Refresh the context meter after idle compaction

Idle compaction with an empty continuation never marked the governor
estimate authoritative, so the prompt meter kept pre-fold occupancy
until the next user turn. Resume with a meter-only settle so the
shrunk estimate paints without starting another inference.

Author: TheGreatAxios

src/agent/compaction.test.ts

@@ -102,8 +102,8 @@ describe("compaction governor", () => {
     expect(actions?.some((a) => a.type === "infer")).toBe(false);
     expect(continuations).toBe(1);
 
-    expect(governor.resumeAfterCompact(emptyMessage())).toBe(true);
-    expect(governor.resumeAfterCompact(emptyMessage())).toBe(false);
+    expect(governor.resumeAfterCompact(emptyMessage())).toBe("infer");
+    expect(governor.resumeAfterCompact(emptyMessage())).toBeNull();
   });
 
   test("stays inert below the threshold or with few turns", () => {
@@ -133,7 +133,7 @@ describe("compaction governor", () => {
   test("recovers from context overflow a bounded number of times", () => {
     const governor = createCompactionGovernor(() => {});
     expect(governor.interceptOverflow(overflowError(), capabilities)).not.toBeNull();
-    expect(governor.resumeAfterCompact(emptyMessage())).toBe(true);
+    expect(governor.resumeAfterCompact(emptyMessage())).toBe("infer");
     expect(governor.interceptOverflow(overflowError(), capabilities)).not.toBeNull();
     expect(governor.interceptOverflow(overflowError(), capabilities)).toBeNull();
 
@@ -161,6 +161,38 @@ describe("compaction governor", () => {
     expect(governor.interceptIdleContinuation(emptyMessage(), capabilities)).toBeNull();
   });
 
+  // Idle compact with an empty continuation previously left postCompactInfer
+  // unset, so resumeAfterCompact never fired and notePostCompact never ran —
+  // the Ctx meter stayed on pre-compact lastTurnUsage until the next user turn.
+  test("idle empty compact syncs the meter after shrink without a following user turn", () => {
+    let continuations = 0;
+    const governor = createCompactionGovernor(() => continuations++);
+    const large = turnsOfLength(10, 200);
+    governor.noteInferenceDone(inferenceDone(overThreshold), large);
+    expect(governor.usingEstimate).toBe(false);
+    const before = governor.estimatedTokens;
+
+    governor.noteIdleTurn(inferenceDone(overThreshold), [{ type: "reply", content: "done" }]);
+    expect(continuations).toBe(1);
+
+    const actions = governor.interceptIdleContinuation(emptyMessage(), capabilities);
+    expect(actions).toEqual([
+      { type: "compact", compactor: "pruning-compactor", reason: "context-threshold" },
+    ] as ReactorAction[]);
+    // A second continuation re-enters decide after the compact cycle so the
+    // governor can adopt the shrunk turns — without starting a new inference.
+    expect(continuations).toBe(2);
+
+    const shrunk = turnsOfLength(3, 20);
+    // resumeAfterCompact must arm the meter-only path (not infer) for empty idle.
+    expect(governor.resumeAfterCompact(emptyMessage())).toBe("meter");
+    governor.notePostCompact(shrunk);
+
+    expect(governor.usingEstimate).toBe(true);
+    expect(governor.estimatedTokens).toBeLessThan(before);
+    expect(governor.estimatedTokens).toBe(governor.syncFromTurns(shrunk));
+  });
+
   test("an operator message that races the idle continuation still compacts, then re-infers", () => {
     let continuations = 0;
     const governor = createCompactionGovernor(() => continuations++);
@@ -176,7 +208,7 @@ describe("compaction governor", () => {
     // A second continuation is requested so the operator message gets answered
     // after the compact cycle.
     expect(continuations).toBe(2);
-    expect(governor.resumeAfterCompact(emptyMessage())).toBe(true);
+    expect(governor.resumeAfterCompact(emptyMessage())).toBe("infer");
   });
 
   test("idle turns with follow-up work or under threshold never arm idle compaction", () => {

src/agent/compaction.ts

@@ -36,6 +36,10 @@ export function createCompactionGovernor(
   let pending = false;
   let idlePending = false;
   let postCompactInfer = false;
+  // Idle empty compact needs a post-compact decide cycle to adopt the shrunk
+  // turns for the meter, but must not start a new inference (there is no
+  // operator question to answer). Distinct from postCompactInfer.
+  let postCompactMeter = false;
   let overflowRecoveries = 0;
   // Set whenever the arming decision fell back to the local estimate because
   // the provider omitted usage or reported zero, so callers rendering a meter
@@ -137,12 +141,16 @@ export function createCompactionGovernor(
     idlePending = false;
     pending = false;
     const content = typeof event.message.content === "string" ? event.message.content : "";
-    // An operator message that raced the continuation is already in history;
-    // compact first, then request another continuation to answer it.
+    // The reactor delivers no event after compact, so always request a
+    // continuation to re-enter decide against the shrunk turns:
+    // - raced operator content → re-infer to answer it
+    // - empty synthetic continuation → meter-only sync (no infer)
     if (content.length > 0) {
       postCompactInfer = true;
-      requestContinuation?.();
+    } else {
+      postCompactMeter = true;
     }
+    requestContinuation?.();
     return [capabilities.compact(COMPACTOR_NAME, "context-threshold")];
   }
 
@@ -165,12 +173,22 @@ export function createCompactionGovernor(
     return [capabilities.compact(COMPACTOR_NAME, "context-overflow")];
   }
 
-  function resumeAfterCompact(event: ReactorInboundEvent): boolean {
-    if (!postCompactInfer || event.type !== "message.received") return false;
+  // After compact, a content-less continuation re-enters decide. "infer" means
+  // resume the interrupted loop; "meter" means adopt the shrunk turns for the
+  // Ctx display and stay idle (idle empty compact has nothing to answer).
+  function resumeAfterCompact(event: ReactorInboundEvent): "infer" | "meter" | null {
+    if (event.type !== "message.received") return null;
     const content = typeof event.message.content === "string" ? event.message.content : "";
-    if (content.length > 0) return false;
-    postCompactInfer = false;
-    return true;
+    if (content.length > 0) return null;
+    if (postCompactInfer) {
+      postCompactInfer = false;
+      return "infer";
+    }
+    if (postCompactMeter) {
+      postCompactMeter = false;
+      return "meter";
+    }
+    return null;
   }
 
   // After a successful compact, the provider-reported usage from before the

src/agent/director.ts

@@ -651,10 +651,14 @@ class ChatDirectorImpl extends DefaultDirector {
     state: ReactorState,
     capabilities: ReactorCapabilities,
   ): Promise<ReactorAction | ReactorAction[]> {
-    if (this.compaction.resumeAfterCompact(event)) {
+    const afterCompact = this.compaction.resumeAfterCompact(event);
+    if (afterCompact !== null) {
       // Compacted history is the live occupancy until the next provider-
       // reported inference.done; paint from the estimate in the meantime.
       this.compaction.notePostCompact(state.turns ?? []);
+      // Idle empty compact only needed the decide re-entry to sync the meter;
+      // stay idle rather than starting an unprompted inference.
+      if (afterCompact === "meter") return capabilities.wait();
       return capabilities.infer();
     }
     const idleCompact = this.compaction.interceptIdleContinuation(event, capabilities);

src/director.test.ts

@@ -363,6 +363,44 @@ describe("chatDirector compaction", () => {
     expect(compactActions).toEqual([
       { type: "compact", compactor: "pruning-compactor", reason: "context-threshold" },
     ]);
+    // Idle empty compact schedules a second continuation so decide can adopt
+    // the shrunk turns for the meter without starting a new inference.
+    expect(continuations).toBe(2);
+  });
+
+  test("idle empty compact makes the post-compact estimate authoritative without inferring", async () => {
+    const director = createChatDirector("", [], {
+      onTasksChange: () => {},
+      requestContinuation: () => {},
+    });
+    const largeTurns = Array.from(
+      { length: compactorNoOpFloor(COMPACTOR_KEEP_RECENT_TURNS) + 1 },
+      (_, i) => ({
+        role: i % 2 === 0 ? "user" : "assistant",
+        content: [{ type: "text", text: "x".repeat(200) }],
+        timestamp: i,
+      }),
+    );
+    const longState = { turns: largeTurns } as unknown as ReactorState;
+
+    await director.decide(textInferenceDone(999_999), longState, mockCapabilities);
+    expect(director.getContextEstimate().isEstimate).toBe(false);
+    const before = director.getContextEstimate().tokens;
+
+    await director.decide(messageReceived(""), longState, mockCapabilities);
+
+    // Simulate the reactor having compacted, then the meter-sync continuation.
+    const shrunkTurns = largeTurns.slice(-3);
+    const shrunkState = { turns: shrunkTurns } as unknown as ReactorState;
+    const afterActions = actionsArray(
+      await director.decide(messageReceived(""), shrunkState, mockCapabilities),
+    );
+    expect(afterActions.some((a) => a.type === "infer")).toBe(false);
+    expect(afterActions.some((a) => a.type === "wait" || a.type === "reply")).toBe(true);
+
+    const estimate = director.getContextEstimate();
+    expect(estimate.isEstimate).toBe(true);
+    expect(estimate.tokens).toBeLessThan(before);
   });
 
   // One turn past createPruningCompactor's own no-op floor (session/compactor.ts).

src/subagent/nudge-director.ts

@@ -161,10 +161,14 @@ export class SubAgentDirector extends DefaultDirector {
     state: ReactorState,
     capabilities: ReactorCapabilities,
   ): Promise<ReactorAction | ReactorAction[]> {
-    if (this.compaction.resumeAfterCompact(event)) {
+    const afterCompact = this.compaction.resumeAfterCompact(event);
+    if (afterCompact !== null) {
       // Compacted history is the live occupancy until the next provider-
       // reported inference.done; paint from the estimate in the meantime.
       this.compaction.notePostCompact(state.turns ?? []);
+      // Idle empty compact only needed the decide re-entry to sync the meter;
+      // stay idle rather than starting an unprompted inference.
+      if (afterCompact === "meter") return capabilities.wait();
       return this.applyPendingNudge([capabilities.infer()], capabilities);
     }
     const idleCompact = this.compaction.interceptIdleContinuation(event, capabilities);

src/tui/runner-host.test.ts

@@ -508,6 +508,39 @@ describe("bottom border cost run", () => {
       harness.destroy();
     }
   });
+
+  test("connector.reply refreshes the cost meter after idle compact meter-sync", async () => {
+    const harness = await createHarness({ width: 80, height: 24 });
+    const emitter = new EventEmitter();
+    let percent = 90;
+    const host = await mountRunnerHost({
+      title: "test",
+      eventEmitter: emitter,
+      send: () => {},
+      interrupt: () => {},
+      providers: {},
+      onModelSelect: () => {},
+      commands: [],
+      onCommand: () => {},
+      chrome: () => ({ agents: [] }),
+      subscribeChrome: () => () => {},
+      subAgentSessions: () => [],
+      createRenderer: async () => harness.renderer,
+      readCostSummary: () => ({ ...fakeCostSummary(), contextPercentUsed: percent }),
+    });
+    try {
+      expect(ruleOf(host.shell.promptBottomRule)).toContain("90%");
+
+      percent = 12;
+      emitter.emit("event", { type: "connector.reply", data: { content: "" } });
+
+      expect(ruleOf(host.shell.promptBottomRule)).toContain("12%");
+      expect(ruleOf(host.shell.promptBottomRule)).not.toContain("90%");
+    } finally {
+      host.dispose();
+      harness.destroy();
+    }
+  });
 });
 
 /** Resolves true when the host exited, false when it is still alive. */

src/tui/runner-host.ts

@@ -309,9 +309,16 @@ export async function mountRunnerHost(deps: RunnerHostDeps): Promise<RunnerHost>
   pushCostContext();
   // Completed turns update cost/context; inference.start also refreshes so a
   // post-compact estimate (synced in decide before the infer) paints before
-  // the next inference.done arrives with provider usage.
+  // the next inference.done arrives with provider usage. connector.reply
+  // covers idle empty compact, which syncs the meter then waits (no infer).
   const onCostEvent = (event: { type: string }): void => {
-    if (onTurnBoundary(event) || event.type === "inference.start") pushCostContext();
+    if (
+      onTurnBoundary(event) ||
+      event.type === "inference.start" ||
+      event.type === "connector.reply"
+    ) {
+      pushCostContext();
+    }
   };
   deps.eventEmitter.on("event", onCostEvent);