From 037bb74114cbde86cba8b50b832a31060aa62f8f Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Tue, 17 Nov 2026 03:18:14 +0000 Subject: [PATCH 1/2] fix(provider-opencode): goal turns end when OpenCode pauses the goal silently An OpenCode goal-mode turn stayed Working forever when OpenCode paused the goal without emitting a goal change to T3's server, for example when another OpenCode process's startup sweep paused it. The adapter held the completed turn open on its cached "active" goal and only a goal.changed event could release it. When a completed execution is held by an active goal, re-read the goal from OpenCode (bounded by the existing inventory timeout) and release the turn if it is no longer active, reusing the refresh path already used for unreadable goal updates. Co-Authored-By: Claude Opus 5.5 --- .../Adapters/OpenCode2AdapterV2.test.ts | 24 ++++++--- .../src/server/v2/adapter.ts | 51 ++++++++++--------- 2 files changed, 45 insertions(+), 30 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts index e4c985daa1652..8b2b8ec9a32c6 100644 --- a/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts @@ -8074,12 +8074,13 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => { ); it.effect.each([ - { status: "complete", reconnect: false }, - { status: "paused", reconnect: false }, - { status: "complete", reconnect: true }, + { status: "complete", reconnect: false, silent: false }, + { status: "paused", reconnect: false, silent: false }, + { status: "complete", reconnect: true, silent: false }, + { status: "paused", reconnect: false, silent: true }, ] as const)( - "keeps an OpenCode goal turn open until $status, with reconnect $reconnect", - ({ status, reconnect }) => + "keeps an OpenCode goal turn open until $status, with reconnect $reconnect and silent $silent", + ({ status, reconnect, silent }) => Effect.gen(function* () { const recovered = reconnected({ [SESSION]: { type: "running" } }); const { runtime, thread } = yield* resumed( @@ -8092,6 +8093,8 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => { reply("session.command", null), event("rpc.opencode.goal.changed", { sessionID: SESSION, goal: nativeGoal("active") }), event("session.execution.succeeded", { sessionID: SESSION }), + out("rpc.call", ""), + reply("rpc.call", { output: nativeGoal(silent ? status : "active") }), ...(status === "complete" ? reconnect ? [ @@ -8104,7 +8107,14 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => { ] : [event("session.execution.started", { sessionID: SESSION })] : []), - event("rpc.opencode.goal.changed", { sessionID: SESSION, goal: nativeGoal(status) }), + ...(silent + ? [] + : [ + event("rpc.opencode.goal.changed", { + sessionID: SESSION, + goal: nativeGoal(status), + }), + ]), ...(status === "complete" ? [ event("session.text.ended", { @@ -8273,6 +8283,8 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => { reply("rpc.call", { output: recovered === "unreadable" ? {} : nativeGoal(recovered) }), ...(recovered === "active" ? [ + out("rpc.call", ""), + reply("rpc.call", { output: nativeGoal("active") }), event("session.execution.started", { sessionID: SESSION }), event("session.text.ended", { sessionID: SESSION, diff --git a/packages/provider-opencode/src/server/v2/adapter.ts b/packages/provider-opencode/src/server/v2/adapter.ts index 2d787b0c5f0b9..34508313795ff 100644 --- a/packages/provider-opencode/src/server/v2/adapter.ts +++ b/packages/provider-opencode/src/server/v2/adapter.ts @@ -3182,6 +3182,9 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr ) { if (end.status === "completed" && (turn.steers.size > 0 || goalHoldsTurn(state))) { turn.heldEnd = end; + // OpenCode can pause a goal without telling this server, such as another process's + // restart sweep, so confirm the goal is still active before waiting on it. + if (goalHoldsTurn(state) && !state.goalRefreshing) yield* refreshGoal(state); return; } yield* finishTurn(state, end); @@ -3192,6 +3195,29 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr ? finishTurn(state, turn.heldEnd) : Effect.void; + // Holds a goal turn until OpenCode's goal is read again; a failed read releases it. + const refreshGoal = Effect.fnUntraced(function* (state: ThreadState) { + state.goalFresh = false; + state.goalRefreshing = true; + state.goalRevision += 1; + const revision = state.goalRevision; + yield* Effect.forkIn( + readGoal(state).pipe( + Effect.timeout(INVENTORY_TIMEOUT), + Effect.catch(() => Effect.logWarning("Could not refresh OpenCode goal state.")), + Effect.ensuring( + lock.withPermit( + Effect.gen(function* () { + if (state.goalRevision === revision) state.goalRefreshing = false; + if (state.active !== undefined) yield* endIfSettled(state, state.active); + }), + ), + ), + ), + sessionScope, + ); + }); + const handleEvent = Effect.fnUntraced(function* (event: OpenCode2Client.OpenCode2StreamEvent) { if (event.type === "shell.created") { const sessionId = stringField(event.data.info.metadata, "sessionID"); @@ -3353,33 +3379,10 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr if (!supportsNativeGoals()) return; const goal = yield* decodeGoal(event.data["goal"]).pipe(Effect.result); if (goal._tag === "Failure") { - state.goalFresh = false; - state.goalRefreshing = true; - state.goalRevision += 1; - const revision = state.goalRevision; yield* Effect.logWarning( "Could not decode an OpenCode goal update; refreshing its state.", ); - yield* Effect.forkIn( - readGoal(state).pipe( - Effect.timeout(INVENTORY_TIMEOUT), - Effect.catch(() => - Effect.logWarning( - "Could not refresh OpenCode goal state after an unreadable update.", - ), - ), - Effect.ensuring( - lock.withPermit( - Effect.gen(function* () { - if (state.goalRevision === revision) state.goalRefreshing = false; - if (state.active !== undefined) yield* endIfSettled(state, state.active); - }), - ), - ), - ), - sessionScope, - ); - return; + return yield* refreshGoal(state); } yield* updateGoal(state, goal.success); if (state.active !== undefined) yield* endIfSettled(state, state.active); From 0827702e9cf5063967322f1161384d73f7400b13 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Tue, 17 Nov 2026 03:51:32 +0000 Subject: [PATCH 2/2] fix(provider-opencode): a superseded goal refresh no longer settles the turn A goal refresh that a reconnect superseded still called endIfSettled when it finished. Reconnect clears the goal flags before its own goal read, so the held turn ended while that read was pending, before OpenCode continued an active goal. readGoal now reports whether it applied its result, and a refresh that neither applied nor still owns the current revision leaves settlement to whoever superseded it. Co-Authored-By: Claude Opus 5.5 --- .../Adapters/OpenCode2AdapterV2.test.ts | 58 +++++++++++++++++++ .../src/server/v2/adapter.ts | 14 +++-- 2 files changed, 68 insertions(+), 4 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts index 8b2b8ec9a32c6..cd1bdc9044a5c 100644 --- a/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts @@ -8261,6 +8261,64 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => { }), ); + it.effect("a goal refresh that reconnect supersedes leaves the turn to reconnect's read", () => + Effect.gen(function* () { + const gate = makeProviderReplayGate(["before-reconnect", "reconnect-reading"]); + const recovered = reconnected({ [SESSION]: { type: "running" } }); + const elsewhere = { sessionID: "ses_elsewhere", goal: null }; + const { runtime, thread } = yield* resumed( + [ + out("session.prompt", { sessionID: SESSION, id: PROMPT_ID, text: "" }), + promptAccepted, + event("rpc.opencode.goal.changed", { sessionID: SESSION, goal: nativeGoal("active") }), + event("session.execution.succeeded", { sessionID: SESSION }), + out("rpc.call", ""), + reply("rpc.call", ""), + event("rpc.opencode.goal.changed", elsewhere, "before-reconnect"), + ...recovered.slice(0, 2), + out("rpc.call", ""), + event("rpc.opencode.goal.changed", elsewhere, "reconnect-reading"), + reply("rpc.call", { output: nativeGoal("active") }), + ...emptyShellInventory, + ...recovered.slice(2), + ...noOpenRequests, + event("session.execution.started", { sessionID: SESSION }), + event("session.text.ended", { + sessionID: SESSION, + assistantMessageID: "msg_goal_final", + ordinal: 0, + text: "Final goal output", + }), + event("rpc.opencode.goal.changed", { sessionID: SESSION, goal: nativeGoal("complete") }), + event("session.execution.succeeded", { sessionID: SESSION }), + ], + { version: "2.2.5", replayGate: gate }, + ); + const events = yield* runtime.events.pipe( + Stream.takeUntil((e) => e.type === "turn.terminal"), + Stream.runCollect, + Effect.forkScoped, + ); + yield* runtime.startTurn(turnInput(thread)); + yield* Effect.promise(() => gate.waitForReached("before-reconnect")); + yield* TestClock.adjust("3 seconds"); + gate.release("before-reconnect"); + yield* Effect.promise(() => gate.waitForReached("reconnect-reading")); + yield* TestClock.adjust("2 seconds"); + gate.release("reconnect-reading"); + const collected = yield* Fiber.join(events); + assert.isTrue( + collected.some( + (e) => + e.type === "turn_item.updated" && + e.turnItem.type === "assistant_message" && + e.turnItem.text === "Final goal output", + ), + ); + assert.deepInclude(collected.at(-1), { type: "turn.terminal", status: "completed" }); + }), + ); + it.effect.each([ { initial: "active", recovered: "paused" }, { initial: "paused", recovered: "active" }, diff --git a/packages/provider-opencode/src/server/v2/adapter.ts b/packages/provider-opencode/src/server/v2/adapter.ts index 34508313795ff..0072f9d1897b7 100644 --- a/packages/provider-opencode/src/server/v2/adapter.ts +++ b/packages/provider-opencode/src/server/v2/adapter.ts @@ -1052,9 +1052,11 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr input: { sessionID: state.sessionId }, }); const goal = yield* decodeGoal(result.output); - yield* lock.withPermit( + return yield* lock.withPermit( Effect.gen(function* () { - if (state.goalRevision === revision) yield* updateGoal(state, goal); + if (state.goalRevision !== revision) return false; + yield* updateGoal(state, goal); + return true; }), ); }); @@ -3204,11 +3206,15 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr yield* Effect.forkIn( readGoal(state).pipe( Effect.timeout(INVENTORY_TIMEOUT), - Effect.catch(() => Effect.logWarning("Could not refresh OpenCode goal state.")), - Effect.ensuring( + Effect.catch(() => + Effect.logWarning("Could not refresh OpenCode goal state.").pipe(Effect.as(false)), + ), + Effect.flatMap((applied) => lock.withPermit( Effect.gen(function* () { if (state.goalRevision === revision) state.goalRefreshing = false; + // A newer goal event or a reconnect's read owns settlement now. + else if (!applied) return; if (state.active !== undefined) yield* endIfSettled(state, state.active); }), ),