fix(tui): re-issue compact continuation after a superseded hop (#1102)

* fix(tui): land compact continue on the replacement agent

* fix(subagent): wait instead of infer while ask_director is parked

Empty stall pings during a parked ask are dropped, not deferred, so
unpark cannot look like a stall-window continuation. Compact continues
skipped during the park still flush after the ask releases.

Author: TheGreatAxios

docs/ARCHITECTURE.md

@@ -161,7 +161,7 @@ The ChatDirector counts consecutive assistant turns that contain tool calls and
 
 #### Sub-agent stall management
 
-`SubAgentDirector` tracks `lastActivityAt`, updated on every real `inference.done` and `tool.done`. Directors are pure `decide(event, ...)` functions with no timer of their own and the reactor has no proactive "idle" event, so a genuinely silent worker (e.g. parked on a long-running background command with nothing else to do) produces no event for the director to react to. `runSubAgent` (`src/subagent/index.ts`) arms an external interval, at `subAgentStallTimeoutMs`, that pings the same content-less continuation channel the compaction governor uses to re-enter an idle reactor (`requestContinuation`). The director only acts on a ping if the elapsed time since `lastActivityAt` has crossed the timeout. A ping can still be delivered while `execute_tools` is in flight; outstanding call ids from the last `inference.done` reset the silence clock and wait rather than recording `stall-nudge` with a huge `silenceMs`. The first stall past the timeout records `stallNudgeAt` and issues one continuation nudge (asking the worker to check on the background work or report status). Later empty pings inside `subAgentStallTimeoutMs` of that instant wait without stopping or treating the ping as activity; salvage fires only once a ping arrives after that grace with still no `tool.done` / turn-boundary reset. That grace is what keeps two queued interval ticks from salvaging hundreds of milliseconds after the nudge. Any real activity clears `stallNudgeAt`, so a worker that is genuinely working through a slow single turn is never penalized. After the worker has already replied with a terminal report (complete envelope or salvage), further empty continuations — idle-compact meter sync or stall pings — return `wait` instead of falling through to `DefaultDirector.infer`; only a non-empty parent message (`resume_agent` / `send_input`) re-opens the brief.
+`SubAgentDirector` tracks `lastActivityAt`, updated on every real `inference.done` and `tool.done`. Directors are pure `decide(event, ...)` functions with no timer of their own and the reactor has no proactive "idle" event, so a genuinely silent worker (e.g. parked on a long-running background command with nothing else to do) produces no event for the director to react to. `runSubAgent` (`src/subagent/index.ts`) arms an external interval, at `subAgentStallTimeoutMs`, that pings the same content-less continuation channel the compaction governor uses to re-enter an idle reactor (`requestContinuation`). The director only acts on a ping if the elapsed time since `lastActivityAt` has crossed the timeout. A ping can still be delivered while `execute_tools` is in flight; outstanding call ids from the last `inference.done` reset the silence clock and wait rather than recording `stall-nudge` with a huge `silenceMs`. The first stall past the timeout records `stallNudgeAt` and issues one continuation nudge (asking the worker to check on the background work or report status). Later empty pings inside `subAgentStallTimeoutMs` of that instant wait without stopping or treating the ping as activity; salvage fires only once a ping arrives after that grace with still no `tool.done` / turn-boundary reset. That grace is what keeps two queued interval ticks from salvaging hundreds of milliseconds after the nudge. Any real activity clears `stallNudgeAt`, so a worker that is genuinely working through a slow single turn is never penalized. After the worker has already replied with a terminal report (complete envelope or salvage), further empty continuations — idle-compact meter sync or stall pings — return `wait` instead of falling through to `DefaultDirector.infer`; only a non-empty parent message (`resume_agent` / `send_input`) re-opens the brief. A parked `ask_director` is the same class of wait: empty stall pings are dropped (not deferred) for the park duration, compact-continue hops skipped during the park flush after unpark, and `SubAgentDirector` returns `wait` on any empty continuation that still arrives while the ask is pending so a long park cannot start a billable infer.
 
 **Intervention log**: every stop and nudge is appended as one JSONL record to `interventions.jsonl` in the firing worker's trace dir (`src/subagent/intervention-log.ts`), carrying the trigger's measured value beside the threshold it crossed, the provider/model/family it fired on, and the run state at that moment (turns used vs budget, tool calls, read/edit counts). A refused parent re-dispatch is recorded on the parent side, where no worker run exists to record it. The parent also appends one `outcome` record per completed dispatch — the salvage kind `classifyBriefSalvage` assigned, or a clean-complete marker, plus the dispatch count — so the log carries dispatch outcomes as well as interventions, and a stop record can later be read alongside what the dispatch it touched actually produced. Writes are fire-and-forget and swallow their own errors — a diagnostic must not be able to fail a run. `scripts/intervention-forensics.ts` aggregates these across local sessions: per-intervention counts by model family, the measured-value distribution against the threshold, two context columns (stops that fired on runs which had already edited files; stops that fired before half the turn budget was spent — neither is a measured false-positive rate, since either is equally consistent with a correct stop or a wrong one), and outcome counts by kind. This exists because every threshold in this tree was set by judgment and four of those judgments were later reverted — a threshold change is expected to cite this data (CL-6938).
 
@@ -192,7 +192,7 @@ When a cycle's input tokens cross a threshold, the director compacts the inferen
 - **Idle (end-of-turn)** — An interactive turn can end with a reply and then sit idle with no tool batch to intercept; the governor requests a continuation at that pause and compacts when it arrives. An operator message that races the continuation still compacts first, then re-enters inference to answer it.
 - **Overflow recovery** — A `context_overflow` inference error would otherwise become a terminal error reply; the governor compacts and retries instead, bounded so a history the compactor cannot shrink does not loop forever. Overflow ignores hysteresis for the compact itself.
 
-The compaction control flow is shaped by a reactor invariant: a `compact` action runs in its own cycle (it cannot be paired with `infer`), and **the reactor delivers no event after a compact cycle**. A director that simply emitted `compact` in place of the follow-up `infer` would leave the loop idle forever — the cause of an earlier stall. Instead the governor pairs `compact` with an emit action (`custom.compaction.continue`), and the host answers that emission by delivering a content-less inbound message (`buildCompactionContinuationMessage()`) through the serial operation queue, generation-guarded like every other deliver. That message adds no turn (`createInboundTurn` returns `null` for empty content) but re-enters the loop, where the director issues the follow-up `infer` against the freshly truncated history. Each emission is answered at most once (a replayed duplicate of an already-answered emission is ignored), and an unsolicited continuation with neither resume flag set answers `wait` rather than burning a billable inference. The legacy `requestContinuation` closure survives only on the sub-agent path, which delivers directly with no host emit hop; idle arming keeps the two channels exclusive (closure fires and the arming flag stays false, or no closure and the flag reports the arming) so a caller honoring both cannot double-deliver.
+The compaction control flow is shaped by a reactor invariant: a `compact` action runs in its own cycle (it cannot be paired with `infer`), and **the reactor delivers no event after a compact cycle**. A director that simply emitted `compact` in place of the follow-up `infer` would leave the loop idle forever — the cause of an earlier stall. Instead the governor pairs `compact` with an emit action (`custom.compaction.continue`), and the host answers that emission by delivering a content-less inbound message (`buildCompactionContinuationMessage()`) through the serial operation queue, generation-guarded like every other deliver. A hop superseded because interrupt already bumped generation and enqueued a rebuild is re-queued onto the replacement agent rather than consumed on the outgoing liveAgent. That message adds no turn (`createInboundTurn` returns `null` for empty content) but re-enters the loop, where the director issues the follow-up `infer` against the freshly truncated history. Each emission is answered at most once (a replayed duplicate of an already-answered emission is ignored), and an unsolicited continuation with neither resume flag set answers `wait` rather than burning a billable inference. The legacy `requestContinuation` closure survives only on the sub-agent path, which delivers directly with no host emit hop; idle arming keeps the two channels exclusive (closure fires and the arming flag stays false, or no closure and the flag reports the arming) so a caller honoring both cannot double-deliver.
 
 Compaction replaces older turns with a structured, workflow-aware summary rather than a stats blob: sections for **What Happened / What We're Doing / Relevant Links / Action Items / Next Steps**, with the active workflow and step woven in so compacting mid-`/build` or mid-`/plan` preserves the contract. The summary is produced by a one-shot model call; on any failure it falls back to a deterministic summary so a compaction cycle never breaks the session.
 

src/subagent/ask-director.test.ts

@@ -5,11 +5,11 @@ import {
   ASK_DIRECTOR_MAX_QUESTIONS,
   commitAskDirector,
   createAskDirectorState,
+  createDeferredContinuation,
   evaluateAskDirector,
   handleAskDirector,
   releaseAskDirector,
   resetAskDirectorTurn,
-  skipStallContinuationWhileAskPending,
 } from "./ask-director.js";
 
 describe("evaluateAskDirector", () => {
@@ -207,18 +207,43 @@ describe("evaluateAskDirector", () => {
 describe("requestContinuation stall skip", () => {
   test("is a no-op while askDirectorState.pending", () => {
     const state = createAskDirectorState();
+    const latch = createDeferredContinuation();
     let delivered = 0;
-    skipStallContinuationWhileAskPending(state, () => {
+    const deliver = () => {
       delivered += 1;
-    });
+    };
+    latch.request(state, deliver);
     expect(delivered).toBe(1);
 
     expect(evaluateAskDirector({ question: "which file?", state }).ok).toBe(
       true,
     );
-    skipStallContinuationWhileAskPending(state, () => {
+    latch.request(state, deliver);
+    expect(delivered).toBe(1);
+  });
+
+  test("ask-pending skip defers compact continuation until the ask releases", () => {
+    const state = createAskDirectorState();
+    const latch = createDeferredContinuation();
+    let delivered = 0;
+    const deliver = () => {
       delivered += 1;
-    });
+    };
+
+    expect(evaluateAskDirector({ question: "which file?", state }).ok).toBe(
+      true,
+    );
+    latch.request(state, deliver);
+    expect(delivered).toBe(0);
+
+    latch.flush(state, deliver);
+    expect(delivered).toBe(0);
+
+    releaseAskDirector(state);
+    latch.flush(state, deliver);
+    expect(delivered).toBe(1);
+
+    latch.flush(state, deliver);
     expect(delivered).toBe(1);
   });
 });

src/subagent/ask-director.ts

@@ -89,15 +89,30 @@ export function resetAskDirectorTurn(state: AskDirectorState): void {
 }
 
 /**
- * Waiting on the spawning director is work, not silence. A stall ping
- * would otherwise salvage a blocked ask_director as stalled.
+ * Compact continuation shares the stall ping channel. Skipping while
+ * ask_director is parked must not drop the only continue: remember the skip
+ * and flush after the ask releases.
  */
-export function skipStallContinuationWhileAskPending(
-  state: AskDirectorState,
-  deliver: () => void,
-): void {
-  if (state.pending) return;
-  deliver();
+export function createDeferredContinuation(): {
+  request: (state: AskDirectorState, deliver: () => void) => void;
+  flush: (state: AskDirectorState, deliver: () => void) => void;
+} {
+  let deferred = false;
+  return {
+    request(state, deliver) {
+      if (state.pending) {
+        deferred = true;
+        return;
+      }
+      deferred = false;
+      deliver();
+    },
+    flush(state, deliver) {
+      if (!deferred || state.pending) return;
+      deferred = false;
+      deliver();
+    },
+  };
 }
 
 export async function handleAskDirector(args: {

src/subagent/nudge-director.test.ts

@@ -1458,6 +1458,105 @@ describe("SubAgentDirector stall nudge grace", () => {
   });
 });
 
+describe("SubAgentDirector ask_director park wait-guard", () => {
+  test("empty stall ping during a parked ask waits instead of inferring", async () => {
+    let now = 6_000_000;
+    let parked = true;
+    const director = new SubAgentDirector(
+      "system",
+      [],
+      undefined,
+      1_000,
+      () => now,
+    );
+    director.observeAskPending(() => parked);
+    const caps = capabilities();
+
+    await director.decide(inferenceDoneText("which file?"), state, caps);
+    now += 60_000;
+    const parkedPing = actions(
+      await director.decide(messageReceived(""), state, caps),
+    );
+    expect(parkedPing).toEqual([{ type: "wait" }]);
+    expect(parkedPing.some((action) => action.type === "infer")).toBe(false);
+    expect(parkedPing.some((action) => action.type === "checkpoint")).toBe(
+      false,
+    );
+  });
+
+  test("compact continue skipped during park still resumes infer after unpark", async () => {
+    let parked = false;
+    let continuations = 0;
+    const director = new SubAgentDirector(
+      "system",
+      [],
+      () => {
+        continuations++;
+      },
+      30,
+      frozenNow,
+    );
+    director.observeAskPending(() => parked);
+    const caps = capabilities();
+
+    const compact = actions(
+      await director.decide(overflowError(), state, caps),
+    );
+    expect(compact).toEqual([
+      {
+        type: "compact",
+        compactor: "pruning-compactor",
+        reason: "context-overflow",
+      },
+    ]);
+    expect(continuations).toBe(1);
+
+    parked = true;
+    const duringPark = actions(
+      await director.decide(messageReceived(""), state, caps),
+    );
+    expect(duringPark).toEqual([{ type: "wait" }]);
+    expect(duringPark.some((action) => action.type === "infer")).toBe(false);
+
+    parked = false;
+    const afterUnpark = inferAction(
+      await director.decide(messageReceived(""), state, caps),
+    );
+    expect(afterUnpark.type).toBe("infer");
+  });
+
+  test("unparked silence past the stall window still stall-nudges", async () => {
+    let now = 7_000_000;
+    let parked = true;
+    const director = new SubAgentDirector(
+      "system",
+      [],
+      undefined,
+      1_000,
+      () => now,
+    );
+    director.observeAskPending(() => parked);
+    const caps = capabilities();
+
+    await director.decide(inferenceDoneText("which file?"), state, caps);
+    now += 60_000;
+    expect(
+      actions(await director.decide(messageReceived(""), state, caps)),
+    ).toEqual([{ type: "wait" }]);
+
+    parked = false;
+    now += 1_000;
+    const afterUnpark = actions(
+      await director.decide(messageReceived(""), state, caps),
+    );
+    expect(afterUnpark).toContainEqual({
+      type: "checkpoint",
+      message: "subagent-stall-nudge",
+    });
+    expect(afterUnpark.some((action) => action.type === "infer")).toBe(true);
+  });
+});
+
 function stubAdmission(
   notes: { provider: string; until: number }[],
 ): AdmissionQueue {

src/subagent/nudge-director.ts

@@ -171,6 +171,12 @@ export class SubAgentDirector extends DefaultDirector {
   // (resume_agent / send_input).
   private reportReplied = false;
 
+  // Live getter from run.ts over askDirectorState.pending. Empty stall pings
+  // and compact-continue hops must wait while the ask is parked — same idea as
+  // ChatDirector's unsolicited-empty wait. Optional: tests and non-leaf runs
+  // leave it unset.
+  private isAskPending: () => boolean = () => false;
+
   // Stall management: a leaf that goes quiet (e.g. parked on a long-running
   // background command with nothing else to do) produces no inbound events
   // for the director to react to. The reactor has no proactive "idle" event
@@ -215,6 +221,11 @@ export class SubAgentDirector extends DefaultDirector {
     this.onForcedStop = callback;
   }
 
+  /** Live ask_director park flag so empty continuations wait instead of inferring. */
+  observeAskPending(isPending: () => boolean): void {
+    this.isAskPending = isPending;
+  }
+
   /** Run state every intervention record carries, for judging it afterwards. */
   private interventionState(): {
     turnsCompleted: number;
@@ -284,6 +295,15 @@ export class SubAgentDirector extends DefaultDirector {
       this.verbatimToolCallNudgeFired = false;
     }
 
+    // Parked ask_director is waiting on the parent, not silent. Wait before
+    // compact resume / stall-nudge so a long park cannot burn a billable
+    // infer, and so an outstanding compact continue is not consumed.
+    if (isEmptyContinuation(event) && this.isAskPending()) {
+      this.lastActivityAt = this.now();
+      this.stallNudgeAt = undefined;
+      return capabilities.wait();
+    }
+
     const afterCompact = this.compaction.resumeAfterCompact(event);
     if (afterCompact !== null) {
       // Compacted history is the live occupancy until the next provider-