fix(run): align mini with current session contracts (#35354)

packages/opencode/test/cli/run/entry.body.test.ts

@@ -50,6 +50,23 @@ function structured(next: StreamCommit) {
 }
 
 describe("run entry body", () => {
+  test("renders a failed direct shell as an error instead of completed success", () => {
+    expect(
+      entryBody(
+        commit({
+          kind: "tool",
+          text: "Shell exited with code 7",
+          phase: "final",
+          source: "tool",
+          tool: "bash",
+          toolState: "error",
+          toolError: "Shell exited with code 7",
+          shell: { callID: "sh_failed", command: "false" },
+        }),
+      ),
+    ).toEqual({ type: "text", content: "✖ bash failed: Shell exited with code 7" })
+  })
+
   test("renders assistant, reasoning, and user entries in their display formats", () => {
     expect(
       entryBody(

packages/opencode/test/cli/run/runtime.test.ts

@@ -1,7 +1,7 @@
 import { afterEach, describe, expect, mock, spyOn, test } from "bun:test"
 import { OpencodeClient } from "@opencode-ai/sdk/v2"
 import { runInteractiveMode } from "@/cli/cmd/run/runtime"
-import type { FooterApi, RunProvider } from "@/cli/cmd/run/types"
+import type { FooterApi, FooterEvent, RunProvider } from "@/cli/cmd/run/types"
 
 const provider: RunProvider = {
   id: "openai",
@@ -53,7 +53,7 @@ function ok<T>(data: T) {
   })
 }
 
-function footer(): FooterApi {
+function footer(events: FooterEvent[] = []): FooterApi {
   let closed = false
   const closes = new Set<() => void>()
 
@@ -78,7 +78,9 @@ function footer(): FooterApi {
         closes.delete(fn)
       }
     },
-    event() {},
+    event(value) {
+      events.push(value)
+    },
     append() {},
     idle() {
       return Promise.resolve()
@@ -296,4 +298,183 @@ describe("run interactive runtime", () => {
     expect(legacyAgents).not.toHaveBeenCalled()
     expect(legacyCommands).not.toHaveBeenCalled()
   })
+
+  test("retains last-known-good state across failed coalesced refreshes and retries later", async () => {
+    const sdk = new OpencodeClient()
+    const refreshGate = defer<void>()
+    let providerCalls = 0
+    let modelCalls = 0
+    let agentCalls = 0
+    let referenceCalls = 0
+    const events: FooterEvent[] = []
+    const api = footer(events)
+    spyOn(sdk.v2.provider, "list").mockImplementation(async () => {
+      providerCalls++
+      if (providerCalls === 2) {
+        await refreshGate.promise
+        throw new Error("provider refresh failed")
+      }
+      return ok({
+        location: { directory: "/tmp" },
+        data: [
+          {
+            id: "openai",
+            name: providerCalls >= 3 ? "OpenAI refreshed" : "OpenAI",
+            api: { type: "native", settings: {} },
+            request: { headers: {}, body: {} },
+          },
+        ],
+      }) as never
+    })
+    spyOn(sdk.v2.model, "list").mockImplementation(() => {
+      modelCalls++
+      return ok({
+        location: { directory: "/tmp" },
+        data: [
+          {
+            id: "gpt-5",
+            providerID: "openai",
+            name: "Little Frank",
+            api: { id: "openai", type: "native", settings: {} },
+            capabilities: { tools: true, input: ["text"], output: ["text"] },
+            request: { headers: {}, body: {} },
+            variants:
+              modelCalls >= 4
+                ? []
+                : [{ id: modelCalls >= 3 ? "high" : "low", settings: {}, headers: {}, body: {} }],
+            time: { released: 1 },
+            cost: [{ input: 0, output: 0, cache: { read: 0, write: 0 } }],
+            status: "active",
+            enabled: true,
+            limit: { context: modelCalls >= 3 ? 256000 : 128000, output: 8192 },
+          },
+        ],
+      }) as never
+    })
+    spyOn(sdk.v2.agent, "list").mockImplementation(async () => {
+      agentCalls++
+      if (agentCalls === 2) throw new Error("agent refresh failed")
+      return ok({
+        location: { directory: "/tmp" },
+        data: [{ id: "build", description: agentCalls >= 3 ? "Refreshed agent" : "Agent", mode: "primary" }],
+      }) as never
+    })
+    spyOn(sdk.v2.reference, "list").mockImplementation(() => {
+      referenceCalls++
+      return ok({
+        location: { directory: "/tmp" },
+        data: [
+          { name: "effect", path: "/effect", description: referenceCalls >= 3 ? "Refreshed reference" : "Reference" },
+        ],
+      }) as never
+    })
+    spyOn(sdk.v2.command, "list").mockImplementation(() =>
+      ok({ location: { directory: "/tmp" }, data: [{ name: "check", description: "Check" }] }) as never,
+    )
+    spyOn(sdk.v2.skill, "list").mockImplementation(() =>
+      ok({ location: { directory: "/tmp" }, data: [] }) as never,
+    )
+    let finalProviders: RunProvider[] = []
+    let finalLimits: Record<string, number> = {}
+    let retainedProviders: RunProvider[] = []
+    let retainedLimits: Record<string, number> = {}
+    let retainedCatalog: FooterEvent | undefined
+    let selectedDefault: unknown
+    let selectDefault: (() => unknown) | undefined
+    let selectVariant: ((variant: string | undefined) => unknown) | undefined
+    let defaultRefreshVariants: FooterEvent | undefined
+
+    await runInteractiveMode(
+      {
+        sdk,
+        directory: "/tmp",
+        sessionID: "ses-1",
+        sessionTitle: "Session",
+        resume: false,
+        agent: "build",
+        model: { providerID: "openai", modelID: "gpt-5" },
+        variant: "low",
+        files: [],
+        thinking: false,
+        backgroundSubagents: false,
+      },
+      {
+        createRuntimeLifecycle: async (input) => {
+          selectDefault = () => input.onVariantSelect?.(undefined)
+          selectVariant = (variant) => input.onVariantSelect?.(variant)
+          return {
+            footer: api,
+            onResize: () => () => {},
+            refreshTheme: () => {},
+            resetForReplay: () => Promise.resolve(),
+            close: () => Promise.resolve(),
+          }
+        },
+        streamTransport: Promise.resolve({
+          createSessionTransport: async (input) => {
+            while (
+              !events.some(
+                (event) => event.type === "variants" && event.variants.includes("low") && event.current === "low",
+              )
+            )
+              await Bun.sleep(0)
+            selectedDefault = await Promise.resolve(selectDefault?.())
+            input.onCatalogRefresh?.()
+            input.onCatalogRefresh?.()
+            input.onCatalogRefresh?.()
+            while (providerCalls < 2) await Bun.sleep(0)
+            refreshGate.resolve()
+            await new Promise((resolve) => setTimeout(resolve, 0))
+            retainedProviders = input.providers?.() ?? []
+            retainedLimits = input.limits()
+            retainedCatalog = events.filter((event) => event.type === "catalog").at(-1)
+            input.onCatalogRefresh?.()
+            input.onCatalogRefresh?.()
+            while (providerCalls < 3 || modelCalls < 3 || agentCalls < 3) await Bun.sleep(0)
+            await new Promise((resolve) => setTimeout(resolve, 0))
+            defaultRefreshVariants = events.filter((event) => event.type === "variants").at(-1)
+            await Promise.resolve(selectVariant?.("high"))
+            input.onCatalogRefresh?.()
+            while (providerCalls < 4 || modelCalls < 4) await Bun.sleep(0)
+            await new Promise((resolve) => setTimeout(resolve, 0))
+            finalProviders = input.providers?.() ?? []
+            finalLimits = input.limits()
+            setTimeout(() => input.footer.close(), 0)
+            return {
+              runPromptTurn: async () => {},
+              interruptActiveTurn: async () => {},
+              selectSubagent: () => {},
+              replayOnResize: async () => false,
+              close: async () => {},
+            }
+          },
+          formatUnknownError: (error: unknown) => (error instanceof Error ? error.message : String(error)),
+        }),
+      },
+    )
+
+    expect(providerCalls).toBe(4)
+    expect(modelCalls).toBe(4)
+    expect(retainedProviders[0]?.name).toBe("OpenAI")
+    expect(retainedProviders[0]?.models["gpt-5"]?.variants).toEqual({ low: {} })
+    expect(retainedLimits["openai/gpt-5"]).toBe(128000)
+    expect(retainedCatalog).toMatchObject({
+      agents: [{ name: "build", description: "Agent" }],
+      references: [{ name: "effect", description: "Reference" }],
+    })
+    expect(selectedDefault).toMatchObject({ variant: undefined })
+    expect(defaultRefreshVariants).toMatchObject({ variants: ["high"], current: undefined })
+    expect(finalProviders[0]?.name).toBe("OpenAI refreshed")
+    expect(finalProviders[0]?.models["gpt-5"]?.variants).toEqual({})
+    expect(finalLimits["openai/gpt-5"]).toBe(256000)
+    expect(events.filter((event) => event.type === "variants").at(-1)).toMatchObject({
+      variants: [],
+      current: undefined,
+    })
+    expect(events.filter((event) => event.type === "catalog").at(-1)).toMatchObject({
+      agents: [{ name: "build", description: "Refreshed agent" }],
+      references: [{ name: "effect", description: "Refreshed reference" }],
+      commands: [{ name: "check", description: "Check" }],
+    })
+  })
 })

packages/opencode/test/cli/run/stream-v2.transport.test.ts

@@ -1019,7 +1019,7 @@ describe("V2 mini transport", () => {
       request = input
       queueMicrotask(() => {
         events.push({
-          id: "evt_shell_start",
+          id: input.id ?? "evt_missing",
           created: 0,
           type: "session.shell.started",
           durable: durable("ses_1"),
@@ -1071,7 +1071,7 @@ describe("V2 mini transport", () => {
       includeFiles: true,
     })
 
-    expect(request).toMatchObject({ sessionID: "ses_1", command: "ls" })
+    expect(request).toMatchObject({ sessionID: "ses_1", command: "ls", id: expect.stringMatching(/^evt_/) })
     expect(ui.commits.filter((item) => item.shell)).toMatchObject([
       { phase: "start", tool: "bash", toolState: "running", shell: { callID: "sh_shell", command: "ls" } },
       { phase: "progress", text: "file.txt", toolState: "completed", shell: { callID: "sh_shell", command: "ls" } },
@@ -1123,6 +1123,133 @@ describe("V2 mini transport", () => {
     await transport.close()
   })
 
+  test("does not resolve an owned shell output wait from an unrelated shell", async () => {
+    const events = feed()
+    events.push(connected())
+    const client = sdk({ streams: [events] })
+    const ui = footer()
+    const transport = await createSessionTransport({
+      sdk: client,
+      sessionID: "ses_1",
+      thinking: false,
+      limits: () => ({}),
+      footer: ui.api,
+    })
+    let request: Parameters<OpencodeClient["v2"]["session"]["shell"]>[0] | undefined
+    let complete!: () => void
+    spyOn(client.v2.session, "shell").mockImplementation((input) => {
+      request = input
+      return new Promise<void>((resolve) => {
+        complete = resolve
+      }) as never
+    })
+
+    let done = false
+    const turn = transport
+      .runPromptTurn({
+        agent: undefined,
+        model: undefined,
+        variant: undefined,
+        prompt: { text: "pwd", parts: [], mode: "shell" },
+        files: [],
+        includeFiles: true,
+      })
+      .then(() => {
+        done = true
+      })
+    while (!request) await Bun.sleep(0)
+    events.push({
+      id: "evt_unrelated_shell",
+      created: 0,
+      type: "session.shell.started",
+      durable: durable("ses_1"),
+      data: {
+        sessionID: "ses_1",
+        shell: {
+          id: "sh_unrelated",
+          status: "running",
+          command: "other",
+          cwd: "/tmp",
+          shell: "/bin/sh",
+          file: "/tmp/unrelated",
+          metadata: {},
+          time: { started: 0 },
+        },
+      },
+    })
+    events.push({
+      id: "evt_unrelated_end",
+      created: 0,
+      type: "session.shell.ended",
+      durable: durable("ses_1", 1),
+      data: {
+        sessionID: "ses_1",
+        shell: {
+          id: "sh_unrelated",
+          status: "exited",
+          command: "other",
+          cwd: "/tmp",
+          shell: "/bin/sh",
+          file: "/tmp/unrelated",
+          exit: 0,
+          metadata: {},
+          time: { started: 0, completed: 1 },
+        },
+        output: { output: "wrong", cursor: 5, size: 5, truncated: false },
+      },
+    })
+    await Bun.sleep(0)
+    complete()
+    await Bun.sleep(0)
+    expect(done).toBe(false)
+
+    events.push({
+      id: request.id ?? "evt_missing",
+      created: 0,
+      type: "session.shell.started",
+      durable: durable("ses_1", 2),
+      data: {
+        sessionID: "ses_1",
+        shell: {
+          id: "sh_owned",
+          status: "running",
+          command: "pwd",
+          cwd: "/tmp",
+          shell: "/bin/sh",
+          file: "/tmp/owned",
+          metadata: {},
+          time: { started: 0 },
+        },
+      },
+    })
+    events.push({
+      id: "evt_owned_end",
+      created: 0,
+      type: "session.shell.ended",
+      durable: durable("ses_1", 3),
+      data: {
+        sessionID: "ses_1",
+        shell: {
+          id: "sh_owned",
+          status: "exited",
+          command: "pwd",
+          cwd: "/tmp",
+          shell: "/bin/sh",
+          file: "/tmp/owned",
+          exit: 0,
+          metadata: {},
+          time: { started: 0, completed: 1 },
+        },
+        output: { output: "/tmp", cursor: 4, size: 4, truncated: false },
+      },
+    })
+    await turn
+
+    expect(request.id).toMatch(/^evt_/)
+    expect(ui.commits.some((item) => item.shell?.callID === "sh_owned" && item.text === "/tmp")).toBe(true)
+    await transport.close()
+  })
+
   test("hydrates projected shell transcripts once and dedupes live redelivery", async () => {
     const events = feed()
     events.push(connected())
@@ -1190,6 +1317,91 @@ describe("V2 mini transport", () => {
     await transport.close()
   })
 
+  test("renders failed projected shells as errors and marks truncated live output", async () => {
+    const events = feed()
+    events.push(connected())
+    const client = sdk({
+      streams: [events],
+      messages: {
+        ses_1: [
+          {
+            id: "msg_failed_shell",
+            type: "shell" as const,
+            shell: {
+              id: "sh_failed",
+              status: "exited",
+              command: "false",
+              cwd: "/tmp",
+              shell: "/bin/sh",
+              file: "/tmp/failed",
+              exit: 7,
+              metadata: {},
+              time: { started: 0, completed: 1 },
+            },
+            output: { output: "failure output", cursor: 14, size: 14, truncated: false },
+            time: { created: 1, completed: 2 },
+          },
+        ],
+      },
+    })
+    const ui = footer()
+    const transport = await createSessionTransport({
+      sdk: client,
+      sessionID: "ses_1",
+      thinking: false,
+      replay: true,
+      limits: () => ({}),
+      footer: ui.api,
+    })
+    events.push({
+      id: "evt_truncated_start",
+      created: 0,
+      type: "session.shell.started",
+      durable: durable("ses_1"),
+      data: {
+        sessionID: "ses_1",
+        shell: {
+          id: "sh_truncated",
+          status: "running",
+          command: "long",
+          cwd: "/tmp",
+          shell: "/bin/sh",
+          file: "/tmp/truncated",
+          metadata: {},
+          time: { started: 0 },
+        },
+      },
+    })
+    events.push({
+      id: "evt_truncated_end",
+      created: 0,
+      type: "session.shell.ended",
+      durable: durable("ses_1", 1),
+      data: {
+        sessionID: "ses_1",
+        shell: {
+          id: "sh_truncated",
+          status: "exited",
+          command: "long",
+          cwd: "/tmp",
+          shell: "/bin/sh",
+          file: "/tmp/truncated",
+          exit: 0,
+          metadata: {},
+          time: { started: 0, completed: 1 },
+        },
+        output: { output: "partial", cursor: 7, size: 20, truncated: false },
+      },
+    })
+    await Bun.sleep(0)
+
+    expect(ui.commits).toContainEqual(
+      expect.objectContaining({ toolState: "error", toolError: "Shell exited with code 7" }),
+    )
+    expect(ui.commits).toContainEqual(expect.objectContaining({ text: "partial\n[output truncated]" }))
+    await transport.close()
+  })
+
   test("routes command prompts through v2.session.command", async () => {
     const events = feed()
     events.push(connected())
@@ -1363,6 +1575,17 @@ describe("V2 mini transport", () => {
         done = true
       })
     while (!sent) await Bun.sleep(0)
+    events.push({
+      id: "evt_other",
+      created: 0,
+      type: "session.skill.activated",
+      durable: durable("ses_1"),
+      data: {
+        sessionID: "ses_1",
+        name: "other",
+        text: "other instructions",
+      },
+    })
     events.push({
       id: "evt_unrelated_settled",
       created: 0,
@@ -1396,6 +1619,46 @@ describe("V2 mini transport", () => {
     await transport.close()
   })
 
+  test("refreshes catalogs on connection and location-scoped invalidations", async () => {
+    const events = feed()
+    events.push(connected())
+    const client = sdk({ streams: [events] })
+    const ui = footer()
+    let refreshes = 0
+    const transport = await createSessionTransport({
+      sdk: client,
+      directory: "/project",
+      sessionID: "ses_1",
+      thinking: false,
+      limits: () => ({}),
+      footer: ui.api,
+      onCatalogRefresh: () => refreshes++,
+    })
+    expect(refreshes).toBe(1)
+
+    for (const type of [
+      "catalog.updated",
+      "integration.updated",
+      "agent.updated",
+      "command.updated",
+      "skill.updated",
+      "reference.updated",
+    ] as const)
+      events.push({ id: `evt_${type}`, created: 0, type, location: { directory: "/project" }, data: {} })
+    events.push({
+      id: "evt_foreign_catalog",
+      created: 0,
+      type: "catalog.updated",
+      location: { directory: "/other" },
+      data: {},
+    })
+    while (refreshes < 7) await Bun.sleep(0)
+    await Bun.sleep(0)
+
+    expect(refreshes).toBe(7)
+    await transport.close()
+  })
+
   test("hydrates skill activation messages once and dedupes live redelivery", async () => {
     const events = feed()
     events.push(connected())
@@ -1526,6 +1789,328 @@ describe("V2 mini transport", () => {
     await transport.close()
   })
 
+  test("reveals an admitted child prompt only when it is promoted after hydration", async () => {
+    const events = feed()
+    events.push(connected())
+    const client = sdk({
+      streams: [events],
+      messages: { ses_child: [] },
+      sessions: [{ id: "ses_child", parentID: "ses_1", time: { updated: 1 } }],
+    })
+    const ui = footer()
+    const transport = await createSessionTransport({
+      sdk: client,
+      sessionID: "ses_1",
+      thinking: false,
+      limits: () => ({}),
+      footer: ui.api,
+    })
+    const states = () => ui.events.flatMap((event) => (event.type === "stream.subagent" ? [event.state] : []))
+    transport.selectSubagent("ses_child")
+    while (!states().some((state) => state.details.ses_child)) await Bun.sleep(0)
+
+    events.push({
+      id: "evt_child_admitted",
+      created: 1,
+      type: "session.prompt.admitted",
+      durable: durable("ses_child"),
+      data: {
+        sessionID: "ses_child",
+        inputID: "msg_child_prompt",
+        prompt: { text: "actual child prompt" },
+        delivery: "steer",
+      },
+    })
+    await Bun.sleep(0)
+    expect(
+      states().at(-1)?.details.ses_child?.commits.some((item) => item.messageID === "msg_child_prompt"),
+    ).toBe(false)
+
+    events.push({
+      id: "evt_child_promoted",
+      created: 2,
+      type: "session.prompt.promoted",
+      durable: durable("ses_child", 1),
+      data: { sessionID: "ses_child", inputID: "msg_child_prompt" },
+    })
+    while (
+      !states()
+        .at(-1)
+        ?.details.ses_child?.commits.some(
+          (item) => item.messageID === "msg_child_prompt" && item.text === "actual child prompt",
+        )
+    )
+      await Bun.sleep(0)
+
+    await transport.close()
+  })
+
+  test("preserves a pre-hydration admission promoted during stale hydration", async () => {
+    const events = feed()
+    events.push(connected())
+    const client = sdk({
+      streams: [events],
+      sessions: [{ id: "ses_child", parentID: "ses_1", time: { updated: 1 } }],
+    })
+    let childHydrating = false
+    let releaseHydration!: () => void
+    const hydration = new Promise<void>((resolve) => {
+      releaseHydration = resolve
+    })
+    spyOn(client.v2.session, "messages").mockImplementation(async (request) => {
+      if (request.sessionID === "ses_child") {
+        childHydrating = true
+        await hydration
+      }
+      return ok({ data: [], cursor: {} })
+    })
+    const ui = footer()
+    const transport = await createSessionTransport({
+      sdk: client,
+      sessionID: "ses_1",
+      thinking: false,
+      limits: () => ({}),
+      footer: ui.api,
+    })
+    const states = () => ui.events.flatMap((event) => (event.type === "stream.subagent" ? [event.state] : []))
+    events.push({
+      id: "evt_child_admitted_race",
+      created: 1,
+      type: "session.prompt.admitted",
+      durable: durable("ses_child"),
+      data: {
+        sessionID: "ses_child",
+        inputID: "msg_child_race",
+        prompt: { text: "prompt admitted before hydration" },
+        delivery: "steer",
+      },
+    })
+    await Bun.sleep(0)
+    transport.selectSubagent("ses_child")
+    while (!childHydrating) await Bun.sleep(0)
+    events.push({
+      id: "evt_child_promoted_race",
+      created: 2,
+      type: "session.prompt.promoted",
+      durable: durable("ses_child", 1),
+      data: { sessionID: "ses_child", inputID: "msg_child_race" },
+    })
+    await Bun.sleep(0)
+    releaseHydration()
+    await Bun.sleep(0)
+    await Bun.sleep(0)
+    while (
+      !states()
+        .at(-1)
+        ?.details.ses_child?.commits.some(
+          (item) => item.messageID === "msg_child_race" && item.text === "prompt admitted before hydration",
+        )
+    )
+      await Bun.sleep(0)
+
+    await transport.close()
+  })
+
+  test("retries child hydration after a bounded live-event overflow", async () => {
+    const events = feed()
+    events.push(connected())
+    const client = sdk({
+      streams: [events],
+      sessions: [{ id: "ses_child", parentID: "ses_1", time: { updated: 1 } }],
+    })
+    let childRequests = 0
+    let releaseStale!: () => void
+    let releaseRetry!: () => void
+    const stale = new Promise<void>((resolve) => {
+      releaseStale = resolve
+    })
+    const retry = new Promise<void>((resolve) => {
+      releaseRetry = resolve
+    })
+    spyOn(client.v2.session, "messages").mockImplementation(async (request) => {
+      if (request.sessionID !== "ses_child") return ok({ data: [], cursor: {} })
+      childRequests++
+      if (childRequests === 1) {
+        await stale
+        return ok({ data: [], cursor: {} })
+      }
+      await retry
+      return ok({
+        data: [
+          {
+            id: "msg_overflow_assistant",
+            type: "assistant" as const,
+            agent: "explore",
+            model: { providerID: "test", id: "model" },
+            content: [{ type: "text" as const, id: "txt_overflow_64", text: "live 64" }],
+            time: { created: 2, completed: 3 },
+          },
+          {
+            id: "msg_overflow_baseline",
+            type: "user" as const,
+            text: "baseline history",
+            files: [],
+            agents: [],
+            time: { created: 1 },
+          },
+        ],
+        cursor: {},
+      })
+    })
+    const ui = footer()
+    const transport = await createSessionTransport({
+      sdk: client,
+      sessionID: "ses_1",
+      thinking: false,
+      limits: () => ({}),
+      footer: ui.api,
+    })
+    const states = () => ui.events.flatMap((event) => (event.type === "stream.subagent" ? [event.state] : []))
+    transport.selectSubagent("ses_child")
+    while (childRequests < 1) await Bun.sleep(0)
+
+    for (let index = 0; index < 65; index++)
+      events.push({
+        id: `evt_overflow_${index}`,
+        created: index,
+        type: "session.text.delta",
+        data: {
+          sessionID: "ses_child",
+          assistantMessageID: "msg_overflow_assistant",
+          textID: `txt_overflow_${index}`,
+          delta: `live ${index}`,
+        },
+      })
+    while (!states().at(-1)?.details.ses_child?.commits.some((item) => item.text === "live 64")) await Bun.sleep(0)
+    releaseStale()
+    while (childRequests < 2) await Bun.sleep(0)
+    expect(states().at(-1)?.details.ses_child?.commits.some((item) => item.text === "live 64")).toBe(true)
+
+    releaseRetry()
+    while (!states().at(-1)?.details.ses_child?.commits.some((item) => item.text === "baseline history"))
+      await Bun.sleep(0)
+    expect(states().at(-1)?.details.ses_child?.commits.some((item) => item.text === "live 64")).toBe(true)
+    expect(childRequests).toBe(2)
+    await transport.close()
+  })
+
+  test("reconciles pre-hydration tool metadata without downgrading projected completion", async () => {
+    const events = feed()
+    events.push(connected())
+    const client = sdk({
+      streams: [events],
+      sessions: [{ id: "ses_child", parentID: "ses_1", time: { updated: 1 } }],
+    })
+    let childHydrating = false
+    let releaseHydration!: () => void
+    const hydration = new Promise<void>((resolve) => {
+      releaseHydration = resolve
+    })
+    spyOn(client.v2.session, "messages").mockImplementation(async (request) => {
+      if (request.sessionID !== "ses_child") return ok({ data: [], cursor: {} })
+      childHydrating = true
+      await hydration
+      return ok({
+        data: [
+          {
+            id: "msg_tool_projected",
+            type: "assistant" as const,
+            agent: "explore",
+            model: { providerID: "test", id: "model" },
+            content: [
+              {
+                type: "tool" as const,
+                id: "call_overlap",
+                name: "bash",
+                state: {
+                  status: "completed" as const,
+                  input: { command: "projected" },
+                  content: [{ type: "text" as const, text: "projected result" }],
+                  structured: {},
+                },
+                time: { created: 1, ran: 1, completed: 2 },
+              },
+            ],
+            time: { created: 1, completed: 2 },
+          },
+        ],
+        cursor: {},
+      })
+    })
+    const ui = footer()
+    const transport = await createSessionTransport({
+      sdk: client,
+      sessionID: "ses_1",
+      thinking: false,
+      limits: () => ({}),
+      footer: ui.api,
+    })
+    const states = () => ui.events.flatMap((event) => (event.type === "stream.subagent" ? [event.state] : []))
+    const inputStarted = (callID: string, name: string, seq: number) =>
+      events.push({
+        id: `evt_started_${callID}`,
+        created: seq,
+        type: "session.tool.input.started",
+        durable: durable("ses_child", seq),
+        data: { sessionID: "ses_child", assistantMessageID: "msg_tool_projected", callID, name },
+      })
+    const called = (callID: string, tool: string, input: Record<string, unknown>, seq: number) =>
+      events.push({
+        id: `evt_called_${callID}`,
+        created: seq,
+        type: "session.tool.called",
+        durable: durable("ses_child", seq),
+        data: {
+          sessionID: "ses_child",
+          assistantMessageID: "msg_tool_projected",
+          callID,
+          tool,
+          input,
+          provider: { executed: true },
+        },
+      })
+
+    inputStarted("call_terminal", "grep", 0)
+    called("call_terminal", "grep", { pattern: "needle" }, 1)
+    await Bun.sleep(0)
+    transport.selectSubagent("ses_child")
+    while (!childHydrating) await Bun.sleep(0)
+    events.push({
+      id: "evt_success_terminal",
+      created: 2,
+      type: "session.tool.success",
+      durable: durable("ses_child", 2),
+      data: {
+        sessionID: "ses_child",
+        assistantMessageID: "msg_tool_projected",
+        callID: "call_terminal",
+        structured: {},
+        content: [{ type: "text", text: "found" }],
+        provider: { executed: true },
+      },
+    })
+    inputStarted("call_overlap", "bash", 3)
+    called("call_overlap", "bash", { command: "stale" }, 4)
+    await Bun.sleep(0)
+    const beforeHydration = states().length
+    releaseHydration()
+    while (states().length === beforeHydration) await Bun.sleep(0)
+    await Bun.sleep(0)
+
+    const commits = states().at(-1)?.details.ses_child?.commits ?? []
+    expect(commits.find((item) => item.partID === "prt_call_terminal")).toMatchObject({
+      tool: "grep",
+      toolState: "completed",
+      part: { state: { input: { pattern: "needle" } } },
+    })
+    expect(commits.find((item) => item.partID === "prt_call_overlap")).toMatchObject({
+      tool: "bash",
+      toolState: "completed",
+      part: { state: { input: { command: "projected" } } },
+    })
+    await transport.close()
+  })
+
   test("keeps child terminal state observed during discovery", async () => {
     const events = feed()
     events.push(connected())