Assert interrupt bumps delivery generation before rebuild

Author: TheGreatAxios

src/tui/runner/exit.ts

@@ -120,6 +120,22 @@ export function agentRebuildFailure(err: unknown): Error {
       : new Error(String(err));
 }
 
+/**
+ * Hard-stop interrupt: bump delivery generation, then enqueue the agent rebuild.
+ * Overlay stays open across interrupt; the bump must happen before enqueue so a
+ * later accept/decline cannot late-bind into the rebuilt agent.
+ */
+export function startInterruptRebuild(args: {
+  deliveryGeneration: { bump: () => void };
+  markSendAborted: () => void;
+  enqueue: (op: () => Promise<void>) => unknown;
+  rebuild: () => Promise<void>;
+}): void {
+  args.deliveryGeneration.bump();
+  args.markSendAborted();
+  void args.enqueue(args.rebuild);
+}
+
 export function clearsActiveRun(kind: SnapshotKind): boolean {
   return kind === "run-end";
 }
@@ -401,36 +417,39 @@ 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 {
-        // close() tears down stream consumers before the aborted cycle's
-        // inference.error is delivered, so the recorder never sees a terminal
-        // event for the dead cycle — dispose closes it against stray deltas
-        // and salvages the buffer before that teardown, so it is never lost
-        // or misattributed to the rebuilt agent's next cycle.
-        await services.cycleRecorder.dispose("interrupted");
-        const closedCleanly = await closeAgentForRebuild(liveAgent(state), "interrupt");
-        await state.streamPromise?.catch((err: unknown) => {
-          tuiLogger.debug("stream drain during interrupt teardown failed: {error}", {
-            error: err instanceof Error ? err.message : String(err),
+    startInterruptRebuild({
+      deliveryGeneration: services.deliveryGeneration,
+      markSendAborted: () => {
+        state.sendAborted = true;
+      },
+      enqueue: enqueueOp,
+      rebuild: async () => {
+        try {
+          // close() tears down stream consumers before the aborted cycle's
+          // inference.error is delivered, so the recorder never sees a terminal
+          // event for the dead cycle — dispose closes it against stray deltas
+          // and salvages the buffer before that teardown, so it is never lost
+          // or misattributed to the rebuilt agent's next cycle.
+          await services.cycleRecorder.dispose("interrupted");
+          const closedCleanly = await closeAgentForRebuild(liveAgent(state), "interrupt");
+          await state.streamPromise?.catch((err: unknown) => {
+            tuiLogger.debug("stream drain during interrupt teardown failed: {error}", {
+              error: err instanceof Error ? err.message : String(err),
+            });
           });
-        });
-        if (!closedCleanly) {
-          throw new AgentContextLockError(state.workdir);
+          if (!closedCleanly) {
+            throw new AgentContextLockError(state.workdir);
+          }
+          state.currentAgent = await services.buildAgent();
+          services.cycleRecorder.reset();
+          state.streamPromise = consumeStream(liveAgent(state).stream(), streamSink);
+          services.workflowController.reattach();
+          state.fatalBuildError = null;
+        } catch (err) {
+          recordRunError(state, err);
+          state.fatalBuildError = agentRebuildFailure(err);
         }
-        state.currentAgent = await services.buildAgent();
-        services.cycleRecorder.reset();
-        state.streamPromise = consumeStream(liveAgent(state).stream(), streamSink);
-        services.workflowController.reattach();
-        state.fatalBuildError = null;
-      } catch (err) {
-        recordRunError(state, err);
-        state.fatalBuildError = agentRebuildFailure(err);
-      }
+      },
     });
   };
   state.interrupt = interrupt;

tests/unit/tui/runner.test.ts

@@ -5,6 +5,7 @@ import {
   agentRebuildFailure,
   closeAgentForRebuild,
   resumeTranscriptLoadErrorBlock,
+  startInterruptRebuild,
 } from "../../../src/tui/runner/exit.js";
 import { createTUIEventEmitter, getTUIRunSummaryStatus } from "../../../src/tui/runner/index.js";
 import { loadLocalSettingsWriteBase } from "../../../src/tui/runner/settings.js";
@@ -287,3 +288,28 @@ test("a rejecting reload op through the real session-operation-queue never trigg
 // failing a single assertion. The test above is the harness-compatible half
 // of that pair: same real queue, same real helpers, proving the fixed shape
 // produces no such failure.
+
+// Overlay accept/decline tests stub bump() inside resolveSuspended, so deleting
+// the interrupt-site bump would not fail them. Drive the interrupt helper itself.
+test("interrupt bumps delivery generation before enqueueing rebuild", () => {
+  const order: string[] = [];
+  startInterruptRebuild({
+    deliveryGeneration: {
+      bump: () => {
+        order.push("bump");
+      },
+    },
+    markSendAborted: () => {
+      order.push("abort");
+    },
+    enqueue: (op) => {
+      order.push("enqueue");
+      return op();
+    },
+    rebuild: async () => {
+      order.push("rebuild");
+    },
+  });
+  expect(order[0]).toBe("bump");
+  expect(order.indexOf("enqueue")).toBeGreaterThan(0);
+});