fix(tui): abort stall while a sibling collect is still in flight

A sibling tool.done clears currentToolName while shell_collect stays in
activeToolCalls, so keying only the last name left that poll unbounded.

Author: TheGreatAxios

docs/PRODUCT.md

@@ -41,7 +41,7 @@ The evidence is in how the product fails today: the personas already produce exc
 5. **Resume capability** — Runs persist to a git-backed store and resume from the last point after interruption.
 6. **Legible loop** — A live event log, working-tree diff panel, plan tracker, and real-time cost meter show what happened, when, and why.
 7. **Operator-in-the-loop** — The agent can call `ask_operator` to pause and ask a clarifying question; the operator answers from a modal (TUI). Headless `corbits exec` unmounts `ask_operator` when stdin/stdout are not TTYs. TTY exec still reads a single line from stdin.
-8. **Mid-run steering** — Two modes while the agent is running, keyed to **whose** idle. **Parent-idle** is when the primary Skywalker turn is not inside an in-flight parent tool; **session-idle** is parent-idle **and** no live fleet lanes. **Enter** soft-steers while the parent is busy — delivers at the next **parent** `tool.boundary` without stopping the current run; a long parent `run_shell` or an awaiting `wait_agents` is parent-busy, so Enter is a queued steer, not a new turn. An in-flight TUI-primary `wait_agents` yields as a timeout when that steer is queued so occupancy can deliver it. A queued steer delivers at the next parent `tool.boundary` so occupancy can pick it up. Idle-with-fleet is shipped: after a non-blocking `spawn_agent` dispatch the parent goes idle while workers keep running, mailbox mail arrives as inbound when a worker finishes or fails, and mid-hold Enter starts a new primary turn instead of queueing a steer. **Alt+Enter** queues a follow-up delivered only on session-idle (`run` goes idle; does not interrupt). Session-idle Alt+Enter is a no-op. **Ctrl+C** stops the run outright. The notice row shows distinct `steer N` / `follow-up M` badges, and held messages list in a pending column stacked on the prompt box — `↑`/`↓` select, `Enter` force-pushes one now, `Ctrl+X` drops it — instead of echoing labelled transcript rows; when steers are pending and a parent tool has been in flight a few seconds, the notice names that command. Shortcuts are listed in `/help` (`Enter` soft-steer · `Alt+Enter` follow-up · `Ctrl+C` stop).
+8. **Mid-run steering** — Two modes while the agent is running, keyed to **whose** idle. **Parent-idle** is when the primary Skywalker turn is not inside an in-flight parent tool; **session-idle** is parent-idle **and** no live fleet lanes. **Enter** soft-steers while the parent is busy — delivers at the next **parent** `tool.boundary` without stopping the current run; a long parent `run_shell` is parent-busy, so Enter is a queued steer, not a new turn. A queued steer delivers at the next parent `tool.boundary` so occupancy can pick it up. Idle-with-fleet is shipped: after a non-blocking `spawn_agent` dispatch the parent goes idle while workers keep running, mailbox mail arrives as inbound when a worker finishes or fails, and mid-hold Enter starts a new primary turn instead of queueing a steer. **Alt+Enter** queues a follow-up delivered only on session-idle (`run` goes idle; does not interrupt). Session-idle Alt+Enter is a no-op. **Ctrl+C** stops the run outright. The notice row shows distinct `steer N` / `follow-up M` badges, and held messages list in a pending column stacked on the prompt box — `↑`/`↓` select, `Enter` force-pushes one now, `Ctrl+X` drops it — instead of echoing labelled transcript rows; when steers are pending and a parent tool has been in flight a few seconds, the notice names that command. Shortcuts are listed in `/help` (`Enter` soft-steer · `Alt+Enter` follow-up · `Ctrl+C` stop).
 9. **Orchestrator-only (TUI + exec)** — The primary session is always the orchestrator: it can act directly and delegates via `spawn_agent` (then idle; mailbox mail inbound) / `search_agents`. Nested orchestrators collect through mailbox mail the same way. Long jobs belong on workers — a parent that runs them itself stays parent-busy and holds Enter steers. Single-agent session mode, the first-run mode picker, and Settings → Session are gone (CL-5814). Legacy `sessionMode` values on disk are ignored.
 
 ## User Experience

src/tui/runtime-bridge.ts

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

src/tui/stall-watchdog.test.ts

@@ -24,6 +24,7 @@ describe("shouldAbortForStall", () => {
     streamingType: "text" as const,
     currentToolName: null,
     activeToolCalls: [],
+    callIdByName: {},
   };
 
   test("aborts a mid-stream hang past the timeout", () => {
@@ -96,6 +97,7 @@ describe("shouldAbortForStall — awaiting-response with a null stream eventuall
     streamingType: null,
     currentToolName: null,
     activeToolCalls: [],
+    callIdByName: {},
   };
 
   test("aborts a run awaiting a response once the stall budget elapses", () => {
@@ -158,6 +160,7 @@ describe("shouldAbortForStall — execution-watchdog-exempt tools do not pin for
     streamingType: "tool" as const,
     currentToolName: "shell_collect",
     activeToolCalls: ["collect-1"],
+    callIdByName: { shell_collect: "collect-1" },
   };
 
   test("in-flight collect auto-aborts after the stall budget", () => {
@@ -173,9 +176,41 @@ describe("shouldAbortForStall — execution-watchdog-exempt tools do not pin for
         ...collect,
         currentToolName: "wait_agents",
         activeToolCalls: ["wait-1"],
+        callIdByName: { wait_agents: "wait-1" },
       }),
     ).toBe(true);
   });
+
+  // tool.done of a sibling bash clears currentToolName and streamingType
+  // while shell_collect is still in activeToolCalls. Keying only the last
+  // name would leave that poll unbounded forever.
+  test("sibling tool.done while collect is in-flight still aborts at the stall budget", () => {
+    const afterSiblingDone = {
+      ...collect,
+      currentToolName: null,
+      streamingType: null,
+      awaitingResponse: false,
+      activeToolCalls: ["collect-1"],
+      callIdByName: { shell_collect: "collect-1" },
+    };
+    expect(
+      shouldAbortForStall({ ...afterSiblingDone, nowMs: STALL_TIMEOUT_MS - 1 }),
+    ).toBe(false);
+    expect(shouldAbortForStall(afterSiblingDone)).toBe(true);
+  });
+
+  test("a remaining ordinary tool after a sibling done is not a stall", () => {
+    expect(
+      shouldAbortForStall({
+        ...collect,
+        currentToolName: null,
+        streamingType: null,
+        awaitingResponse: false,
+        activeToolCalls: ["bash-1"],
+        callIdByName: { bash: "bash-1" },
+      }),
+    ).toBe(false);
+  });
 });
 
 describe("applyStallRecovery", () => {
@@ -219,6 +254,7 @@ describe("shouldNoticeStall", () => {
     currentToolName: null,
     repeating: false,
     activeToolCalls: [],
+    callIdByName: {},
   };
 
   test("a parallel fan-out with sibling tools still running does not notice", () => {
@@ -303,6 +339,7 @@ describe("the stall level the indicator reads", () => {
     streamingType: null,
     currentToolName: null,
     activeToolCalls: [],
+    callIdByName: {},
     repeating: false,
   };
 

src/tui/stall-watchdog.ts

@@ -24,6 +24,7 @@ export interface ShouldAbortForStallArgs {
   readonly streamingType: "text" | "thinking" | "tool" | null;
   readonly currentToolName: string | null;
   readonly activeToolCalls: readonly string[];
+  readonly callIdByName: Readonly<Record<string, string>>;
 }
 
 /**
@@ -58,18 +59,31 @@ function silentPastThreshold(
 
 /**
  * Polls the per-tool execution watchdog leaves unarmed. Without a stall
- * bound they hold `streamingType === "tool"` with no other wall-clock limit.
+ * 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.
  */
-function isStallBoundedInFlightTool(args: ShouldAbortForStallArgs): boolean {
-  if (args.streamingType !== "tool") return false;
-  const name = args.currentToolName;
+function isStallBoundedToolName(name: string | null | undefined): boolean {
   return (
     name === "shell_collect" ||
     name === "wait_agents" ||
     name === "ask_director"
   );
 }
 
+function isStallBoundedInFlightTool(args: ShouldAbortForStallArgs): boolean {
+  if (isStallBoundedToolName(args.currentToolName)) return true;
+  for (const [name, id] of Object.entries(args.callIdByName)) {
+    if (isStallBoundedToolName(name) && args.activeToolCalls.includes(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);
+}
+
 // Pure decision helper: returns true when the run is genuinely stuck and should
 // be aborted. Extracted so the timeout logic is unit-testable without timers.
 //