fix(tui): drop interrupt-stale continuation notices

Author: TheGreatAxios

src/tui/deliver-agent-message.test.ts

@@ -131,7 +131,7 @@ describe("runGenerationGuardedDeliver", () => {
 });
 
 describe("settleCompactionContinuationHop", () => {
-  test("a superseded hop requeues instead of delivering to the outgoing agent", async () => {
+  test("a superseded hop does not deliver to the outgoing agent", async () => {
     let generation = 1;
     const stillCurrent = () => generation === 1;
     let delivered = 0;
@@ -195,6 +195,45 @@ describe("settleCompactionContinuationHop", () => {
     expect(runs).toBe(1);
   });
 
+  test("an accepted hop stays accepted if generation flips after deliver", async () => {
+    let generation = 1;
+    const result = await settleCompactionContinuationHop({
+      stillCurrent: () => generation === 1,
+      deliver: async () => {
+        generation = 2;
+        return { status: "accepted" as const };
+      },
+      onSuperseded: () => {
+        throw new Error("accepted hop must not be relabeled superseded");
+      },
+    });
+    expect(result).toEqual({ status: "accepted" });
+  });
+
+  test("a closed hop that goes stale does not retry deliver", async () => {
+    let generation = 1;
+    let attempts = 0;
+    const result = await settleCompactionContinuationHop({
+      stillCurrent: () => generation === 1,
+      deliver: async () => {
+        attempts += 1;
+        generation = 2;
+        return {
+          status: "not-delivered" as const,
+          reason: "agent-closed" as const,
+          detail: "agent is closed",
+        };
+      },
+      onSuperseded: () => undefined,
+    });
+    expect(result).toEqual({
+      status: "not-delivered",
+      reason: "superseded",
+      detail: "session identity changed before delivery",
+    });
+    expect(attempts).toBe(1);
+  });
+
   test("continuation enqueued then interrupt rebuild queued does not auto-deliver to the replacement agent", async () => {
     const { enqueue, enqueuePreemptible, abortInFlight, awaitTail } =
       createSessionOperationQueue();
@@ -393,6 +432,34 @@ describe("settleCompactionContinuationHop", () => {
     await awaitTail();
     expect(delivered).toEqual([1, 2]);
   });
+
+  test("an interrupt-stale hop does not report not-delivered", async () => {
+    const { enqueue, enqueuePreemptible, abortInFlight, awaitTail } =
+      createSessionOperationQueue();
+    const deliveryGeneration = createDeliveryGeneration();
+    const notices: string[] = [];
+
+    enqueueCompactionContinuationHop({
+      enqueue: enqueuePreemptible,
+      captureGeneration: () => deliveryGeneration.capture(),
+      deliver: async () => ({ status: "accepted" as const }),
+      onResult: (result) => {
+        if (result.status === "accepted") return;
+        notices.push(result.detail);
+      },
+    });
+
+    startInterruptRebuild({
+      deliveryGeneration,
+      markSendAborted: () => undefined,
+      abortInFlight,
+      enqueue,
+      rebuild: async () => undefined,
+    });
+
+    await awaitTail();
+    expect(notices).toEqual([]);
+  });
 });
 
 describe("deliveryResultNotice", () => {

src/tui/delivery-queue.ts

@@ -84,9 +84,9 @@ export async function deliverAgentMessage(
 
 /**
  * Settles a deliver that was enqueued on the serial operation queue against
- * the shoot generation captured at enqueue time. The queue is FIFO with no
- * preemption, so a deliver queued ahead of a reload still executes after the
- * reload has replaced the agent — the generation must be re-checked when the
+ * the shoot generation captured at enqueue time. Serial ops stay FIFO with
+ * no preemption; continuation hops are preemptible, so a hung compact-continue
+ * cannot park interrupt. Either way the generation must be re-checked when the
  * queued closure runs, not just when it enqueues. A stale deliver takes the
  * `onStale` path (the caller reports `not-delivered`); a current deliver runs
  * the real settle. This is what closes the reload-vs-async-deliver race: a
@@ -134,14 +134,14 @@ export async function settleCompactionContinuationHop(options: {
     options.onSuperseded();
     return first;
   }
-  if (!options.stillCurrent()) {
-    return {
-      status: "not-delivered",
-      reason: "superseded",
-      detail: "session identity changed before delivery",
-    };
-  }
   if (first.status === "not-delivered" && first.reason === "agent-closed") {
+    if (!options.stillCurrent()) {
+      return {
+        status: "not-delivered",
+        reason: "superseded",
+        detail: "session identity changed before delivery",
+      };
+    }
     return options.deliver();
   }
   return first;
@@ -164,6 +164,8 @@ export function enqueueCompactionContinuationHop(options: {
       deliver: options.deliver,
       onSuperseded: () => undefined,
     });
+    if (!stillCurrent()) return;
+    if (compactionContinuationIsSuperseded(result)) return;
     options.onResult(result);
   });
 }
@@ -420,7 +422,8 @@ export interface SessionOperationQueue {
   /**
    * Same tail as `enqueue`, marked preemptible. `abortInFlight` races the
    * current op against a captured abort signal so a hung continuation cannot
-   * park rebuild, send, or quit.
+   * park rebuild or send. Quit still starts shutdown first, then awaits the
+   * tail — it does not call `abortInFlight`.
    */
   enqueuePreemptible: (op: () => Promise<void>) => Promise<void>;
   /**