Derive the compaction floor from the compactor's own config

MIN_TURNS_TO_COMPACT was an independent literal that happened to
match createPruningCompactor's keepRecentTurns, itself duplicated as
a third literal in the session and sub-agent compactor registrations.
The independent copy was also off by one: the compactor's own no-op
condition is keepRecentTurns + 1, not keepRecentTurns, so the
governor could arm a compaction at the exact turn count the
compactor was guaranteed to no-op on. All three call sites now share
one exported constant, and the governor computes its floor with the
same function the compactor uses internally.

Author: TheGreatAxios

src/agent/compaction.test.ts

@@ -8,14 +8,25 @@ import type {
 } from "@intx/types/runtime";
 import { createCompactionGovernor } from "./compaction.js";
 import { compactionThresholdFor } from "../provider/context-window.js";
+import { COMPACTOR_KEEP_RECENT_TURNS, compactorNoOpFloor } from "../session/compactor.js";
 
 const capabilities = {
   infer: (options?: unknown) => ({ type: "infer", ...(options !== undefined ? { options } : {}) }),
   compact: (compactor: string, reason: string) => ({ type: "compact", compactor, reason }),
 } as unknown as ReactorCapabilities;
 
+// Distinct, non-zero cacheRead/cacheWrite so a test asserting on the total
+// would fail if compaction.ts ever stopped routing through the shared
+// contextTokensFromUsage and summed only `input` again.
 function usage(input: number): TokenUsage {
-  return { input, output: 0, cacheRead: 0, cacheWrite: 0, thinking: 0 };
+  return { input, output: 0, cacheRead: 3, cacheWrite: 5, thinking: 0 };
+}
+
+// A provider that truly omits usage reports every field as zero, not just
+// `input` — distinct from usage(0), which still carries the fixture's
+// non-zero cache values above.
+function zeroUsage(): TokenUsage {
+  return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, thinking: 0 };
 }
 
 function turnsOfLength(count: number, textLength: number): ConversationTurn[] {
@@ -39,7 +50,7 @@ function inferenceDoneWithoutUsage(): Extract<ReactorInboundEvent, { type: "infe
   return {
     type: "inference.done",
     turn: { role: "assistant", content: [{ type: "text", text: "ok" }] },
-    usage: usage(0),
+    usage: zeroUsage(),
     source: { sourceId: "s", provider: "p", model: "m" },
   } as unknown as Extract<ReactorInboundEvent, { type: "inference.done" }>;
 }
@@ -281,4 +292,43 @@ describe("compaction governor", () => {
     expect(actions).not.toBeNull();
     expect(actions?.some((a) => a.type === "compact")).toBe(true);
   });
+
+  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);
+    const governor = createCompactionGovernor(() => {});
+    governor.noteInferenceDone(inferenceDone(overThreshold), turnsOfLength(floor, 1));
+    expect(governor.interceptActions(toolDone(), inferAction, capabilities)).toBeNull();
+  });
+
+  test("arms one turn past the floor createPruningCompactor no-ops on", () => {
+    const floor = compactorNoOpFloor(COMPACTOR_KEEP_RECENT_TURNS);
+    const governor = createCompactionGovernor(() => {});
+    governor.noteInferenceDone(inferenceDone(overThreshold), turnsOfLength(floor + 1, 1));
+    const actions = governor.interceptActions(toolDone(), inferAction, capabilities);
+    expect(actions).not.toBeNull();
+    expect(actions?.some((a) => a.type === "compact")).toBe(true);
+  });
+
+  test("does not catch a huge tool result mid-cycle when the provider reported real usage", () => {
+    // Disclosed, accepted gap: the live tool.done re-check only re-derives
+    // arming from the local estimate when the last inference.done snapshot
+    // came from that same estimate (usingEstimate). When the provider
+    // reported real usage under threshold, that snapshot is trusted as
+    // authoritative until the next inference.done — a huge tool result
+    // arriving in between is not caught until then, unlike the
+    // usage-omitted case covered above.
+    const governor = createCompactionGovernor(() => {});
+    governor.noteInferenceDone(inferenceDone(1000), tenTurns);
+    expect(governor.interceptActions(toolDone(), inferAction, capabilities)).toBeNull();
+
+    const overThresholdChars = (compactionThresholdFor("m") + 1) * 4;
+    governor.syncFromTurns(turnsOfLength(10, Math.ceil(overThresholdChars / 10)));
+
+    // Still null: the live estimate is now over threshold, but the last
+    // arming decision trusted reported usage, so it is not re-checked here.
+    expect(governor.interceptActions(toolDone(), inferAction, capabilities)).toBeNull();
+  });
 });

src/agent/compaction.ts

@@ -6,10 +6,16 @@ import type {
   ToolDefinition,
 } from "@intx/types/runtime";
 import { compactionThresholdFor, contextTokensFromUsage } from "../provider/context-window.js";
+import { COMPACTOR_KEEP_RECENT_TURNS, compactorNoOpFloor } from "../session/compactor.js";
 import { createContextEstimate, estimateOverheadTokens } from "./context-estimate.js";
 
 const COMPACTOR_NAME = "pruning-compactor";
-const MIN_TURNS_TO_COMPACT = 6;
+// 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);
 const MAX_OVERFLOW_RECOVERIES = 2;
 
 // A compact action runs in its own reactor cycle, after which the reactor
@@ -55,10 +61,6 @@ export function createCompactionGovernor(
     return estimate.syncFromTurns(turns);
   }
 
-  // `createPruningCompactor` (session/compactor.ts) is the only layer that
-  // knows whether a history is actually shrinkable — it no-ops below its own
-  // keepRecentTurns floor. MIN_TURNS_TO_COMPACT mirrors that floor so the
-  // governor never arms a compaction the compactor is guaranteed to no-op.
   function isOverThreshold(contextTokens: number): boolean {
     return contextTokens > compactionThresholdFor(lastModel) && turnCount > MIN_TURNS_TO_COMPACT;
   }

src/context-compactor.test.ts

@@ -1,6 +1,7 @@
 import { describe, test, expect } from "bun:test";
 import {
   createPruningCompactor,
+  compactorNoOpFloor,
   buildContextEnvelope,
   formatPlan,
   classifyTaskBoundary,
@@ -46,6 +47,30 @@ describe("createPruningCompactor", () => {
     expect(result.output).toBe(turns); // Same reference when no compaction needed
   });
 
+  test("compactorNoOpFloor names the exact turn count apply() no-ops on", async () => {
+    // The compaction governor (agent/compaction.ts) derives its arming floor
+    // from this function so it never arms a compaction guaranteed to no-op.
+    // Anyone changing apply()'s no-op condition without updating
+    // compactorNoOpFloor accordingly breaks that guarantee silently.
+    const keepRecentTurns = 3;
+    const compactor = createPruningCompactor({ keepRecentTurns, summaryMaxChars: 500 });
+    const floor = compactorNoOpFloor(keepRecentTurns);
+
+    const atFloor = Array.from({ length: floor }, (_, i) =>
+      makeTurn({ role: i % 2 === 0 ? "user" : "assistant" }),
+    );
+    const pastFloor = Array.from({ length: floor + 1 }, (_, i) =>
+      makeTurn({ role: i % 2 === 0 ? "user" : "assistant" }),
+    );
+
+    expect((await compactor.apply(atFloor, mockStrategyCtx)).record.reason).toBe(
+      "no compaction needed",
+    );
+    expect((await compactor.apply(pastFloor, mockStrategyCtx)).record.reason).not.toBe(
+      "no compaction needed",
+    );
+  });
+
   test("compacts old turns and preserves recent ones", async () => {
     const compactor = createPruningCompactor({ keepRecentTurns: 2, summaryMaxChars: 500 });
     const turns: ConversationTurn[] = [

src/director.test.ts

@@ -3,6 +3,7 @@ import { createChatDirector } from "./agent/director.js";
 import { createAgentToolset } from "./agent/tools.js";
 import { advertisedTools, createActivatedToolTracker } from "./agent/tool-search.js";
 import { createPermissionGate } from "./permission/gate.js";
+import { COMPACTOR_KEEP_RECENT_TURNS, compactorNoOpFloor } from "./session/compactor.js";
 import type { SessionMetadata, TaskBoundary } from "./session/compactor.js";
 import type { ExtendedInferenceOptions } from "@intx/inference";
 import type { ReactorState, ReactorCapabilities, ReactorAction, ReactorInboundEvent } from "@intx/types/runtime";
@@ -275,7 +276,14 @@ describe("chatDirector compaction", () => {
     const director = createChatDirector("", [], undefined, undefined, undefined, undefined, undefined, undefined, () => {
       continuations++;
     });
-    const longState = { turns: Array.from({ length: 7 }, () => ({ role: "user", content: [], timestamp: 0 })) } as unknown as ReactorState;
+    // One turn past createPruningCompactor's own no-op floor (session/compactor.ts),
+    // so the arming check finds a history actually worth compacting.
+    const longState = {
+      turns: Array.from(
+        { length: compactorNoOpFloor(COMPACTOR_KEEP_RECENT_TURNS) + 1 },
+        () => ({ role: "user", content: [], timestamp: 0 }),
+      ),
+    } as unknown as ReactorState;
 
     const replyActions = actionsArray(await director.decide(textInferenceDone(999_999), longState, mockCapabilities));
     expect(replyActions.some((a) => a.type === "reply")).toBe(true);
@@ -288,7 +296,13 @@ describe("chatDirector compaction", () => {
     ]);
   });
 
-  const longState = { turns: Array.from({ length: 7 }, () => ({ role: "user", content: [], timestamp: 0 })) } as unknown as ReactorState;
+  // One turn past createPruningCompactor's own no-op floor (session/compactor.ts).
+  const longState = {
+    turns: Array.from(
+      { length: compactorNoOpFloor(COMPACTOR_KEEP_RECENT_TURNS) + 1 },
+      () => ({ role: "user", content: [], timestamp: 0 }),
+    ),
+  } as unknown as ReactorState;
 
   function overThresholdToolTurn(): ReactorInboundEvent {
     return {

src/session/compactor.ts

@@ -217,6 +217,19 @@ const DEFAULT_COMPACTOR_CONFIG: CompactorConfig = {
   stripResultContent: false,
 };
 
+// Recent turns kept verbatim by both real pruning-compactor registrations
+// (the main session and sub-agents). Exported so callers that need to know
+// in advance whether a compaction would do anything — the compaction
+// governor's arming floor — derive it from this value instead of carrying
+// an independent literal that can silently drift out of sync.
+export const COMPACTOR_KEEP_RECENT_TURNS = 6;
+
+// `apply` below no-ops at or below this turn count: keeping `keepRecentTurns`
+// turns plus at least one more is what makes pruning worth doing at all.
+export function compactorNoOpFloor(keepRecentTurns: number): number {
+  return keepRecentTurns + 1;
+}
+
 // Minimum anchor score for a turn to be pulled forward past the summary boundary.
 const ANCHOR_SCORE_THRESHOLD = 5;
 
@@ -425,7 +438,7 @@ export function createPruningCompactor(
       // leave the inference-facing context as soon as they exit the recent window.
       const aged = await ageImagesOutsideRecentWindow(turns, cfg.keepRecentTurns);
 
-      if (aged.turns.length <= cfg.keepRecentTurns + 1) {
+      if (aged.turns.length <= compactorNoOpFloor(cfg.keepRecentTurns)) {
         return {
           output: aged.turns,
           record: {

src/session/runtime-assembly.ts

@@ -38,7 +38,7 @@ import {
 import type { Approval, GrantScope } from "../permission/types.js";
 import type { ReasoningEffort } from "../provider/reasoning-effort.js";
 import type { SubAgentProvider } from "../subagent/index.js";
-import { createPruningCompactor } from "./compactor.js";
+import { COMPACTOR_KEEP_RECENT_TURNS, createPruningCompactor } from "./compactor.js";
 
 // ---------------------------------------------------------------------------
 // 1. Sub-agent provider literal
@@ -238,7 +238,6 @@ export function buildSessionSourcesFromConfig(
 // 6. Pruning-compactor config
 // ---------------------------------------------------------------------------
 
-const SESSION_COMPACTOR_KEEP_RECENT = 6;
 const SESSION_COMPACTOR_SUMMARY_MAX_CHARS = 2500;
 
 export type SessionPruningCompactorArgs = {
@@ -251,7 +250,7 @@ export function createSessionPruningCompactor(
   args: SessionPruningCompactorArgs,
 ): Compactor {
   return createPruningCompactor({
-    keepRecentTurns: SESSION_COMPACTOR_KEEP_RECENT,
+    keepRecentTurns: COMPACTOR_KEEP_RECENT_TURNS,
     summaryMaxChars: SESSION_COMPACTOR_SUMMARY_MAX_CHARS,
     ...(args.compactionMode !== "pruning"
       ? { summarize: args.summarize }

src/subagent/run.ts

@@ -40,7 +40,7 @@ import { shouldApplyGrokAntiThrash } from "./provider-family.js";
 import { resolveModelFamilyPolicy } from "../agent/model-family-policy.js";
 import { normalizeToolDefinitionsForProvider } from "../agent/tool-schema-normalize.js";
 
-import { createPruningCompactor } from "../session/compactor.js";
+import { COMPACTOR_KEEP_RECENT_TURNS, createPruningCompactor } from "../session/compactor.js";
 import { createAttachmentRehydrateTransform } from "../session/attachment-store.js";
 import { createModelSummarizer } from "../session/summarizer.js";
 import { gatherEnvironment } from "../agent/environment.js";
@@ -496,7 +496,7 @@ async function runSubAgentInner(params: RunSubAgentParams): Promise<string> {
     }),
     compactors: {
       "pruning-compactor": createPruningCompactor({
-        keepRecentTurns: 6,
+        keepRecentTurns: COMPACTOR_KEEP_RECENT_TURNS,
         summaryMaxChars: 2500,
         stripResultContent: true,
         // A structured model summary keeps sub-agent context useful across a