fix(tui): keep leftover same-name collect under the stall budget

Two concurrent shell_collect calls share one callIdByName slot, so when
the mapping-owning sibling resolves first and clears it, the leftover
earlier collect loses its name and pins the turn with no wall-clock
bound. Track the tool name per call id (callNameById) in register/
unregister and consult it in isStallBoundedInFlightTool, so the leftover
still aborts at the stall budget.

Fixes CL-8059

Author: TheGreatAxios

src/tui/runtime-bridge.ts

@@ -1551,6 +1551,7 @@ export function attachSessionBridge(
     currentToolName: bag.turn.currentToolName,
     activeToolCalls: bag.turn.activeToolCalls,
     callIdByName: bag.turn.callIdByName,
+    callNameById: bag.turn.callNameById,
     stallNoticeMs,
     repeating: bag.turn.repeating,
   });

src/tui/stall-watchdog.test.ts

@@ -211,6 +211,41 @@ describe("shouldAbortForStall — execution-watchdog-exempt tools do not pin for
       }),
     ).toBe(false);
   });
+
+  // Two concurrent collects share one callIdByName slot: the second
+  // registration overwrites the first, so when the mapping-owning sibling
+  // resolves first and clears the slot, the leftover earlier collect is
+  // invisible to the name-keyed check above. The per-id record keeps it
+  // bounded (CL-8059).
+  test("concurrent collects with the mapping owner done first still abort at the stall budget", () => {
+    const leftover = {
+      ...collect,
+      currentToolName: null,
+      streamingType: null,
+      awaitingResponse: false,
+      activeToolCalls: ["collect-1"],
+      callIdByName: {},
+      callNameById: { "collect-1": "shell_collect" },
+    };
+    expect(
+      shouldAbortForStall({ ...leftover, nowMs: STALL_TIMEOUT_MS - 1 }),
+    ).toBe(false);
+    expect(shouldAbortForStall(leftover)).toBe(true);
+  });
+
+  test("a leftover ordinary tool tracked per-id is not a stall", () => {
+    expect(
+      shouldAbortForStall({
+        ...collect,
+        currentToolName: null,
+        streamingType: null,
+        awaitingResponse: false,
+        activeToolCalls: ["bash-1"],
+        callIdByName: {},
+        callNameById: { "bash-1": "bash" },
+      }),
+    ).toBe(false);
+  });
 });
 
 describe("applyStallRecovery", () => {

src/tui/stall-watchdog.ts

@@ -25,6 +25,12 @@ export interface ShouldAbortForStallArgs {
   readonly currentToolName: string | null;
   readonly activeToolCalls: readonly string[];
   readonly callIdByName: Readonly<Record<string, string>>;
+  /**
+   * Tool name for each in-flight real call id. Optional so callers holding
+   * only the legacy name-keyed record still compile; absent means no
+   * per-id names are known. See `isStallBoundedInFlightTool`.
+   */
+  readonly callNameById?: Readonly<Record<string, string>>;
 }
 
 /**
@@ -62,7 +68,10 @@ function silentPastThreshold(
  * bound they hold the turn with no other wall-clock limit. A sibling
  * tool.done clears `currentToolName` / `streamingType` while the poll is
  * still in `activeToolCalls`, so the bound keys any in-flight stall-bounded
- * name, not only the last announced tool.
+ * name, not only the last announced tool. The name-keyed `callIdByName`
+ * holds one id per tool, so concurrent same-name siblings overwrite each
+ * other there; the per-id `callNameById` covers the leftover when the
+ * mapping-owning sibling resolves first and clears the shared slot.
  */
 function isStallBoundedToolName(name: string | null | undefined): boolean {
   return (
@@ -79,6 +88,13 @@ function isStallBoundedInFlightTool(args: ShouldAbortForStallArgs): boolean {
       return true;
     }
   }
+  // Concurrent same-name siblings share one callIdByName slot, so the
+  // mapping-owning sibling clearing it on tool.done must not release the
+  // leftover earlier call: its own id still maps to the bounded name here.
+  const callNameById = args.callNameById ?? {};
+  for (const id of args.activeToolCalls) {
+    if (isStallBoundedToolName(callNameById[id])) return true;
+  }
   // Name-only announcements track the call under its name until a real id
   // arrives, so the placeholder itself is the stall-bounded name.
   return args.activeToolCalls.some(isStallBoundedToolName);

src/tui/turn-state.test.ts

@@ -155,6 +155,43 @@ describe("turnStateFromEvent", () => {
     expect(bothDone.activeToolCalls).toHaveLength(0);
   });
 
+  test("concurrent same-name collects stay tracked when the mapping owner finishes first", () => {
+    // Regression for CL-8059: two concurrent shell_collect calls share one
+    // callIdByName slot, so the second registration overwrites the first.
+    // When the mapping-owning sibling resolves first and clears that slot,
+    // the leftover earlier collect must keep its own name record.
+    const running = fold([
+      { type: "inference.start" },
+      {
+        type: "tool.start",
+        data: { call: { id: "collect-1", name: "shell_collect" } },
+      },
+      {
+        type: "tool.start",
+        data: { call: { id: "collect-2", name: "shell_collect" } },
+      },
+    ]);
+    expect(running.activeToolCalls).toHaveLength(2);
+
+    const oneDone = turnStateFromEvent(
+      running,
+      { type: "tool.done", data: { result: { callId: "collect-2" } } },
+      200,
+    );
+    expect(oneDone.activeToolCalls).toEqual(["collect-1"]);
+    expect(oneDone.callNameById).toEqual({
+      "collect-1": "shell_collect",
+    });
+
+    const bothDone = turnStateFromEvent(
+      oneDone,
+      { type: "tool.done", data: { result: { callId: "collect-1" } } },
+      201,
+    );
+    expect(bothDone.activeToolCalls).toHaveLength(0);
+    expect(bothDone.callNameById).toEqual({});
+  });
+
   test("tool.done only sets awaitingResponse once every parallel call has finished", () => {
     // Regression for CL-5661: with a fan-out of two outstanding calls, the
     // first tool.done must not claim the turn is idle while the second call

src/tui/turn-state.ts

@@ -93,6 +93,15 @@ export interface TurnState {
    * onto one `activeToolCalls` entry. See `registerActiveCall`.
    */
   readonly callIdByName: Readonly<Record<string, string>>;
+  /**
+   * Tool name for each in-flight real call id, so two concurrent calls to
+   * the same tool each keep their own record. `callIdByName` holds only one
+   * id per name — the latest registration wins — so when the mapping-owning
+   * sibling resolves first and clears that slot, the leftover earlier call
+   * would otherwise lose its name and (for stall-bounded polls like
+   * `shell_collect`) its stall budget. See `registerActiveCall`.
+   */
+  readonly callNameById: Readonly<Record<string, string>>;
   /**
    * Tail of the text/thinking output streamed in the current uninterrupted
    * streaming cycle. A tool call ends the cycle and clears it: a model
@@ -147,6 +156,7 @@ export function initialTurnState(nowMs: number): TurnState {
     quota: null,
     activeToolCalls: [],
     callIdByName: {},
+    callNameById: {},
     streamText: "",
     repeating: false,
     repeatingSinceTokenCount: null,
@@ -189,6 +199,7 @@ export function turnStateOnSubmit(state: TurnState, nowMs: number): TurnState {
     lastActivityAt: nowMs,
     activeToolCalls: [],
     callIdByName: {},
+    callNameById: {},
     streamText: "",
     repeating: false,
     repeatingSinceTokenCount: null,
@@ -385,6 +396,23 @@ interface CallTracking {
    * the original name-keyed tracking collapsed them identically.
    */
   readonly callIdByName: Readonly<Record<string, string>>;
+  /**
+   * Tool name for each in-flight real call id. Unlike `callIdByName` this
+   * keeps one entry per call, so concurrent same-name siblings do not
+   * overwrite each other — the entry that survives is keyed by the
+   * leftover call's own id, not the shared name.
+   */
+  readonly callNameById: Readonly<Record<string, string>>;
+}
+
+function withoutCallNameById(
+  callNameById: Readonly<Record<string, string>>,
+  id: string,
+): Readonly<Record<string, string>> {
+  if (!(id in callNameById)) return callNameById;
+  return Object.fromEntries(
+    Object.entries(callNameById).filter(([callId]) => callId !== id),
+  );
 }
 
 /**
@@ -396,13 +424,17 @@ function registerActiveCall(
   tracking: CallTracking,
   identity: CallIdentity,
 ): CallTracking {
-  const { activeToolCalls, callIdByName } = tracking;
+  const { activeToolCalls, callIdByName, callNameById } = tracking;
 
   if (identity.id !== undefined) {
     const nextCallIdByName =
       identity.name !== undefined
         ? { ...callIdByName, [identity.name]: identity.id }
         : callIdByName;
+    const nextCallNameById =
+      identity.name !== undefined
+        ? { ...callNameById, [identity.id]: identity.name }
+        : callNameById;
     // A provisional entry may already be tracking this call under its name —
     // promote it onto the real id in place instead of adding a duplicate.
     const withoutPlaceholder =
@@ -412,6 +444,7 @@ function registerActiveCall(
     return {
       activeToolCalls: withActiveCall(withoutPlaceholder, identity.id),
       callIdByName: nextCallIdByName,
+      callNameById: nextCallNameById,
     };
   }
 
@@ -420,12 +453,14 @@ function registerActiveCall(
     return {
       activeToolCalls: withActiveCall(activeToolCalls, id),
       callIdByName,
+      callNameById,
     };
   }
 
   return {
     activeToolCalls: withActiveCall(activeToolCalls, "tool"),
     callIdByName,
+    callNameById,
   };
 }
 
@@ -455,12 +490,14 @@ function unregisterActiveCall(
   tracking: CallTracking,
   identity: CallIdentity,
 ): CallTracking {
-  const { activeToolCalls, callIdByName } = tracking;
+  const { activeToolCalls, callIdByName, callNameById } = tracking;
 
   if (identity.id !== undefined) {
     // Clear the mapping once its call resolves, or a later call reusing the
     // same tool name would resolve straight to this now-finished id instead
     // of tracking its own — reproducing the leak this function exists to fix.
+    // The per-id record clears only the finished call's own entry, so a
+    // concurrent same-name sibling keeps its name (CL-8059).
     const resolvedName =
       identity.name ?? nameForCallId(callIdByName, identity.id);
     const nextCallIdByName =
@@ -470,6 +507,7 @@ function unregisterActiveCall(
     return {
       activeToolCalls: withoutActiveCall(activeToolCalls, identity.id),
       callIdByName: nextCallIdByName,
+      callNameById: withoutCallNameById(callNameById, identity.id),
     };
   }
 
@@ -478,12 +516,14 @@ function unregisterActiveCall(
     return {
       activeToolCalls: withoutActiveCall(activeToolCalls, id),
       callIdByName: withoutCallIdByName(callIdByName, identity.name),
+      callNameById: withoutCallNameById(callNameById, id),
     };
   }
 
   return {
     activeToolCalls: withoutActiveCall(activeToolCalls, "tool"),
     callIdByName,
+    callNameById,
   };
 }