Capture approval generation at overlay start

/clear during the permission overlay bumped generation after handle
started, but the TUI recaptured at deliver time so an accept still
injected the approved decision into the empty session.

Author: TheGreatAxios

src/session/approval-resume.ts

@@ -114,7 +114,10 @@ export function createApprovalResume(args: {
   getAgent: () => Pick<Agent, "deliver" | "history"> | undefined;
   // TUI session queue. When present, each decision is awaited through this
   // seam; exec omits it and uses getAgent().deliver.
-  deliver?: (message: InboundMessage) => void | Promise<void>;
+  deliver?: (message: InboundMessage, stillCurrent: () => boolean) => void | Promise<void>;
+  // TUI: capture at handle() start so /clear during the overlay drops the
+  // decision instead of delivering into the new session. Exec omits this.
+  captureGeneration?: () => () => boolean;
   gate: PermissionGate;
 }): ApprovalResume {
   const { getAgent, gate } = args;
@@ -127,19 +130,21 @@ export function createApprovalResume(args: {
     return agent;
   };
 
-  const deliverDecision = async (message: InboundMessage): Promise<void> => {
-    if (args.deliver !== undefined) {
-      await args.deliver(message);
-      return;
-    }
-    requireAgent().deliver(message);
-  };
-
   return {
     handle: async (result) => {
       if (result.type !== "suspended") return false;
+      const stillCurrent = args.captureGeneration?.() ?? (() => true);
       const { correlationId, approvalSnapshot } = result;
 
+      const deliverDecision = async (message: InboundMessage): Promise<void> => {
+        if (!stillCurrent()) return;
+        if (args.deliver !== undefined) {
+          await args.deliver(message, stillCurrent);
+          return;
+        }
+        requireAgent().deliver(message);
+      };
+
       // Turn-count watermark for the settled guard below: a "approval timed
       // out" tool result appended after this point means the reactor settled
       // this very correlation before our decision lands.
@@ -164,6 +169,7 @@ export function createApprovalResume(args: {
       }
 
       const outcome = await gate.resolveSuspended(request);
+      if (!stillCurrent()) return true;
       if (settledAfterSuspend(await requireAgent().history(), turnsAtSuspend)) {
         // The reactor already answered the parked call (its approval timeout
         // fired while the surface was still up). Delivering now would append

src/tui/runner/session.ts

@@ -364,8 +364,8 @@ export async function assembleTUISession(
   const deliveryGeneration = createDeliveryGeneration();
   const approvalResume = createApprovalResume({
     getAgent: () => state.agentProxy ?? state.currentAgent,
-    deliver: (message) => {
-      const stillCurrent = deliveryGeneration.capture();
+    captureGeneration: deliveryGeneration.capture,
+    deliver: (message, stillCurrent) => {
       return sessionOps.enqueue(async () => {
         if (!stillCurrent()) return;
         if (state.fatalBuildError !== null) throw state.fatalBuildError;

tests/unit/approval-resume.test.ts

@@ -5,6 +5,7 @@ import type { ConversationTurn, InboundMessage } from "@intx/types/runtime";
 
 import type { PermissionGate } from "../../src/permission/gate.js";
 import { createApprovalResume } from "../../src/session/approval-resume.js";
+import { createDeliveryGeneration } from "../../src/tui/queued-delivery.js";
 
 const SUSPENDED: SendResult = {
   type: "suspended",
@@ -184,3 +185,55 @@ describe("approval resume late-bind", () => {
     expect(correlationHeaders(delivered[0]).interchangeCorrelationId).toBe("corr-1");
   });
 });
+
+describe("approval resume generation capture", () => {
+  test("overlay accept after a generation bump does not deliver", async () => {
+    const generation = createDeliveryGeneration();
+    const delivered: unknown[] = [];
+    const agent = {
+      deliver: (message: unknown) => delivered.push(message),
+      history: async () => [userTurn()],
+    };
+    const resume = createApprovalResume({
+      getAgent: () => agent,
+      captureGeneration: generation.capture,
+      deliver: (message, stillCurrent) => {
+        if (!stillCurrent()) return;
+        delivered.push(message);
+      },
+      gate: {
+        resolveSuspended: async () => {
+          generation.bump();
+          return { allow: true };
+        },
+      } as unknown as PermissionGate,
+    });
+
+    expect(await resume.handle(SUSPENDED)).toBe(true);
+    expect(delivered).toEqual([]);
+  });
+
+  test("a live generation still delivers after the overlay", async () => {
+    const generation = createDeliveryGeneration();
+    const delivered: unknown[] = [];
+    const agent = {
+      deliver: (message: unknown) => delivered.push(message),
+      history: async () => [userTurn()],
+    };
+    const resume = createApprovalResume({
+      getAgent: () => agent,
+      captureGeneration: generation.capture,
+      deliver: (message, stillCurrent) => {
+        if (!stillCurrent()) return;
+        delivered.push(message);
+      },
+      gate: { resolveSuspended: async () => ({ allow: true }) } as unknown as PermissionGate,
+    });
+
+    expect(await resume.handle(SUSPENDED)).toBe(true);
+    expect(delivered).toHaveLength(1);
+    expect(JSON.parse((delivered[0] as { content: string }).content)).toEqual({
+      outcome: "approved",
+    });
+  });
+});

tests/unit/tui/approval-reload-during-suspend.test.ts

@@ -1,5 +1,11 @@
 import { describe, expect, test } from "bun:test";
 
+import type { SendResult } from "@intx/agent";
+import type { ConversationTurn } from "@intx/types/runtime";
+
+import type { PermissionGate } from "../../../src/permission/gate.js";
+import { createApprovalResume } from "../../../src/session/approval-resume.js";
+import { createSessionOperationQueue } from "../../../src/tui/session-operation-queue.js";
 import { runWhileAgentBusy, type RunnerState } from "../../../src/tui/runner/state.js";
 
 function stubBusyState() {
@@ -63,3 +69,64 @@ describe("runWhileAgentBusy vs pendingReload", () => {
     expect(state.pendingReload).toBe(true);
   });
 });
+
+const SUSPENDED: SendResult = {
+  type: "suspended",
+  correlationId: "corr-1",
+  approvalSnapshot: { name: "run_shell", arguments: { command: "curl -sS https://example.com" } },
+} as unknown as SendResult;
+
+function userTurn(): ConversationTurn {
+  return {
+    role: "user",
+    content: [{ type: "text", text: "go" }],
+    timestamp: 0,
+  } as unknown as ConversationTurn;
+}
+
+describe("pendingReload during resolveSuspended vs deliver enqueue", () => {
+  test("does not rebuild until handle returns and deliver has run", async () => {
+    const events: string[] = [];
+    const { enqueue, awaitTail } = createSessionOperationQueue();
+    const state: Pick<RunnerState, "inFlight" | "reloadIfIdle"> & { pendingReload: boolean } = {
+      inFlight: 0,
+      pendingReload: false,
+      reloadIfIdle: () => {
+        if (!state.pendingReload || state.inFlight > 0) return;
+        state.pendingReload = false;
+        void enqueue(async () => {
+          events.push("rebuild");
+        });
+      },
+    };
+    const agent = {
+      deliver: (_message: unknown) => {
+        events.push("deliver");
+      },
+      history: async () => [userTurn()],
+    };
+    const resume = createApprovalResume({
+      getAgent: () => agent,
+      deliver: (message) =>
+        enqueue(async () => {
+          agent.deliver(message);
+        }),
+      gate: {
+        resolveSuspended: async () => {
+          state.pendingReload = true;
+          state.reloadIfIdle?.();
+          expect(events).toEqual([]);
+          return { allow: true };
+        },
+      } as unknown as PermissionGate,
+    });
+
+    await runWhileAgentBusy(state, async () => {
+      await resume.handle(SUSPENDED);
+    });
+    await awaitTail();
+
+    expect(events).toEqual(["deliver", "rebuild"]);
+    expect(state.inFlight).toBe(0);
+  });
+});