fix(tui): hang stalled ask-wake resurface on shouldAbortForStall

After the silent-turn abort, a second wake-only predicate would duplicate
that bound. Un-dedupe armed wakes on interrupt instead.

Author: TheGreatAxios

src/subagent/fleet-report.ask-wake.test.ts

@@ -84,4 +84,20 @@ describe("pendingAskWakeText", () => {
     expect(text).toContain("using target a1");
     expect(text.toLowerCase()).toContain("worker");
   });
+
+  test("a re-surface count restates that the earlier wake stalled", () => {
+    const text = pendingAskWakeText(
+      {
+        sessionId: "a1",
+        agentId: "builder",
+        description: "Build the thing",
+        question: "Which port?",
+        questionId: "q1",
+      },
+      { resurface: 1 },
+    );
+    expect(text).toContain("Re-surface 1");
+    expect(text).toContain("stalled");
+    expect(text).toContain("send_input");
+  });
 });

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

@@ -18,7 +18,8 @@ import { cancelWorkersForStop, createFleetStallPollTick } from "./wiring.js";
 
 // CL-8016: a silent primary turn (wake text sent, inference never starts)
 // must not freeze the message queue and parked worker questions forever.
-// The stall poll tick bounds that turn: past the stall threshold it aborts,
+// The stall poll tick bounds that turn via shouldAbortForStall (including
+// awaiting-first-token after #1095): past the stall threshold it aborts,
 // the queued operator message gets a fresh turn, and parked asks either
 // re-surface (escalated) or settle exactly once via the ask deadline.
 

src/tui/runtime-bridge.ts

@@ -49,7 +49,6 @@ import {
   repetitionRecoveryMessage,
   isStalledForDisplay,
   shouldAbortForStall,
-  shouldAbortForStalledWakeTurn,
   stallLevel,
   STALL_NOTICE_MESSAGE,
   STALL_NOTICE_MS,
@@ -309,12 +308,11 @@ export interface SessionBridge {
    */
   flushMailboxMail: () => void;
   /**
-   * Stall bound for a silent ask-wake primary turn (CL-8016). Ends the turn
-   * through the same path as an operator stop when it is still silent past
-   * the stall threshold, then hands queued mail over and re-surfaces the
-   * still-pending questions (escalated) so neither the queue nor the parked
-   * asks freeze. Returns true when it aborted. Never touches tool-execution
-   * or gated turns; those are someone else's turn shape. Driven by the fleet
+   * 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.
    */
   abortStalledWakeTurn: () => boolean;
@@ -1885,26 +1883,12 @@ export function attachSessionBridge(
   bag.flushMailboxMail = flushMailboxMail;
 
   /**
-   * Stall bound for a silent ask-wake primary turn (CL-8016). Only an armed
-   * (wake-sent, never settled) turn can match: the predicate bounds silence
-   * past the threshold while tool-execution and gated turns stay excluded.
-   * The layer is stamped before the interrupt so the marker names the hung
-   * layer instead of the post-abort idle. The turn ends through the same
-   * path as an operator stop — interrupt the record, hand the queued mail
-   * over, then let occupancy drive mail or re-surface the still-pending
-   * questions (escalated) — so neither the queue nor the parked asks freeze.
+   * A stalled armed wake never landed: drop matching deliveredAskWake entries
+   * and bump the resurface count so the next flush restates the questions
+   * (escalated) instead of skipping them as already delivered.
    */
-  const abortStalledWakeTurn = (): boolean => {
-    if (bag.disposed || !bag.askWakeTurnArmed) return false;
-    if (!shouldAbortForStalledWakeTurn(stallArgsFor(now()))) return false;
-    const layer = turnStallLayer(bag.turn) ?? "mid-stream";
-    // The aborted turn never landed its wakes: release the still-pending
-    // questions from delivery dedupe so the trailing flush restates them
-    // (escalated via the count), and bump the count so the restatement reads
-    // as proof the earlier turn stalled rather than as a duplicate. Settled
-    // or replaced questions are untouched — only a pending question whose
-    // delivered id matches can re-surface, so each abort yields at most one
-    // restatement per live question.
+  const unDedupeArmedAskWakes = (): void => {
+    if (!bag.askWakeTurnArmed) return;
     for (const [sessionId, ask] of bag.pendingAskWake) {
       if (bag.deliveredAskWake.get(sessionId) !== ask.questionId) continue;
       bag.deliveredAskWake.delete(sessionId);
@@ -1913,6 +1897,21 @@ export function attachSessionBridge(
         (bag.askWakeResurface.get(sessionId) ?? 0) + 1,
       );
     }
+  };
+
+  /**
+   * 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.
+   */
+  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());
@@ -1943,8 +1942,9 @@ export function attachSessionBridge(
     // turn the operator (or the watchdog) deliberately stopped.
     recordLastSent(null);
     bag.awaitingContinuationInference = false;
-    // An operator stop ends the turn the same way a settle does: no bound
-    // is owed anymore, whatever the turn was started for.
+    // Armed wake that dies here (operator stop or #1095 stall abort) never
+    // landed: un-dedupe so flushPendingAskWake restates the questions.
+    unDedupeArmedAskWakes();
     bag.askWakeTurnArmed = false;
     bag.turn = turnStateOnInterrupt(bag.turn, now());
     paintPhase();

src/tui/stall-watchdog.ts

@@ -96,29 +96,6 @@ export function shouldAbortForStall(args: ShouldAbortForStallArgs): boolean {
   return silentPastThreshold(args, args.stallTimeoutMs);
 }
 
-/**
- * Whether a silent primary turn started for parked `ask_director` questions
- * (CL-8016) is past the bound and should be aborted so the queue and the
- * questions unfreeze. Unlike `shouldAbortForStall` this deliberately includes
- * the awaiting-first-token state: a wake turn is machine-generated text the
- * parent never typed, so no operator intent is discarded by bounding it —
- * the abort re-surfaces the still-pending questions (escalated) or lets the
- * ask deadline settle them. Tool-execution turns are still excluded: an
- * `ask_director` wake turn never starts tools, so tools out means this is not
- * the wake turn stalling. Blocked turns are excluded via `status`.
- */
-export function shouldAbortForStalledWakeTurn(
-  args: ShouldAbortForStallArgs,
-): boolean {
-  if (args.status !== "running") return false;
-  if (args.nowMs - args.lastActivityAt < args.stallTimeoutMs) return false;
-  // Tool execution is someone else's turn shape, not a stalled wake turn.
-  if (args.activeToolCalls.length > 0 || args.streamingType === "tool") {
-    return false;
-  }
-  return args.isProcessing;
-}
-
 export type ShouldNoticeStallArgs = ShouldAbortForStallArgs & {
   readonly stallNoticeMs: number;
   /** Whether the repetition guard currently sees a looping tail. */