Resolve tool result rows by call id instead of tool name

Matching a result to its call row by tool name alone breaks the
moment two calls to the same tool are in flight together, which
parallel sub-agent dispatch does on every turn that fires more than
one task call. The newest pending row of that name absorbed whichever
result landed first, stranding the others pending and turning later
results into orphan rows.

An id that matches nothing on the log now answers nothing rather than
falling back to the newest same-name row, since every current caller
carries a real id. The name-based fallback survives only for callId
undefined, which saved history from before ids were threaded through
this path still produces.

Author: TheGreatAxios

src/tui-opentui/diff.ts

@@ -445,6 +445,8 @@ export type ToolCallRowInput = {
   readonly name: string
   /** Raw JSON arguments as streamed by the model; may be absent or partial. */
   readonly arguments?: string
+  /** Runtime call id, when the source (live bridge, saved history) carried one. */
+  readonly callId?: string
 }
 
 /**
@@ -492,6 +494,7 @@ export function toolCallRow(input: ToolCallRowInput): StreamRow {
     meta,
     pending: true,
     callKey,
+    ...(input.callId !== undefined ? { callId: input.callId } : {}),
     ...(diff !== null ? { diff } : {}),
     ...(verb !== undefined ? { verb } : {}),
     // A summarised call may deliberately have no subject — its verb already

src/tui-opentui/history-hydrate.test.ts

@@ -208,6 +208,23 @@ describe("hydrateHistoryRows", () => {
     ])
   })
 
+  // CL-5562: a resumed transcript with three parallel `task` dispatches has
+  // three tool_call blocks that all share name "task" — the callId each
+  // block carries is what tells them apart on replay.
+  test("resolves parallel same-name tool_call/tool_result pairs by callId", () => {
+    const rows = hydrateHistoryRows([
+      { type: "tool_call", name: "task", arguments: '{"description":"Fix CL-5559"}', callId: "c1" },
+      { type: "tool_call", name: "task", arguments: '{"description":"Fix CL-5560"}', callId: "c2" },
+      { type: "tool_call", name: "task", arguments: '{"description":"Fix CL-5561"}', callId: "c3" },
+      { type: "tool_result", name: "task", content: "done c2", callId: "c2" },
+      { type: "tool_result", name: "task", content: "done c1", callId: "c1" },
+      { type: "tool_result", name: "task", content: "done c3", callId: "c3" },
+    ])
+    expect(rows.length).toBe(3)
+    expect(rows.every((r) => r.pending !== true)).toBe(true)
+    expect(rows.map((r) => r.text)).toEqual(["done c1", "done c2", "done c3"])
+  })
+
   test("non-array returns empty", () => {
     expect(hydrateHistoryRows(undefined)).toEqual([])
     expect(hydrateHistoryRows(null)).toEqual([])

src/tui-opentui/history-hydrate.ts

@@ -24,6 +24,13 @@ export type HistoryBlock = {
   readonly isError?: boolean
   /** tool_call argument payload when `content` is absent (ContentBlockData). */
   readonly arguments?: string
+  /**
+   * Call id carried by a `tool_call` / `tool_result` block. Two saved calls to
+   * the same tool are indistinguishable by name alone — a resumed transcript
+   * with parallel sub-agent dispatches needs this to pair each result with
+   * its own call rather than the newest pending call of that name.
+   */
+  readonly callId?: string
   /** view block payload — validated before it reaches the layout pass. */
   readonly node?: unknown
   /** plan block payload. */
@@ -51,6 +58,7 @@ function asHistoryBlock(raw: unknown): HistoryBlock | null {
     message?: string
     isError?: boolean
     arguments?: string
+    callId?: string
     node?: unknown
     steps?: unknown
     tasks?: unknown
@@ -60,6 +68,7 @@ function asHistoryBlock(raw: unknown): HistoryBlock | null {
   if (typeof o.message === "string") out.message = o.message
   if (typeof o.isError === "boolean") out.isError = o.isError
   if (typeof o.arguments === "string") out.arguments = o.arguments
+  if (typeof o.callId === "string") out.callId = o.callId
   if (o.node !== undefined) out.node = o.node
   if (o.steps !== undefined) out.steps = o.steps
   if (o.tasks !== undefined) out.tasks = o.tasks
@@ -135,13 +144,15 @@ export function rowFromHistoryBlock(block: HistoryBlock): StreamRow | null {
       return toolCallRow({
         name: block.name ?? "tool",
         ...(args !== undefined ? { arguments: args } : {}),
+        ...(block.callId !== undefined ? { callId: block.callId } : {}),
       })
     }
     case "tool_result":
       return toolResultRow({
         name: block.name ?? "tool",
         content: block.content ?? (block.isError ? "error" : "ok"),
         isError: block.isError === true,
+        ...(block.callId !== undefined ? { callId: block.callId } : {}),
       })
     case "view": {
       const text = viewText(block.node) || block.content?.trim() || ""
@@ -211,6 +222,7 @@ function pushHistoryBlock(rows: StreamRow[], block: HistoryBlock): void {
     pushToolCall(rows, {
       name: block.name ?? "tool",
       ...(args !== undefined ? { arguments: args } : {}),
+      ...(block.callId !== undefined ? { callId: block.callId } : {}),
     })
     return
   }
@@ -219,6 +231,7 @@ function pushHistoryBlock(rows: StreamRow[], block: HistoryBlock): void {
       name: block.name ?? "tool",
       content: block.content ?? (block.isError ? "error" : "ok"),
       isError: block.isError === true,
+      ...(block.callId !== undefined ? { callId: block.callId } : {}),
     })
     return
   }

src/tui-opentui/mcp-view.ts

@@ -264,6 +264,8 @@ export type ToolResultRowInput = {
   readonly name: string
   readonly content: string
   readonly isError?: boolean
+  /** Runtime call id this result answers, when the source carried one. */
+  readonly callId?: string
 }
 
 /** Bodies at or under this many lines read faster than a sentence about them. */
@@ -487,6 +489,7 @@ export function toolResultRow(input: ToolResultRowInput): StreamRow {
     role: "tool" as const,
     text: input.content,
     meta: input.name,
+    ...(input.callId !== undefined ? { callId: input.callId } : {}),
   }
   if (failed) return { ...base, failed: true }
 

src/tui-opentui/observe-map.ts

@@ -33,12 +33,14 @@ export function rowFromBridgeEvent(event: BridgeInboundEvent): StreamRow | null
       return toolCallRow({
         name: event.name,
         ...(event.detail !== undefined ? { arguments: event.detail } : {}),
+        ...(event.callId !== undefined ? { callId: event.callId } : {}),
       })
     case "tool_result":
       return toolResultRow({
         name: event.name,
         content: event.detail ?? (event.isError ? "error" : "ok"),
         isError: event.isError === true,
+        ...(event.callId !== undefined ? { callId: event.callId } : {}),
       })
     case "system":
       return { role: "system", text: event.text }
@@ -94,6 +96,7 @@ function pushBridgeEvent(
     pushToolCall(rows, {
       name: event.name,
       ...(event.detail !== undefined ? { arguments: event.detail } : {}),
+      ...(event.callId !== undefined ? { callId: event.callId } : {}),
     })
     return
   }
@@ -102,6 +105,7 @@ function pushBridgeEvent(
       name: event.name,
       content: event.detail ?? (event.isError ? "error" : "ok"),
       isError: event.isError === true,
+      ...(event.callId !== undefined ? { callId: event.callId } : {}),
     })
     return
   }

src/tui-opentui/runner-host.test.ts

@@ -72,6 +72,7 @@ describe("rowFromTranscriptEntry", () => {
       verb: "Grep",
       pending: true,
       callKey: "grep Grep ",
+      callId: "c",
     })
     expect(
       rowFromTranscriptEntry({
@@ -81,7 +82,7 @@ describe("rowFromTranscriptEntry", () => {
         content: "boom",
         isError: true,
       }),
-    ).toEqual({ role: "tool", text: "boom", meta: "grep", failed: true })
+    ).toEqual({ role: "tool", text: "boom", meta: "grep", failed: true, callId: "c" })
     expect(rowFromTranscriptEntry({ kind: "report", content: "done" })).toEqual({
       role: "assistant",
       text: "done",

src/tui-opentui/runner-host.ts

@@ -141,12 +141,13 @@ export function rowFromTranscriptEntry(entry: SubAgentTranscriptEntry): StreamRo
     case "thinking":
       return { role: "system", text: entry.content, meta: "thinking" }
     case "tool":
-      return toolCallRow({ name: entry.name, arguments: entry.arguments })
+      return toolCallRow({ name: entry.name, arguments: entry.arguments, callId: entry.callId })
     case "tool_result":
       return toolResultRow({
         name: entry.name,
         content: entry.content,
         isError: entry.isError,
+        callId: entry.callId,
       })
     case "report":
       return { role: "assistant", text: entry.content, meta: "report" }
@@ -164,14 +165,15 @@ export function rowsFromTranscript(
   const rows: StreamRow[] = []
   for (const entry of entries) {
     if (entry.kind === "tool") {
-      pushToolCall(rows, { name: entry.name, arguments: entry.arguments })
+      pushToolCall(rows, { name: entry.name, arguments: entry.arguments, callId: entry.callId })
       continue
     }
     if (entry.kind === "tool_result") {
       pushToolResult(rows, {
         name: entry.name,
         content: entry.content,
         isError: entry.isError,
+        callId: entry.callId,
       })
       continue
     }

src/tui-opentui/runtime-bridge.test.ts

@@ -432,3 +432,61 @@ describe("committed inference retry", () => {
     )
   })
 })
+
+describe("parallel sub-agent dispatch on the live session bridge", () => {
+  // The live main-session path tracks a call's row by callId in its own map
+  // (applyToolCall/applyToolResult), independent of tool-rows.ts's name-based
+  // pendingCallIndex — this pins that down so a future change to either path
+  // cannot silently reintroduce CL-5562's misattribution on the parent
+  // transcript specifically (the observe overlay and resumed history are
+  // covered separately in tool-rows.test.ts / history-hydrate.test.ts).
+  test("three parallel task calls resolve to three rows, each with its own result", async () => {
+    await withTestRenderer(
+      async (h) => {
+        const shell = createAppShell(h.renderer, {
+          terminal: { columns: 80, rows: 24 },
+          wireKeys: false,
+          run: "idle",
+        })
+        const bridge = attachSessionBridge(shell, createRecordingPort())
+        try {
+          const events = [
+            { type: "inference.start", data: {} },
+            {
+              type: "inference.tool_call.end",
+              data: { name: "task", callId: "c1", arguments: { description: "Fix CL-5559" } },
+            },
+            {
+              type: "inference.tool_call.end",
+              data: { name: "task", callId: "c2", arguments: { description: "Fix CL-5560" } },
+            },
+            {
+              type: "inference.tool_call.end",
+              data: { name: "task", callId: "c3", arguments: { description: "Fix CL-5561" } },
+            },
+            { type: "inference.done", data: {} },
+            { type: "tool.start", data: { call: { id: "c1", name: "task" } } },
+            { type: "tool.start", data: { call: { id: "c2", name: "task" } } },
+            { type: "tool.start", data: { call: { id: "c3", name: "task" } } },
+            // Completion order does not follow dispatch order.
+            { type: "tool.done", data: { result: { callId: "c2", name: "task", content: "done c2" } } },
+            { type: "tool.done", data: { result: { callId: "c1", name: "task", content: "done c1" } } },
+            { type: "tool.done", data: { result: { callId: "c3", name: "task", content: "done c3" } } },
+            { type: "reactor.done", data: {} },
+          ] as const
+          for (const event of events) bridge.handle(event)
+
+          const toolRows = shell.streamLog.filter((r) => r.role === "tool")
+          expect(toolRows.length).toBe(3)
+          expect(toolRows.every((r) => r.pending !== true)).toBe(true)
+          expect(toolRows.every((r) => r.failed !== true)).toBe(true)
+          expect(toolRows.map((r) => r.text)).toEqual(["done c1", "done c2", "done c3"])
+        } finally {
+          bridge.dispose()
+          shell.dispose()
+        }
+      },
+      { width: 80, height: 24 },
+    )
+  })
+})

src/tui-opentui/stream.ts

@@ -71,6 +71,15 @@ export type StreamRow = {
    * onto a single row.
    */
   readonly callKey?: string
+  /**
+   * Runtime id of the call this row answers, when the source carried one
+   * (a live reactor callId, a resumed transcript's saved id). A result finds
+   * the exact row it resolves by this id first — the tool name alone is
+   * ambiguous the moment two calls to the same tool are in flight at once,
+   * which parallel sub-agent dispatch does on every turn that fires more
+   * than one `task` call.
+   */
+  readonly callId?: string
   /**
    * Row standing for a run of repeated calls. Its subject stays the call the
    * run repeats (never a total across them, which would be a claim the

src/tui-opentui/tool-rows.test.ts

@@ -9,12 +9,13 @@ import { withTestRenderer } from "./harness"
 import { attachSessionBridge, createRecordingPort } from "./runtime-bridge"
 import { createAppShell } from "./shell"
 import {
+  isCollapsibleRow,
   paintStreamRow,
   toolSentenceLines,
   type RowLayout,
   type StreamRow,
 } from "./stream"
-import { pushToolCall, pushToolResult } from "./tool-rows"
+import { pendingCallIndex, pushToolCall, pushToolResult } from "./tool-rows"
 
 const LAYOUT: RowLayout = { width: 72, multiAgent: false }
 
@@ -124,6 +125,91 @@ describe("a run of identical calls", () => {
   })
 })
 
+describe("parallel calls to the same tool", () => {
+  // CL-5562: three `task` calls dispatched in one turn all carry
+  // meta === "task" — name alone cannot tell them apart, so a result must
+  // find its own row by call id or it resolves whichever pending "task" row
+  // happens to be newest, leaving the others stranded pending forever and
+  // turning any later same-name result into an orphaned extra row.
+  test("each result resolves its own call by id, not the newest pending call of that name", () => {
+    const rows: StreamRow[] = []
+    pushToolCall(rows, {
+      name: "task",
+      arguments: JSON.stringify({ agent: "intern", description: "Fix CL-5559 heading shake" }),
+      callId: "c1",
+    })
+    pushToolCall(rows, {
+      name: "task",
+      arguments: JSON.stringify({ agent: "intern", description: "Fix CL-5560 approval UI" }),
+      callId: "c2",
+    })
+    pushToolCall(rows, {
+      name: "task",
+      arguments: JSON.stringify({ agent: "intern", description: "Fix CL-5561 scroll/history" }),
+      callId: "c3",
+    })
+    expect(rows.length).toBe(3)
+
+    // Results land out of dispatch order, as real sub-agent completion does.
+    pushToolResult(rows, { name: "task", content: "done c2", callId: "c2" })
+    pushToolResult(rows, { name: "task", content: "done c1", callId: "c1" })
+    pushToolResult(rows, { name: "task", content: "done c3", callId: "c3" })
+
+    expect(rows.length).toBe(3)
+    expect(rows.every((r) => r.pending !== true)).toBe(true)
+    expect(rows.every((r) => r.failed !== true)).toBe(true)
+    expect(rows[0]?.summary).toBe("Fix CL-5559 heading shake")
+    expect(rows[0]?.text).toBe("done c1")
+    expect(rows[1]?.summary).toBe("Fix CL-5560 approval UI")
+    expect(rows[1]?.text).toBe("done c2")
+    expect(rows[2]?.summary).toBe("Fix CL-5561 scroll/history")
+    expect(rows[2]?.text).toBe("done c3")
+  })
+
+  // A miss must not fall back to "the newest pending row of that name" — that
+  // fallback is exactly the LIFO misattribution this test file exists to rule
+  // out, and every live caller (the bridge's own call map, subagent session
+  // entries, resumed history with ids) always carries a real id, so a miss
+  // here means the id genuinely does not belong to anything on the log.
+  test("an id that matches nothing on the log answers nothing, not the newest pending call", () => {
+    const rows: StreamRow[] = [
+      { role: "tool", text: "", meta: "task", pending: true, callId: "a1" },
+      { role: "tool", text: "", meta: "task", pending: true, callId: "b1" },
+    ]
+    expect(pendingCallIndex(rows, "task", "zzz-does-not-exist")).toBe(-1)
+
+    pushToolResult(rows, { name: "task", content: "orphan", callId: "zzz-does-not-exist" })
+    // Answers nothing on the log — appended as its own row rather than
+    // resolving (and thereby corrupting) an unrelated in-flight call.
+    expect(rows.length).toBe(3)
+    expect(rows[0]?.pending).toBe(true)
+    expect(rows[1]?.pending).toBe(true)
+  })
+
+  // Acceptance criterion: a failed sub-agent surfaces its error inline
+  // (expandable), not a bare mark with nothing behind it. `mergeToolRows` /
+  // `toolResultRow` already carry the failed result's own text into `detail`
+  // — untouched by this fix, but only reachable per-call once results resolve
+  // to the right row instead of a neighbour's.
+  test("a failed call keeps its error text behind the expand arrow", () => {
+    const rows: StreamRow[] = []
+    pushToolCall(rows, {
+      name: "task",
+      arguments: JSON.stringify({ agent: "intern", description: "Fix CL-5559 heading shake" }),
+      callId: "c1",
+    })
+    pushToolResult(rows, {
+      name: "task",
+      content: 'Error: sub-agent "Fix CL-5559 heading shake" failed: boom',
+      isError: true,
+      callId: "c1",
+    })
+    expect(rows[0]?.failed).toBe(true)
+    expect(isCollapsibleRow(rows[0]!)).toBe(true)
+    expect(rows[0]?.detail?.[0]?.[0]?.text).toContain("boom")
+  })
+})
+
 describe("a long subject", () => {
   test("is cut to one line rather than wrapped", () => {
     const row = toolCallRow({