From 788584a4e40d434d7ee8e15f7e32b420a4fa13ed Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Thu, 12 Nov 2026 07:44:05 +0000 Subject: [PATCH 1/4] test(opencode): resumed task child turns append to the child's ordinals Fails on main: a Task call that resumes an existing child session by task_id rebuilds the child state with ordinal 1, colliding with the child's first provider turn (#19883). AI-assisted; verified with the tests and tools listed above. Co-Authored-By: Claude Opus 5.5 --- .../src/server/adapter.test.ts | 107 ++++++++++++++++++ 1 file changed, 107 insertions(+) diff --git a/packages/provider-opencode/src/server/adapter.test.ts b/packages/provider-opencode/src/server/adapter.test.ts index 91400661e6eed..a2bba958e104d 100644 --- a/packages/provider-opencode/src/server/adapter.test.ts +++ b/packages/provider-opencode/src/server/adapter.test.ts @@ -1501,6 +1501,113 @@ describe("OpenCodeAdapterV2", () => { ), ); + it.effect("appends a resumed task child's turn after its earlier turns", () => + Effect.gen(function* () { + const nativeEvents = asyncEventStream(); + const push = (event: unknown) => Effect.promise(() => nativeEvents.push(event)); + const root = "ses_root"; + const child = "ses_child"; + let promptId = ""; + const harness = yield* makeOpenCodeRuntimeHarness("resumed-child", root, { + event: { subscribe: async () => ({ stream: nativeEvents.stream }) }, + session: { + create: async () => ({ data: { id: root, time: { created: 1, updated: 1 } } }), + get: async () => ({ + data: { id: child, parentID: root, permission: [], time: { created: 2, updated: 2 } }, + }), + update: async () => ({ data: { id: child, parentID: root } }), + promptAsync: async (input: { messageID: string }) => { + promptId = input.messageID; + return { data: true }; + }, + abort: async () => ({ data: true }), + children: async () => ({ data: [] }), + }, + }); + yield* harness.startTurn(); + const childTurns = yield* harness.runtime.events.pipe( + Stream.filter( + (event) => + event.type === "provider_turn.updated" && + event.providerTurn.status === "running" && + event.providerTurn.providerThreadId.includes(child), + ), + Stream.take(2), + Stream.runCollect, + Effect.forkScoped, + ); + const taskPart = (partId: string, status: "running" | "completed", taskId?: string) => ({ + type: "message.part.updated", + properties: { + sessionID: root, + part: { + id: partId, + sessionID: root, + messageID: "msg_root_assistant", + type: "tool", + tool: "task", + callID: `call_${partId}`, + state: { + status, + input: { + description: "Explore", + prompt: "look around", + subagent_type: "general", + ...(taskId === undefined ? {} : { task_id: taskId }), + }, + title: "Explore", + metadata: { parentSessionId: root, sessionId: child }, + time: { start: 3, ...(status === "completed" ? { end: 4 } : {}) }, + ...(status === "completed" ? { output: "done" } : {}), + }, + }, + }, + }); + const childPrompt = (id: string, created: number) => ({ + type: "message.updated", + properties: { + sessionID: child, + info: { id, sessionID: child, role: "user", time: { created } }, + }, + }); + const status = (sessionID: string, type: "busy" | "idle") => ({ + type: "session.status", + properties: { sessionID, status: { type } }, + }); + + yield* push({ + type: "message.updated", + properties: { + sessionID: root, + info: { id: promptId, sessionID: root, role: "user", time: { created: 1 } }, + }, + }); + yield* push(status(root, "busy")); + yield* push(taskPart("prt_task_first", "running")); + yield* push(childPrompt("msg_child_first", 3)); + yield* push(status(child, "busy")); + yield* push(status(child, "idle")); + yield* push({ type: "session.idle", properties: { sessionID: child } }); + yield* push(taskPart("prt_task_first", "completed")); + // The lead resumes the same child session by passing its task_id. + yield* push(taskPart("prt_task_resume", "running", child)); + yield* push(childPrompt("msg_child_resume", 5)); + yield* push(status(child, "busy")); + + const turns = Array.from(yield* Fiber.join(childTurns)).flatMap((event) => + event.type === "provider_turn.updated" ? [event.providerTurn] : [], + ); + assert.equal(new Set(turns.map((turn) => turn.providerThreadId)).size, 1); + assert.deepEqual( + turns.map((turn) => turn.ordinal), + [1, 2], + ); + }).pipe( + Effect.provide(Layer.merge(IdAllocator.layer, McpProviderSessions.layer)), + Effect.scoped, + ), + ); + it.effect("projects OpenCode read output and search titles from native tool calls", () => Effect.gen(function* () { const directoryOutput = From c0c5884d191ef9a20ee276128bab506f24d70a46 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Thu, 12 Nov 2026 07:56:39 +0000 Subject: [PATCH 2/4] fix(opencode): a resumed task subagent's turn no longer collides with its first A Task call that resumes a child session by task_id rebuilt the child's state with turn ordinal 1, so the resumed turn hit the unique (provider_thread_id, ordinal) index and failed the parent run. The child now keeps its in-memory ordinal and prompt history, and when the adapter no longer holds it (after a restart) the next ordinal follows the child session's earlier user prompts. Fixes pingdotgg/t3code#19883 AI-assisted; verified with the tests and tools listed above. Co-Authored-By: Claude Opus 5.5 --- .../src/server/adapter.test.ts | 27 ++++++++++++------- .../provider-opencode/src/server/adapter.ts | 23 +++++++++++++--- 2 files changed, 38 insertions(+), 12 deletions(-) diff --git a/packages/provider-opencode/src/server/adapter.test.ts b/packages/provider-opencode/src/server/adapter.test.ts index a2bba958e104d..13557406adda8 100644 --- a/packages/provider-opencode/src/server/adapter.test.ts +++ b/packages/provider-opencode/src/server/adapter.test.ts @@ -1501,7 +1501,11 @@ describe("OpenCodeAdapterV2", () => { ), ); - it.effect("appends a resumed task child's turn after its earlier turns", () => + // After a restart the adapter no longer holds the child, so its earlier turns come from OpenCode. + it.effect.each([ + { case: "in memory", restarted: false }, + { case: "after a restart", restarted: true }, + ])("appends a resumed task child's turn after its earlier turns ($case)", ({ restarted }) => Effect.gen(function* () { const nativeEvents = asyncEventStream(); const push = (event: unknown) => Effect.promise(() => nativeEvents.push(event)); @@ -1522,6 +1526,9 @@ describe("OpenCodeAdapterV2", () => { }, abort: async () => ({ data: true }), children: async () => ({ data: [] }), + messages: async () => ({ + data: [{ info: { id: "msg_child_first", role: "user" }, parts: [] }], + }), }, }); yield* harness.startTurn(); @@ -1532,7 +1539,7 @@ describe("OpenCodeAdapterV2", () => { event.providerTurn.status === "running" && event.providerTurn.providerThreadId.includes(child), ), - Stream.take(2), + Stream.take(restarted ? 1 : 2), Stream.runCollect, Effect.forkScoped, ); @@ -1583,12 +1590,14 @@ describe("OpenCodeAdapterV2", () => { }, }); yield* push(status(root, "busy")); - yield* push(taskPart("prt_task_first", "running")); - yield* push(childPrompt("msg_child_first", 3)); - yield* push(status(child, "busy")); - yield* push(status(child, "idle")); - yield* push({ type: "session.idle", properties: { sessionID: child } }); - yield* push(taskPart("prt_task_first", "completed")); + if (!restarted) { + yield* push(taskPart("prt_task_first", "running")); + yield* push(childPrompt("msg_child_first", 3)); + yield* push(status(child, "busy")); + yield* push(status(child, "idle")); + yield* push({ type: "session.idle", properties: { sessionID: child } }); + yield* push(taskPart("prt_task_first", "completed")); + } // The lead resumes the same child session by passing its task_id. yield* push(taskPart("prt_task_resume", "running", child)); yield* push(childPrompt("msg_child_resume", 5)); @@ -1600,7 +1609,7 @@ describe("OpenCodeAdapterV2", () => { assert.equal(new Set(turns.map((turn) => turn.providerThreadId)).size, 1); assert.deepEqual( turns.map((turn) => turn.ordinal), - [1, 2], + restarted ? [2] : [1, 2], ); }).pipe( Effect.provide(Layer.merge(IdAllocator.layer, McpProviderSessions.layer)), diff --git a/packages/provider-opencode/src/server/adapter.ts b/packages/provider-opencode/src/server/adapter.ts index fc3ba8fe2b8f5..9405592dd6390 100644 --- a/packages/provider-opencode/src/server/adapter.ts +++ b/packages/provider-opencode/src/server/adapter.ts @@ -1308,6 +1308,15 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function }); }); + // Each earlier child turn began at a distinct user message, so their count bounds its ordinals. + const nextResumedChildTurnOrdinal = Effect.fnUntraced(function* (childSessionId: string) { + const response = yield* sdkCall("session.messages", { sessionID: childSessionId }, () => + client.session.messages({ sessionID: childSessionId }), + ); + const messages = unwrapData("session.messages", response); + return messages.filter((entry) => entry.info.role === "user").length + 1; + }); + const emitSubagent = Effect.fnUntraced(function* ( state: OpenCodeThreadState, turn: ActiveOpenCodeTurn, @@ -1416,6 +1425,14 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function permission: childPermission, }), ); + // A Task call with task_id resumes the child, whose earlier turns already hold ordinals. + const knownChild = threads.get(childSessionId); + const resumedChild = knownChild?.parentSubagent == null ? undefined : knownChild; + const nextChildTurnOrdinal = + resumedChild?.nextChildTurnOrdinal ?? + (recordString(input, "task_id") === childSessionId + ? yield* nextResumedChildTurnOrdinal(childSessionId) + : 1); threads.set(childSessionId, { nativeSessionId: childSessionId, providerThread: childProviderThread, @@ -1423,10 +1440,10 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function activeTurn: null, providerTurns: new Map(), runtimeRequests: new Map(), - messageRoles: new Map(), - userMessageIds: [], + messageRoles: resumedChild?.messageRoles ?? new Map(), + userMessageIds: resumedChild?.userMessageIds ?? [], parentSubagent: context, - nextChildTurnOrdinal: 1, + nextChildTurnOrdinal, nextAdmissionGeneration: 1, permission: childPermission, inheritedPermission: openCodePermissionRules(turn.runtimePolicy), From 8c82bc49a9d977013a6d42b47895c6fe16b1afb4 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Fri, 13 Nov 2026 16:22:49 +0000 Subject: [PATCH 3/4] docs(opencode): note why the stored user-message count cannot reuse a child ordinal Co-Authored-By: Claude Opus 5.5 --- packages/provider-opencode/src/server/adapter.ts | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/packages/provider-opencode/src/server/adapter.ts b/packages/provider-opencode/src/server/adapter.ts index 918d096cd81c7..049541dfe8d97 100644 --- a/packages/provider-opencode/src/server/adapter.ts +++ b/packages/provider-opencode/src/server/adapter.ts @@ -1308,7 +1308,8 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function }); }); - // Each earlier child turn began at a distinct user message, so their count bounds its ordinals. + // Each earlier child turn began at a distinct user message OpenCode stored before publishing it, + // so their count bounds its ordinals; a stored resume prompt only leaves a gap. const nextResumedChildTurnOrdinal = Effect.fnUntraced(function* (childSessionId: string) { const response = yield* sdkCall("session.messages", { sessionID: childSessionId }, () => client.session.messages({ sessionID: childSessionId }), From 82842a9346f1e8a0bdfe53b1fd75667000bed907 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Fri, 13 Nov 2026 16:36:20 +0000 Subject: [PATCH 4/4] fix(opencode): recover a resumed child's ordinal from its prompt's stored position Counting stored user messages at resume could leave a gap when the resume prompt was already stored, and a later restart could then reuse an ordinal. A recovered child now takes its ordinal from the position of the turn's own user message among the session's stored user messages, which is stable across restarts and never below an earlier ordinal. Co-Authored-By: Claude Opus 5.5 --- .../src/server/adapter.test.ts | 6 +++- .../provider-opencode/src/server/adapter.ts | 34 +++++++++++++------ 2 files changed, 28 insertions(+), 12 deletions(-) diff --git a/packages/provider-opencode/src/server/adapter.test.ts b/packages/provider-opencode/src/server/adapter.test.ts index ba82226c5af74..47cedeefc1c9e 100644 --- a/packages/provider-opencode/src/server/adapter.test.ts +++ b/packages/provider-opencode/src/server/adapter.test.ts @@ -1487,8 +1487,12 @@ describe("OpenCodeAdapterV2", () => { }, abort: async () => ({ data: true }), children: async () => ({ data: [] }), + // OpenCode may have stored the resume prompt before its event reaches the adapter. messages: async () => ({ - data: [{ info: { id: "msg_child_first", role: "user" }, parts: [] }], + data: [ + { info: { id: "msg_child_first", role: "user" }, parts: [] }, + { info: { id: "msg_child_resume", role: "user" }, parts: [] }, + ], }), }, }); diff --git a/packages/provider-opencode/src/server/adapter.ts b/packages/provider-opencode/src/server/adapter.ts index 049541dfe8d97..b017a8861f408 100644 --- a/packages/provider-opencode/src/server/adapter.ts +++ b/packages/provider-opencode/src/server/adapter.ts @@ -378,7 +378,8 @@ interface OpenCodeThreadState { readonly messageRoles: Map; readonly userMessageIds: Array; parentSubagent: OpenCodeSubagentContext | null; - nextChildTurnOrdinal: number; + // null: a child resumed after a restart, whose next ordinal is recovered from OpenCode. + nextChildTurnOrdinal: number | null; nextAdmissionGeneration: number; permission: PermissionRuleset; /** Parent rules last written into this child's `permission`; empty for root sessions. */ @@ -1308,14 +1309,20 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function }); }); - // Each earlier child turn began at a distinct user message OpenCode stored before publishing it, - // so their count bounds its ordinals; a stored resume prompt only leaves a gap. - const nextResumedChildTurnOrdinal = Effect.fnUntraced(function* (childSessionId: string) { + // A child turn's ordinal never exceeds its user message's position in the session, and that + // position survives restarts, so it stays above every ordinal allocated before. + const storedUserMessagePosition = Effect.fnUntraced(function* ( + childSessionId: string, + messageId: string, + ) { const response = yield* sdkCall("session.messages", { sessionID: childSessionId }, () => client.session.messages({ sessionID: childSessionId }), ); - const messages = unwrapData("session.messages", response); - return messages.filter((entry) => entry.info.role === "user").length + 1; + const userMessageIds = unwrapData("session.messages", response).flatMap((entry) => + entry.info.role === "user" ? [entry.info.id] : [], + ); + const index = userMessageIds.indexOf(messageId); + return (index === -1 ? userMessageIds.length : index) + 1; }); const emitSubagent = Effect.fnUntraced(function* ( @@ -1430,10 +1437,11 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function const knownChild = threads.get(childSessionId); const resumedChild = knownChild?.parentSubagent == null ? undefined : knownChild; const nextChildTurnOrdinal = - resumedChild?.nextChildTurnOrdinal ?? - (recordString(input, "task_id") === childSessionId - ? yield* nextResumedChildTurnOrdinal(childSessionId) - : 1); + resumedChild === undefined + ? recordString(input, "task_id") === childSessionId + ? null + : 1 + : resumedChild.nextChildTurnOrdinal; threads.set(childSessionId, { nativeSessionId: childSessionId, providerThread: childProviderThread, @@ -2240,6 +2248,10 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function message: Extract, ) { if (state.appThread === null || state.parentSubagent === null) return null; + const ordinal = + state.nextChildTurnOrdinal ?? + (yield* storedUserMessagePosition(state.nativeSessionId, message.id)); + state.nextChildTurnOrdinal = ordinal + 1; const now = yield* DateTime.now; const startedAt = dateTimeFromEpoch(message.time.created, now); const rootNodeId = idAllocator.derive.nodeFromProviderItem({ @@ -2256,7 +2268,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function nodeId: rootNodeId, runAttemptId: null, nativeTurnRef: providerRef(message.id, "weak"), - ordinal: state.nextChildTurnOrdinal++, + ordinal, status: "running", startedAt, completedAt: null,