feat(compaction): fold to a token-capped tail, not recent turns

Author: TheGreatAxios

e2e/compaction-read-paging.test.ts

@@ -41,10 +41,12 @@ function logLines(count: number): string {
 async function openFoldSession(): Promise<E2ESession> {
   const session = await openE2ESession({
     permissionGate: e2ePermissionGate(),
-    // A tiny tail budget keeps the fold honest: the default 7500-token
+    // A tiny tail budget keeps the fold honest: the default 2500-token
     // budget would absorb this small scenario into the live tail and the
     // compactor would correctly no-op.
-    compactionShape: { tailBudgetTokens: 10 },
+    // Budget fits the paged read windows in the live tail but not the bulky
+    // pad turns, so the fold still fires.
+    compactionShape: { tailBudgetTokens: 500 },
     // Echo the summarized turns verbatim: the spine must exist, and this
     // scenario asserts on the kept live bodies, not the summary text.
     compactionCompletion: async (turns) =>
@@ -78,7 +80,7 @@ async function lastRequestBody(session: E2ESession): Promise<string> {
 async function padTurns(session: E2ESession, count: number): Promise<void> {
   for (let i = 0; i < count; i++) {
     session.harness.scenario.replyOnce("anthropic", {
-      text: `Acknowledged ${i}.`,
+      text: `Acknowledged ${i}. ${"pad".repeat(800)}`,
       headUsage: LOW_USAGE,
     });
     await runUntilDone(session, `Pad turn ${i}.`);

evals/compaction/fixtures.ts

@@ -11,7 +11,7 @@ export const BASELINE = {
   syntheticLowInput: 100,
   syntheticTriggerInput: 200000,
   outputTokens: 1,
-  keepRecentTurns: 6,
+  tailBudgetTokens: 2500,
   summaryMaxChars: 4000,
   wallTimeoutMs: 30000,
 } as const;

src/agent/compaction.test.ts

@@ -17,7 +17,6 @@ import {
   compactionThresholdFor,
 } from "../provider/context-window.js";
 import {
-  COMPACTOR_KEEP_RECENT_TURNS,
   COMPACT_SPACER_TEXT,
   LEGACY_COMPACT_SPACER_TEXT,
   compactorNoOpFloor,
@@ -149,7 +148,6 @@ const overThreshold = compactionThresholdFor("m") + 1;
 const wideDelta = compactionWideResumeDeltaFor("m");
 const inferAction: ReactorAction[] = [{ type: "infer" }];
 const tenTurns = turnsOfLength(10, 1);
-const threeTurns = turnsOfLength(3, 1);
 
 describe("compaction governor", () => {
   test("stays inert below the threshold or with few turns", () => {
@@ -159,7 +157,7 @@ describe("compaction governor", () => {
       governor.interceptActions(toolDone(), inferAction, capabilities),
     ).toBeNull();
 
-    governor.noteInferenceDone(inferenceDone(overThreshold), threeTurns);
+    governor.noteInferenceDone(inferenceDone(overThreshold), turnsOfLength(1, 1));
     expect(
       governor.interceptActions(toolDone(), inferAction, capabilities),
     ).toBeNull();
@@ -474,13 +472,12 @@ describe("compaction governor", () => {
   });
 
   test("stays inert below the minimum-turn floor no matter how far over threshold", () => {
-    // Two turns is well under MIN_TURNS_TO_COMPACT. createPruningCompactor
-    // no-ops at the same floor (see session/compactor.ts), so arming here
-    // would spend a reactor cycle that cannot shrink anything.
+    // A single turn is the compactor no-op floor. Arming here would spend a
+    // reactor cycle that cannot shrink anything.
     const governor = createCompactionGovernor(() => undefined);
     governor.noteInferenceDone(
       inferenceDone(overThreshold * 10),
-      turnsOfLength(2, 1),
+      turnsOfLength(1, 1),
     );
     expect(
       governor.interceptActions(toolDone(), inferAction, capabilities),
@@ -514,9 +511,9 @@ describe("compaction governor", () => {
 
   test("never arms at the exact turn count createPruningCompactor no-ops on", () => {
     // createPruningCompactor's own no-op floor (session/compactor.ts) is
-    // compactorNoOpFloor(COMPACTOR_KEEP_RECENT_TURNS). Arming at or below it
-    // would spend a reactor cycle that is guaranteed to shrink nothing.
-    const floor = compactorNoOpFloor(COMPACTOR_KEEP_RECENT_TURNS);
+    // compactorNoOpFloor(). Arming at or below it would spend a reactor cycle
+    // that is guaranteed to shrink nothing.
+    const floor = compactorNoOpFloor();
     const governor = createCompactionGovernor(() => undefined);
     governor.noteInferenceDone(
       inferenceDone(overThreshold),
@@ -528,7 +525,7 @@ describe("compaction governor", () => {
   });
 
   test("arms one turn past the floor createPruningCompactor no-ops on", () => {
-    const floor = compactorNoOpFloor(COMPACTOR_KEEP_RECENT_TURNS);
+    const floor = compactorNoOpFloor();
     const governor = createCompactionGovernor(() => undefined);
     governor.noteInferenceDone(
       inferenceDone(overThreshold),
@@ -708,7 +705,7 @@ describe("compaction governor", () => {
 
   test("manual compact no-ops below the compactor floor", () => {
     const governor = createCompactionGovernor(undefined);
-    governor.noteInferenceDone(inferenceDone(overThreshold), threeTurns);
+    governor.noteInferenceDone(inferenceDone(overThreshold), turnsOfLength(1, 1));
     expect(governor.requestManual("focus on tests")).toBe("noop");
     expect(governor.extraInstructions).toBeUndefined();
     expect(
@@ -828,25 +825,23 @@ describe("post-compact above-threshold latch (CL-9006)", () => {
     ).toBeNull();
   });
 
-  test("a wide resume gap while still over threshold re-arms", () => {
+  test("a still-over fold reports non-convergence instead of re-arming on a wide gap", () => {
     const governor = createCompactionGovernor(() => undefined);
     governor.noteInferenceDone(inferenceDone(overThreshold), tenTurns);
     expect(
       governor.interceptActions(toolDone(), inferAction, capabilities),
     ).not.toBeNull();
 
     governor.noteInferenceDone(inferenceDone(overThreshold), tenTurns);
+    expect(governor.foldNonConverged).toBe(true);
     governor.noteInferenceDone(
       inferenceDone(overThreshold + wideDelta),
       tenTurns,
     );
-    const actions = governor.interceptActions(
-      toolDone(),
-      inferAction,
-      capabilities,
-    );
-    expect(actions).not.toBeNull();
-    expect(actions?.some((a) => a.type === "compact")).toBe(true);
+    expect(
+      governor.interceptActions(toolDone(), inferAction, capabilities),
+    ).toBeNull();
+    expect(governor.foldNonConverged).toBe(true);
   });
 
   test("the consecutive-compact cap holds across tool-call occupancy", () => {
@@ -856,29 +851,17 @@ describe("post-compact above-threshold latch (CL-9006)", () => {
       governor.interceptActions(toolDone(), inferAction, capabilities),
     ).not.toBeNull();
 
+    // Post-compact measurement still over: the fold is non-converged and the
+    // cap is spent, even past a wide gap and tool-call occupancy.
     governor.noteInferenceDone(inferenceDone(overThreshold), tenTurns);
-    governor.noteInferenceDone(
-      inferenceDone(overThreshold + wideDelta),
-      tenTurns,
-    );
-    expect(
-      governor.interceptActions(toolDone(), inferAction, capabilities),
-    ).not.toBeNull();
-
-    // Post-compact measurement still over: tool-call occupancy must not reset
-    // the cap, even past a wide gap.
-    governor.noteInferenceDone(
-      inferenceDone(overThreshold + wideDelta),
-      tenTurns,
-    );
+    expect(governor.foldNonConverged).toBe(true);
     governor.noteInferenceDone(
       inferenceDoneWithTools(overThreshold + 2 * wideDelta),
       tenTurns,
     );
     expect(
       governor.interceptActions(toolDone(), inferAction, capabilities),
     ).toBeNull();
-    // The idle path shares the same cap.
     governor.noteIdleTurn(
       inferenceDoneWithTools(overThreshold + 2 * wideDelta),
       [{ type: "reply", content: "done" }],
@@ -942,19 +925,17 @@ describe("post-compact above-threshold latch (CL-9006)", () => {
     expect(
       governor.interceptActions(toolDone(), inferAction, capabilities),
     ).toBeNull();
+    expect(governor.foldNonConverged).toBe(true);
 
-    // Wide gap re-arms identically to the automatic path.
+    // Wide gap does not silently re-arm the automatic path after a still-over
+    // operator fold; the fold already reported non-convergence.
     governor.noteInferenceDone(
       inferenceDone(overThreshold + wideDelta),
       tenTurns,
     );
-    const actions = governor.interceptActions(
-      toolDone(),
-      inferAction,
-      capabilities,
-    );
-    expect(actions).not.toBeNull();
-    expect(actions?.some((a) => a.type === "compact")).toBe(true);
+    expect(
+      governor.interceptActions(toolDone(), inferAction, capabilities),
+    ).toBeNull();
   });
 });
 
@@ -1012,7 +993,7 @@ describe("handoff arming (/handoff)", () => {
 
   test("requestHandoff noops at or below the fold floor and arms nothing", () => {
     const governor = createCompactionGovernor(undefined);
-    governor.syncFromTurns(threeTurns);
+    governor.syncFromTurns(turnsOfLength(1, 1));
     expect(governor.requestHandoff("now do the UI audit")).toBe("noop");
     expect(governor.extraInstructions).toBeUndefined();
     expect(
@@ -1226,7 +1207,7 @@ describe("handoff arming (/handoff)", () => {
     {
       title: "noop then cancelManual does not wipe extras from a prior fold",
       fire: "idle",
-      midRequests: [{ turns: threeTurns, text: "wipe this", result: "noop" }],
+      midRequests: [{ turns: turnsOfLength(1, 1), text: "wipe this", result: "noop" }],
     },
     {
       title:
@@ -1318,7 +1299,7 @@ describe("handoff arming (/handoff)", () => {
     expect(
       governor.interceptIdleContinuation(emptyMessage(), capabilities),
     ).not.toBeNull();
-    governor.syncFromTurns(threeTurns);
+    governor.syncFromTurns(turnsOfLength(1, 1));
     expect(governor.requestHandoff("wipe this")).toBe("noop");
     governor.cancelManual();
     expect(

src/agent/compaction.ts

@@ -13,7 +13,6 @@ import {
   isAtOrUnderCompactThreshold,
 } from "../provider/context-window.js";
 import {
-  COMPACTOR_KEEP_RECENT_TURNS,
   assistantTextIsCompactSpacerEcho,
   compactorNoOpFloor,
   isCompactSpacerEchoTurn,
@@ -26,11 +25,10 @@ import { onTurnBoundary } from "./reactor-events.js";
 
 const COMPACTOR_NAME = "pruning-compactor";
 // The exact turn count `createPruningCompactor` (session/compactor.ts) is
-// guaranteed to no-op on. Derived from the same keepRecentTurns both real
-// registrations (session, sub-agent) use, so this floor cannot silently
-// drift from what the compactor will actually do — arming at or below it
-// would spend a reactor cycle that shrinks nothing.
-const MIN_TURNS_TO_COMPACT = compactorNoOpFloor(COMPACTOR_KEEP_RECENT_TURNS);
+// guaranteed to no-op on. Derived from the same helper so this floor cannot
+// silently drift from what the compactor will actually do — arming at or
+// below it would spend a reactor cycle that shrinks nothing.
+const MIN_TURNS_TO_COMPACT = compactorNoOpFloor();
 const MAX_OVERFLOW_RECOVERIES = 2;
 // Last-ditch bound on compact→infer→compact when the post-compact infer never
 // gets under the high watermark. Counts consecutive threshold compacts with no
@@ -173,6 +171,11 @@ export function createCompactionGovernor(
   // operator, and overflow alike); only fold evidence moves past it.
   let tokensAtLastCompact: number | undefined;
   let awaitingPostCompactMeasurement = false;
+  // Set when a fold's post-compact measurement is still at or above the
+  // threshold. The CL-9006 latch still holds (small growth does not re-arm);
+  // the consecutive cap is spent immediately so a still-over fold reports
+  // non-convergence instead of silently saw-toothing on the wide-gap re-arm.
+  let foldNonConverged = false;
 
   // Running local estimate of the turns we send, plus the fixed system-prompt
   // and tool-schema overhead every request carries. Providers that omit usage
@@ -266,6 +269,10 @@ export function createCompactionGovernor(
     if (awaitingPostCompactMeasurement) {
       tokensAtLastCompact = contextTokens;
       awaitingPostCompactMeasurement = false;
+      if (!isAtOrUnderCompactThreshold(contextTokens, lastModel)) {
+        foldNonConverged = true;
+        consecutiveThresholdCompacts = MAX_CONSECUTIVE_THRESHOLD_COMPACTS;
+      }
     }
     // Fold evidence: usage back at or under the threshold clears the latch
     // and restores both rails (consecutive threshold compacts, overflow
@@ -275,6 +282,7 @@ export function createCompactionGovernor(
       tokensAtLastCompact = undefined;
       consecutiveThresholdCompacts = 0;
       overflowRecoveries = 0;
+      foldNonConverged = false;
     }
     // Assign, don't OR: an under-threshold follow-up must disarm a sticky
     // pending left from an earlier over-threshold turn (e.g. after the
@@ -579,6 +587,9 @@ export function createCompactionGovernor(
     get compactTurnCount(): number {
       return turnCount;
     },
+    get foldNonConverged(): boolean {
+      return foldNonConverged;
+    },
     requestManual,
     restoreExtraInstructions,
     restoreCacheWrite,

src/agent/director.test.ts

@@ -21,7 +21,6 @@ import { createAgentToolset } from "./tools.js";
 import { createAdvertisedToolset } from "../session/assemble-runtime.js";
 import { createPermissionGate } from "../permission/gate.js";
 import {
-  COMPACTOR_KEEP_RECENT_TURNS,
   COMPACT_SPACER_TEXT,
   LEGACY_COMPACT_SPACER_TEXT,
   compactorNoOpFloor,
@@ -803,7 +802,7 @@ function makeToolErrorEvent(callId: string, content: string) {
 // so the arming check finds a history actually worth compacting.
 const longState = {
   turns: Array.from(
-    { length: compactorNoOpFloor(COMPACTOR_KEEP_RECENT_TURNS) + 1 },
+    { length: compactorNoOpFloor() + 1 },
     () => ({
       role: "user",
       content: [],
@@ -1594,14 +1593,11 @@ describe("chatDirector compaction", () => {
 
   test("idle empty compact makes the post-compact estimate authoritative without inferring", async () => {
     const director = createChatDirector("", [], {});
-    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 largeTurns = Array.from({ length: 8 }, (_, i) => ({
+      role: i % 2 === 0 ? "user" : "assistant",
+      content: [{ type: "text", text: "x".repeat(200) }],
+      timestamp: i,
+    }));
     const longTurnsState = { turns: largeTurns } as unknown as ReactorState;
 
     await director.decide(