fix(tui): settle the turn when a parked call ends without running

A call parked on an approval gate is registered as active when the
model streams it. Approved, the reactor re-dispatches it and it reports
through its own tool.start and tool.done. Rejected, timed out or
dropped, the reactor answers it with a synthetic error result and
emits nothing naming it, so the call stayed active. The model's
follow-up reply arrived, but a turn with an active call never settles,
so the footer stayed at "working" until the operator interrupted.

The bridge now records which active calls had not started executing
when an approval gate blocked. A call that later starts leaves the set.
The reactor cannot re-infer while a call is parked, so an
inference.start that finds a recorded call still unstarted means it was
answered without running. The bridge closes it as not run through the
same path a tool.done takes, and the turn settles when the reply ends.
Siblings that were already executing, and gates other than approvals,
are left alone.

Bridge tests cover the rejected, approved, executing-sibling and
non-approval cases. An end-to-end test captures the real reactor's
stream for a rejected and an approved parked call and replays it into
the bridge.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: bwachman

e2e/reactor-approval-parked-call-settles.test.ts

@@ -0,0 +1,151 @@
+/**
+ * A parked call that ends without running is answered by the reactor with a
+ * synthetic error result and no `tool.done`. These tests capture the real
+ * reactor's event stream for a rejected and an approved parked call and replay
+ * it into the TUI bridge, so the bridge is judged against what the reactor
+ * actually emits rather than a hand-written sequence.
+ */
+import { describe, expect, test } from "bun:test";
+
+import type { ReactorEmittedEvent } from "@intx/inference";
+
+import { createPermissionGate } from "../src/permission/gate.js";
+import { createReactorAuthorize } from "../src/permission/reactor-authorize.js";
+import {
+  createApprovalResume,
+  resolveParkedCallIdFromStore,
+} from "../src/session/approval-resume.js";
+import {
+  attachSessionBridge,
+  createRecordingPort,
+  PARKED_CALL_NOT_RUN,
+} from "../src/tui/runtime-bridge.js";
+import { withAppShell } from "../src/tui/test-helpers.js";
+import {
+  closeIntegrationSession,
+  openIntegrationSession,
+  runUntilSuspended,
+  toolDoneEvents,
+} from "./integration-harness.js";
+
+/** Drives one parked call to the operator's decision; returns every event. */
+async function parkedCallEvents(
+  allow: boolean,
+): Promise<ReactorEmittedEvent[]> {
+  let release: ((outcome: { allow: boolean }) => void) | undefined;
+  const gate = createPermissionGate({
+    approvals: [],
+    interactive: true,
+    skipPermissions: false,
+    auto: false,
+    reactorGated: true,
+    requestApproval: () =>
+      new Promise((resolve) => {
+        release = resolve;
+      }),
+  });
+  const session = await openIntegrationSession({
+    permissionGate: gate,
+    authorize: createReactorAuthorize(gate),
+  });
+  try {
+    session.harness.scenario.replyOnce("anthropic", {
+      toolCalls: [
+        {
+          name: "run_shell",
+          args: { command: "curl -sS https://example.com" },
+        },
+      ],
+    });
+    session.harness.scenario.replyOnce("anthropic", { text: "Understood." });
+
+    const turn = await runUntilSuspended(session, "Fetch example.com.");
+    if (turn.result.type !== "suspended") throw new Error("did not park");
+    const resume = createApprovalResume({
+      getAgent: () => session.agent,
+      gate,
+      resolveParkedCallId: (correlationId) =>
+        resolveParkedCallIdFromStore(session.storage, correlationId),
+    });
+    const handling = resume.handle(turn.result);
+    for (let i = 0; i < 400 && release === undefined; i++) {
+      await new Promise((resolve) => setTimeout(resolve, 5));
+    }
+    release?.({ allow });
+    await handling;
+    await turn.reply();
+    // Let the run-ended event that follows the reply land.
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    return [...turn.events];
+  } finally {
+    await closeIntegrationSession(session);
+  }
+}
+
+async function replayIntoBridge(events: readonly ReactorEmittedEvent[]) {
+  let outcome:
+    | {
+        run: string;
+        active: readonly string[];
+        rows: { text: string; failed?: boolean; pending?: boolean }[];
+      }
+    | undefined;
+  await withAppShell(
+    (shell) => {
+      const bridge = attachSessionBridge(shell, createRecordingPort());
+      try {
+        for (const event of events) {
+          bridge.handle(event as { type: string; data?: unknown });
+        }
+        outcome = {
+          run: shell.session.run,
+          active: bridge.turn.activeToolCalls,
+          rows: shell.streamLog.filter(
+            (row) => row.role === "tool",
+          ) as unknown as {
+            text: string;
+            failed?: boolean;
+            pending?: boolean;
+          }[],
+        };
+      } finally {
+        bridge.dispose();
+      }
+    },
+    { shell: { run: "busy" } },
+  );
+  if (outcome === undefined) throw new Error("bridge did not run");
+  return outcome;
+}
+
+describe("integration: a parked call's end settles the TUI turn", () => {
+  test.serial(
+    "a rejected call emits no tool.done, and the bridge still closes it and settles",
+    async () => {
+      const events = await parkedCallEvents(false);
+      // The premise of the fix: nothing on the stream names the parked call.
+      expect(toolDoneEvents(events)).toHaveLength(0);
+
+      const after = await replayIntoBridge(events);
+      expect(after.active).toEqual([]);
+      expect(after.run).toBe("idle");
+      expect(after.rows).toHaveLength(1);
+      expect(after.rows[0]?.failed).toBe(true);
+      expect(after.rows[0]?.text).toBe(PARKED_CALL_NOT_RUN);
+    },
+  );
+
+  test.serial(
+    "an approved call reports its own result and is not closed as not run",
+    async () => {
+      const events = await parkedCallEvents(true);
+      expect(toolDoneEvents(events)).toHaveLength(1);
+
+      const after = await replayIntoBridge(events);
+      expect(after.active).toEqual([]);
+      expect(after.run).toBe("idle");
+      expect(after.rows).toHaveLength(1);
+      expect(after.rows[0]?.text).not.toBe(PARKED_CALL_NOT_RUN);
+    },
+  );
+});

src/tui/runtime-bridge.test.ts

@@ -11,6 +11,7 @@ import {
   mapReactorLike,
   type TaskProgressSession,
   type TurnMonitorOptions,
+  PARKED_CALL_NOT_RUN,
 } from "./runtime-bridge";
 import { DEFAULT_STALL_MS } from "./agent-progress";
 import { appendStreamRow, paintChrome } from "./shell/chrome";
@@ -1045,6 +1046,126 @@ describe("parallel sub-agent dispatch on the live session bridge", () => {
   });
 });
 
+describe("calls parked on an approval gate", () => {
+  type Event = { type: string; data?: unknown };
+
+  const toolCall = (id: string): Event[] => [
+    {
+      type: "inference.tool_call.start",
+      data: { callId: id, name: "run_shell" },
+    },
+    {
+      type: "inference.tool_call.end",
+      data: {
+        name: "run_shell",
+        callId: id,
+        arguments: JSON.stringify({ command: `touch ${id}` }),
+      },
+    },
+  ];
+  const gateBlocked = (reason = "approval"): Event => ({
+    type: "reactor.gate.blocked",
+    data: { reason, gateId: "gate-1", correlationId: "corr-1" },
+  });
+  // The reactor re-infers once the parked call is answered.
+  const followUpReply: Event[] = [
+    { type: "inference.start", data: {} },
+    { type: "inference.text.delta", data: { token: "It was not run." } },
+    { type: "inference.done", data: {} },
+    { type: "connector.reply", data: { content: "It was not run." } },
+  ];
+  const toolRow = (shell: { streamLog: readonly { role: string }[] }) =>
+    shell.streamLog.filter((r) => r.role === "tool") as unknown as {
+      text: string;
+      pending?: boolean;
+      failed?: boolean;
+    }[];
+
+  test("a call answered without running is closed as not run and the turn settles", async () => {
+    await withBridge({ run: "busy" }, async ({ shell, bridge }) => {
+      const events: Event[] = [
+        { type: "inference.start", data: {} },
+        ...toolCall("c1"),
+        { type: "inference.done", data: {} },
+        gateBlocked(),
+      ];
+      for (const event of events) bridge.handle(event);
+      expect(shell.session.run).toBe("busy");
+
+      // Rejected, timed out or dropped: no tool.done, just the re-inference.
+      for (const event of followUpReply) bridge.handle(event);
+
+      expect(bridge.turn.activeToolCalls).toEqual([]);
+      expect(shell.session.run).toBe("idle");
+      expect(shell.lockupPhase).toBeNull();
+      const rows = toolRow(shell);
+      expect(rows).toHaveLength(1);
+      expect(rows[0]?.pending).not.toBe(true);
+      expect(rows[0]?.failed).toBe(true);
+      expect(rows[0]?.text).toBe(PARKED_CALL_NOT_RUN);
+    });
+  });
+
+  test("an approved call reports through its own events and is never closed early", async () => {
+    await withBridge({ run: "busy" }, async ({ shell, bridge }) => {
+      const events: Event[] = [
+        { type: "inference.start", data: {} },
+        ...toolCall("c1"),
+        { type: "inference.done", data: {} },
+        gateBlocked(),
+        // Approved: the reactor re-dispatches the exact parked call.
+        { type: "tool.start", data: { call: { id: "c1", name: "run_shell" } } },
+        {
+          type: "tool.done",
+          data: { result: { callId: "c1", name: "run_shell", content: "ok" } },
+        },
+        ...followUpReply,
+      ];
+      for (const event of events) bridge.handle(event);
+
+      expect(shell.session.run).toBe("idle");
+      const rows = toolRow(shell);
+      expect(rows).toHaveLength(1);
+      expect(rows[0]?.failed).not.toBe(true);
+      expect(rows[0]?.text).toBe("ok");
+    });
+  });
+
+  test("a sibling already executing when the gate blocked stays open", async () => {
+    await withBridge({ run: "busy" }, async ({ shell, bridge }) => {
+      const events: Event[] = [
+        { type: "inference.start", data: {} },
+        ...toolCall("c1"),
+        ...toolCall("c2"),
+        { type: "inference.done", data: {} },
+        // c1 was auto-allowed and is running; c2 parked on the gate.
+        { type: "tool.start", data: { call: { id: "c1", name: "run_shell" } } },
+        gateBlocked(),
+        { type: "inference.start", data: {} },
+      ];
+      for (const event of events) bridge.handle(event);
+
+      expect(bridge.turn.activeToolCalls).toEqual(["c1"]);
+      expect(shell.session.run).toBe("busy");
+    });
+  });
+
+  test("a gate that is not an approval does not close anything", async () => {
+    await withBridge({ run: "busy" }, async ({ bridge }) => {
+      const events: Event[] = [
+        { type: "inference.start", data: {} },
+        ...toolCall("c1"),
+        { type: "inference.done", data: {} },
+        gateBlocked("input"),
+        { type: "inference.start", data: {} },
+      ];
+      for (const event of events) bridge.handle(event);
+
+      expect(bridge.turn.activeToolCalls).toEqual(["c1"]);
+    });
+  });
+});
+
 describe("idle-with-fleet (CL-7057)", () => {
   test("parent settles while fleet is live: run holds busy, follow-up keeps waiting", async () => {
     await withBridge({ run: "idle" }, async ({ h, shell, port, bridge }) => {