test(tui): cover a lost decision's rejection and the queued run state

Author: bwachman

src/session/approval-resume.test.ts

@@ -12,6 +12,7 @@ import type {
   InboundMessage,
 } from "@intx/types/runtime";
 
+import { APPROVAL_TIMEOUT_RESULT_TEXT } from "../permission/decline-markers.js";
 import type { PermissionGate } from "../permission/gate.js";
 import { createExtraDeniedPathMatcher } from "../plugins/secret-guard-plugin.js";
 import {
@@ -1193,10 +1194,9 @@ describe("approval resume retry re-await", () => {
     expect(delivered).toHaveLength(1);
   });
 
-  // Concurrent duplicates share one in-flight rejection (one gate, zero
-  // deliveries), then a retry re-gates and delivers exactly once, and later
-  // retries memoize.
-  test("a shared rejection re-gates once, delivers once, then memoizes", async () => {
+  // Concurrent duplicates share one in-flight gate failure (one gate, one
+  // rejection delivered), and later retries memoize.
+  test("a shared gate failure rejects the parked call once, then memoizes", async () => {
     const gate = Promise.withResolvers<{ allow: boolean }>();
     const { resume, delivered, resolveSuspended } = retryHarness({
       allow: true,
@@ -1211,17 +1211,54 @@ describe("approval resume retry re-await", () => {
     await expect(first).rejects.toBe(failure);
     await expect(second).rejects.toBe(failure);
     expect(resolveSuspended).toHaveBeenCalledTimes(1);
-    expect(delivered).toHaveLength(0);
-
-    expect(await resume.handle(suspension("corr-A", "echo alpha"))).toBe(true);
-    expect(resolveSuspended).toHaveBeenCalledTimes(2);
+    // Nothing retries a parked call, so the failure answers it.
     expect(delivered).toHaveLength(1);
-    expect(decisionBody(onlyDecision(delivered)).outcome).toBe("approved");
+    expect(decisionBody(onlyDecision(delivered)).outcome).toBe("rejected");
 
     expect(await resume.handle(suspension("corr-A", "echo alpha"))).toBe(true);
-    expect(resolveSuspended).toHaveBeenCalledTimes(2);
+    expect(resolveSuspended).toHaveBeenCalledTimes(1);
     expect(delivered).toHaveLength(1);
   });
+  test("a gate failure after the reactor timed the call out delivers nothing", async () => {
+    const delivered: InboundMessage[] = [];
+    let timedOut = false;
+    const failure = new Error("gate exploded");
+    const resume = createApprovalResume({
+      getAgent: () => ({
+        deliver: (message: InboundMessage) => {
+          delivered.push(message);
+        },
+        history: async () =>
+          timedOut
+            ? ([
+                {
+                  role: "user",
+                  content: [
+                    {
+                      type: "tool_result",
+                      callId: "call-A",
+                      content: [
+                        { type: "text", text: APPROVAL_TIMEOUT_RESULT_TEXT },
+                      ],
+                    },
+                  ],
+                },
+              ] as unknown as Awaited<ReturnType<Agent["history"]>>)
+            : [],
+      }),
+      resolveParkedCallId: () => "call-A",
+      gate: {
+        resolveSuspended: async () => {
+          timedOut = true;
+          throw failure;
+        },
+      } as unknown as PermissionGate,
+    });
+    await expect(
+      resume.handle(suspension("corr-A", "echo alpha")),
+    ).rejects.toBe(failure);
+    expect(delivered).toEqual([]);
+  });
 });
 
 describe("parked overlay registration after the operator answers", () => {

src/tui/runner/queued-approval-delivery.test.ts

@@ -31,6 +31,7 @@ import {
 import type { PermissionGate } from "../../permission/gate.js";
 import { ASK_DIRECTOR_WAKE_PREFIX } from "../../subagent/fleet-report.js";
 import { withTestRenderer } from "../harness.js";
+import { setShellRunState } from "../shell/chrome.js";
 import { createAppShell } from "../shell/index.js";
 import { shellInternals, type AppShell } from "../shell/internals.js";
 import { createDeliverRouting, createSubmitPath } from "./submit.js";
@@ -244,16 +245,23 @@ const drainWake = (h: ReturnType<typeof harness>): (() => unknown) => {
 
 // A decision that fails after the drained send returned cannot change the
 // drain's result: the wake already reached the agent, and restoring it would
-// resend it. It must be surfaced the way a failed send is instead.
-for (const [name, opts] of [
+// resend it. The failure is surfaced as a notice, the parked call is answered
+// rather than left to the reactor's timeout, and the shell keeps its run state
+// so follow-ups queued behind this turn still drain when it ends.
+for (const [name, opts, decisions] of [
   [
     "the approval surface throws",
     {
       resolveSuspended: () =>
         Promise.reject(new Error("approval overlay failed")),
     },
+    ["approval.denied"],
+  ],
+  [
+    "the reactor never accepts the decision",
+    { acceptsDecisions: false },
+    ["approval.granted"],
   ],
-  ["the reactor never accepts the decision", { acceptsDecisions: false }],
 ] as const) {
   test(`wake-drained turn: surfaces a lost decision when ${name}`, async () => {
     await withTestRenderer(async (r) => {
@@ -265,12 +273,16 @@ for (const [name, opts] of [
       });
       try {
         const h = harness({ ...opts, shell });
+        setShellRunState(shell, "busy");
         const settled = drainWake(h);
         await new Promise((resolve) => setTimeout(resolve, 200));
         expect(h.gateAsked()).toBe(1);
         expect(settled()).toEqual({ status: "accepted" });
-        expect(h.state.runError).toBeDefined();
+        expect(h.delivered.map((m) => m.headers.interchangeType)).toEqual([
+          ...decisions,
+        ]);
         expect(systemRows(shell).length).toBe(1);
+        expect(shell.session.run).toBe("busy");
         expect(await settleWithin(h.sessionOps.awaitTail(), 200)).toBe(
           "settled",
         );