Drop overlay approval after interrupt rebuilds the agent

Interrupt rebuilt the agent while the permission overlay stayed
open, so a later accept or decline still saw a current generation
and delivered into the new agent. Bump delivery generation on
interrupt the same way session rotation does.

Author: TheGreatAxios

src/session/approval-resume.ts

@@ -115,8 +115,8 @@ export function createApprovalResume(args: {
   // TUI session queue. When present, each decision is awaited through this
   // seam; exec omits it and uses getAgent().deliver.
   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.
+  // TUI: capture at handle() start so /clear or interrupt during the overlay
+  // drops the decision instead of delivering into the rebuilt agent. Exec omits this.
   captureGeneration?: () => () => boolean;
   gate: PermissionGate;
 }): ApprovalResume {

src/tui/runner/exit.ts

@@ -401,6 +401,9 @@ export async function createRunLifecycle(
   // Close it, drain the old stream, and rebuild a fresh agent so the next send
   // works.
   const interrupt = (): void => {
+    // Overlay stays open across interrupt; bump so a later accept/decline
+    // cannot late-bind into the rebuilt agent.
+    services.deliveryGeneration.bump();
     state.sendAborted = true;
     void enqueueOp(async () => {
       try {

tests/unit/approval-resume.test.ts

@@ -236,4 +236,46 @@ describe("approval resume generation capture", () => {
       outcome: "approved",
     });
   });
+
+  async function interruptDuringOverlayThenDecide(outcome: { allow: boolean; message?: string }) {
+    const generation = createDeliveryGeneration();
+    const deliveredA: unknown[] = [];
+    const deliveredB: unknown[] = [];
+    const agentA = {
+      deliver: (message: unknown) => deliveredA.push(message),
+      history: async () => [userTurn()],
+    };
+    const agentB = {
+      deliver: (message: unknown) => deliveredB.push(message),
+      history: async () => [userTurn()],
+    };
+    let current: typeof agentA | typeof agentB = agentA;
+    const resume = createApprovalResume({
+      getAgent: () => current,
+      captureGeneration: generation.capture,
+      deliver: (message, stillCurrent) => {
+        if (!stillCurrent()) return;
+        current.deliver(message);
+      },
+      gate: {
+        resolveSuspended: async () => {
+          generation.bump();
+          current = agentB;
+          return outcome;
+        },
+      } as unknown as PermissionGate,
+    });
+
+    expect(await resume.handle(SUSPENDED)).toBe(true);
+    expect(deliveredA).toEqual([]);
+    expect(deliveredB).toEqual([]);
+  }
+
+  test("interrupt during overlay then accept does not deliver to the rebuilt agent", async () => {
+    await interruptDuringOverlayThenDecide({ allow: true });
+  });
+
+  test("interrupt during overlay then decline does not deliver to the rebuilt agent", async () => {
+    await interruptDuringOverlayThenDecide({ allow: false, message: "not today" });
+  });
 });