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).
 

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-