fix(tui): let occupancy win after a stalled ask-wake abort

A stalled armed wake was re-surfacing before mailbox mail, so
occupancy lost the next turn. Share one interrupt path: interrupt
the hung inference, then mail, then wake only if still idle.
Expiring asks must abort that wake, not merely disarm it.

Author: TheGreatAxios

src/tui/runner/wiring.stall-bound.test.ts

@@ -148,6 +148,17 @@ describe("stall-bound primary turn (CL-8016)", () => {
         expect(bridge.turnMarkers().map((marker) => marker.path)).toContain(
           "stall-abort:awaiting-first-token",
         );
+        // ... the hung inference was interrupted before any new deliver ...
+        const interruptAt = port.calls.findIndex((call) => call.op === "interrupt");
+        expect(interruptAt).toBeGreaterThanOrEqual(0);
+        const wakeAfterInterrupt = port.calls
+          .slice(interruptAt + 1)
+          .filter(
+            (call): call is Extract<typeof call, { op: "deliver" }> =>
+              call.op === "deliver" &&
+              call.item.text.includes(ASK_DIRECTOR_WAKE_PREFIX),
+          );
+        expect(wakeAfterInterrupt).toHaveLength(0);
         // ... the queued operator message reached the port ...
         expect(
           port.calls.some(
@@ -173,6 +184,72 @@ describe("stall-bound primary turn (CL-8016)", () => {
     });
   });
 
+  test("stall monitor abort of an armed wake lets occupancy take the next turn", async () => {
+    await withTestRenderer(async (h) => {
+      let nowMs = 4_000_000;
+      let monitorTick: (() => void) | undefined;
+      const store = createSubAgentSessionStore({ now: () => nowMs });
+      parkWorker(store, "a");
+      const shell = createAppShell(h.renderer, {
+        terminal: { columns: 80, rows: 24 },
+        wireKeys: false,
+      });
+      const port = createRecordingPort();
+      const bridge = attachSessionBridge(shell, port, {
+        now: () => nowMs,
+        stallTimeoutMs: STALL_TIMEOUT_MS,
+        schedule: (fn) => {
+          monitorTick = fn;
+          return () => {
+            monitorTick = undefined;
+          };
+        },
+      });
+      try {
+        bridge.handle({
+          type: "agent-ask",
+          asks: pendingAskSnapshot(store.list(), (id) => {
+            const ask = store.peekAsk(id);
+            return ask === undefined ? undefined : ask;
+          }),
+        });
+        expect(bridge.turn.isProcessing).toBe(true);
+        expect(wakeDeliveries(port)).toHaveLength(1);
+
+        let mailDrives = 0;
+        bridge.setMailboxMailDriver(() => {
+          if (mailDrives > 0) return false;
+          mailDrives += 1;
+          bridge.beginSystemContinuation("mailbox occupancy");
+          return true;
+        });
+
+        nowMs += STALL_TIMEOUT_MS + 500;
+        expect(monitorTick).toBeDefined();
+        monitorTick?.();
+
+        // Production abort is the #1095 monitor tick → doInterrupt, not the
+        // 5s fleet poll. Occupancy must win that next turn; a re-surface wake
+        // must not start processing first.
+        const interruptAt = port.calls.findIndex((call) => call.op === "interrupt");
+        expect(interruptAt).toBeGreaterThanOrEqual(0);
+        expect(
+          port.calls.slice(interruptAt + 1).some(
+            (call) =>
+              call.op === "deliver" &&
+              call.item.text.includes(ASK_DIRECTOR_WAKE_PREFIX),
+          ),
+        ).toBe(false);
+        expect(mailDrives).toBe(1);
+        expect(wakeDeliveries(port)).toHaveLength(1);
+        expect(bridge.turn.isProcessing).toBe(true);
+        expect(bridge.turn.status).toBe("running");
+      } finally {
+        bridge.dispose();
+      }
+    });
+  });
+
   test("two parked asks settle exactly once via the ask deadline", async () => {
     await withTestRenderer(async (h) => {
       let nowMs = 2_000_000;
@@ -238,6 +315,9 @@ describe("stall-bound primary turn (CL-8016)", () => {
           expect(store.resolveAsk(worker.sessionId, "late")).toBe(false);
           expect(store.hasPendingAsk(worker.sessionId)).toBe(false);
         }
+        // Expiring the asks must also end the silent wake — disarm without
+        // abort would leave isProcessing hung with nothing left to re-surface.
+        expect(bridge.turn.isProcessing).toBe(false);
       } finally {
         bridge.dispose();
       }

src/tui/runtime-bridge.ts

@@ -311,9 +311,10 @@ export interface SessionBridge {
    * Stall bound for a silent ask-wake primary turn (CL-8016). If a wake was
    * actually sent (`askWakeTurnArmed`) and `shouldAbortForStall` says the
    * turn is silent past the bound (including awaiting-first-token, per
-   * #1095), un-dedupe the delivered wakes and interrupt so the questions
-   * re-surface escalated. Returns true when it aborted. Driven by the fleet
-   * stall poll, which settles deadline-past asks first.
+   * #1095), interrupt the hung inference, un-dedupe the delivered wakes,
+   * and hand the next turn to occupancy (mailbox mail) before any re-surface.
+   * Returns true when it aborted. Driven by the fleet stall poll, which
+   * settles deadline-past asks first, and by the #1095 monitor tick.
    */
   abortStalledWakeTurn: () => boolean;
   /**
@@ -1383,9 +1384,9 @@ function applyInbound(
         bag.askWakeResurface.delete(sessionId);
       }
     }
-    // A fresh snapshot with nothing pending means every parked question
-    // settled or expired: no wake turn is owed, so disarm the bound.
-    if (bag.pendingAskWake.size === 0) bag.askWakeTurnArmed = false;
+    // A fresh snapshot with nothing pending means no wake is owed, but a
+    // still-armed silent turn must stay armed so the stall abort can interrupt
+    // it. Disarming here (expire / send_input) would leave isProcessing hung.
     bag.flushPendingAskWake?.();
     return;
   }
@@ -1900,30 +1901,11 @@ export function attachSessionBridge(
   };
 
   /**
-   * Stall bound for a silent ask-wake primary turn (CL-8016). Only an armed
-   * (wake-sent, never settled) turn can match. Silence uses `shouldAbortForStall`
-   * — the same #1095 bound that already covers awaiting-first-token — then
-   * un-dedupes and interrupts so parked questions re-surface. Mail first so
-   * occupancy can take the next turn; the trailing wake flush restates if
-   * mail did not start one.
+   * Shared abort used by Ctrl+C, the #1095 monitor tick, and the fleet-poll
+   * stall bound. Interrupt the hung inference before any new deliver, then
+   * occupancy/mailbox first so a re-surface wake cannot steal that turn.
    */
-  const abortStalledWakeTurn = (): boolean => {
-    if (bag.disposed || !bag.askWakeTurnArmed) return false;
-    if (!shouldAbortForStall(stallArgsFor(now()))) return false;
-    const layer = turnStallLayer(bag.turn) ?? "mid-stream";
-    unDedupeArmedAskWakes();
-    recordTurnMarker(bag, `stall-abort:${layer}`);
-    bag.askWakeTurnArmed = false;
-    bag.turn = turnStateOnInterrupt(bag.turn, now());
-    paintPhase();
-    drainAtBoundary(shell, bag);
-    flushMailboxMail();
-    flushPendingAskWake();
-    return true;
-  };
-
-  const doInterrupt = (): void => {
-    if (bag.disposed) return;
+  const abortInFlightAndHandoff = (): void => {
     closeOpenRow(shell, bag);
     bag.pendingEchoes.length = 0;
     // The stopped attempt is no longer in flight. Expire the error-recovery
@@ -1942,14 +1924,37 @@ export function attachSessionBridge(
     // turn the operator (or the watchdog) deliberately stopped.
     recordLastSent(null);
     bag.awaitingContinuationInference = false;
-    // Armed wake that dies here (operator stop or #1095 stall abort) never
-    // landed: un-dedupe so flushPendingAskWake restates the questions.
+    // Armed wake that dies here (operator stop or stall abort) never
+    // landed: un-dedupe so flushPendingAskWake can restate the questions
+    // if occupancy does not take the next turn.
     unDedupeArmedAskWakes();
     bag.askWakeTurnArmed = false;
     bag.turn = turnStateOnInterrupt(bag.turn, now());
     paintPhase();
-    flushPendingAskWake();
     flushMailboxMail();
+    if (!bag.turn.isProcessing) flushPendingAskWake();
+  };
+
+  /**
+   * Stall bound for a silent ask-wake primary turn (CL-8016). Only an armed
+   * (wake-sent, never settled) turn can match. Silence uses `shouldAbortForStall`
+   * — the same #1095 bound that already covers awaiting-first-token — then
+   * interrupts the hung inference before any new deliver. Mail first so
+   * occupancy can take the next turn; the trailing wake flush restates only
+   * if mail did not start one.
+   */
+  const abortStalledWakeTurn = (): boolean => {
+    if (bag.disposed || !bag.askWakeTurnArmed) return false;
+    if (!shouldAbortForStall(stallArgsFor(now()))) return false;
+    const layer = turnStallLayer(bag.turn) ?? "mid-stream";
+    recordTurnMarker(bag, `stall-abort:${layer}`);
+    abortInFlightAndHandoff();
+    return true;
+  };
+
+  const doInterrupt = (): void => {
+    if (bag.disposed) return;
+    abortInFlightAndHandoff();
   };
   const clearQueuedDelivery = (): void => {
     if (bag.disposed) return;
@@ -2052,7 +2057,10 @@ export function attachSessionBridge(
     if (shouldAbortForStall(stallArgs)) {
       applyStallRecovery(
         {
-          abort: doInterrupt,
+          abort: () => {
+            if (abortStalledWakeTurn()) return;
+            doInterrupt();
+          },
           notify: (message) =>
             setStatusFlash(shell, message, { ttlMs: RUNTIME_FLASH_MS }),
         },