feat(session): gate anthropic prompt shrink behind settings

Cache expiry no longer compacts stored turns.

The prompt transform runs only when anthropicCachePrompt is set.

Author: TheGreatAxios

src/agent/compaction.test.ts

@@ -1020,10 +1020,8 @@ describe("provider-aware idle recompress (CL-8745)", () => {
     nowMs += MINUTE_MS + 1;
     expect(
       governor.interceptIdleContinuation(emptyMessage(), capabilities),
-    ).toEqual(ttlCompact);
-    expect(continuations).toBe(1);
-    // Empty continuation adopts the shrunk turns without a new inference.
-    expect(governor.resumeAfterCompact(emptyMessage())).toBe("meter");
+    ).toBeNull();
+    expect(continuations).toBe(0);
   });
 
   test("production LastCycleSource: anthropic fires at 5m, codex never does", () => {
@@ -1058,7 +1056,7 @@ describe("provider-aware idle recompress (CL-8745)", () => {
     nowMs += 5 * MINUTE_MS + 1;
     expect(
       anthropic.interceptIdleContinuation(emptyMessage(), capabilities),
-    ).toEqual(ttlCompact);
+    ).toBeNull();
     expect(
       codex.interceptIdleContinuation(emptyMessage(), capabilities),
     ).toBeNull();
@@ -1181,7 +1179,7 @@ describe("provider-aware idle recompress (CL-8745)", () => {
     nowMs += 5 * MINUTE_MS + 1;
     expect(
       governor.interceptIdleContinuation(emptyMessage(), capabilities),
-    ).toEqual(ttlCompact);
+    ).toBeNull();
   });
 
   test("after threshold compact and gap TTL, growth-armed compact stays blocked until a tool_call", () => {
@@ -1211,27 +1209,7 @@ describe("provider-aware idle recompress (CL-8745)", () => {
     nowMs += 5 * MINUTE_MS + 1;
     expect(
       governor.interceptIdleContinuation(emptyMessage(), capabilities),
-    ).toEqual(ttlCompact);
-    expect(governor.resumeAfterCompact(emptyMessage())).toBe("meter");
-
-    // Post-TTL snapshot, then growth past resumeDelta — pending re-arms,
-    // but the cap is full so interceptActions stays null.
-    governor.noteInferenceDone(inferenceDone(overThreshold), tenTurns);
-    governor.noteInferenceDone(
-      inferenceDone(overThreshold + resumeDelta),
-      tenTurns,
-    );
-    expect(
-      governor.interceptActions(toolDone(), inferAction, capabilities),
     ).toBeNull();
-
-    governor.noteInferenceDone(
-      inferenceDoneWithTools(overThreshold + 2 * resumeDelta),
-      tenTurns,
-    );
-    expect(
-      governor.interceptActions(toolDone(), inferAction, capabilities),
-    ).not.toBeNull();
   });
 
   test("does not fold under an outstanding tool batch, fires once it settles", () => {
@@ -1257,8 +1235,8 @@ describe("provider-aware idle recompress (CL-8745)", () => {
     ).toBeNull();
     expect(
       governor.interceptIdleContinuation(emptyMessage(), capabilities),
-    ).toEqual(ttlCompact);
-    expect(continuations).toBe(1);
+    ).toBeNull();
+    expect(continuations).toBe(0);
   });
 
   test("one fire per window, then the shared consecutive-compact cap stops the spiral", () => {
@@ -1276,31 +1254,10 @@ describe("provider-aware idle recompress (CL-8745)", () => {
     );
 
     nowMs += 5 * MINUTE_MS + 1;
-    expect(
-      governor.interceptIdleContinuation(emptyMessage(), capabilities),
-    ).toEqual(ttlCompact);
-    expect(governor.resumeAfterCompact(emptyMessage())).toBe("meter");
-    governor.notePostCompact(tenTurns);
-
-    // Inside the next window: no second fire.
-    nowMs += 4 * MINUTE_MS;
     expect(
       governor.interceptIdleContinuation(emptyMessage(), capabilities),
     ).toBeNull();
-
-    nowMs += MINUTE_MS + 1;
-    expect(
-      governor.interceptIdleContinuation(emptyMessage(), capabilities),
-    ).toEqual(ttlCompact);
-    expect(governor.resumeAfterCompact(emptyMessage())).toBe("meter");
-    governor.notePostCompact(tenTurns);
-
-    // Cap reached: the third window stays quiet.
-    nowMs += 5 * MINUTE_MS + 1;
-    expect(
-      governor.interceptIdleContinuation(emptyMessage(), capabilities),
-    ).toBeNull();
-    expect(continuations).toBe(2);
+    expect(continuations).toBe(0);
   });
 
   test("a raced operator message past the TTL still folds, then re-infers", () => {
@@ -1319,11 +1276,8 @@ describe("provider-aware idle recompress (CL-8745)", () => {
     nowMs += 6 * MINUTE_MS;
     expect(
       governor.interceptIdleContinuation(racedMessage(), capabilities),
-    ).toEqual(ttlCompact);
-    expect(continuations).toBe(1);
-    // The follow-up empty continuation carries the infer that answers the
-    // raced question (mirrors the threshold raced path).
-    expect(governor.resumeAfterCompact(emptyMessage())).toBe("infer");
+    ).toBeNull();
+    expect(continuations).toBe(0);
   });
 });
 

src/agent/compaction.ts

@@ -11,7 +11,6 @@ import {
   compactionThresholdFor,
   contextTokensFromUsage,
 } from "../provider/context-window.js";
-import { cacheTtlMsFor } from "../provider/cache-ttl.js";
 import {
   COMPACTOR_KEEP_RECENT_TURNS,
   assistantTextIsCompactSpacerEcho,
@@ -162,13 +161,7 @@ export function createCompactionGovernor(
   // can flag the number as approximate instead of implying provider-grade
   // precision.
   let usingEstimate = false;
-  // Last-cycle source of the last inference.done, kept for live re-checks
-  // between inference cycles (see interceptActions) where the event carries
-  // no source. Threshold sizing still keys off `model`; TTL identity needs
-  // `sourceId` / `provider` as well — production LastCycleSource stamps a
-  // bare model, and Ollama is `openai-compatible` with id `ollama/…`.
   let lastModel: string | undefined;
-  let lastCycleSource: LastCycleSource | undefined;
   let turnCount = 0;
   // Wall-clock of the last inference.done: the provider (re)wrote its prefix
   // cache for this session on that turn, so the provider TTL window in
@@ -284,7 +277,6 @@ export function createCompactionGovernor(
       consecutiveThresholdCompacts = 0;
     }
     syncFromTurns(turns);
-    lastCycleSource = event.source;
     lastModel = event.source?.model;
     lastCacheWriteAt = now();
     // The terminal reply ends the previous tool batch (its results are
@@ -390,37 +382,6 @@ export function createCompactionGovernor(
     return true;
   }
 
-  // Provider-aware idle recompress (CL-8745): the fold is a re-compress, not
-  // a cache play. Provider KV caches expire on their own schedule
-  // (provider/cache-ttl.ts); compressing after that expiry makes the next
-  // turn a cheaper write and later reads compound on the shrunk context. This
-  // fires on any live re-entry once `now - lastCacheWrite >= ttl`, including
-  // over-threshold sessions whose threshold path has disarmed (`pending` is
-  // false via growth hysteresis — the threshold path owns only armed
-  // over-threshold; the fold is still window- and cap-bounded). Guards, in
-  // order: threshold arming defers (pending), the fresh-tail floor (turns at
-  // or under it are all kept, so a fold would shrink nothing), the
-  // consecutive-compact cap (existing death-spiral bound, shared with the
-  // threshold path), providers with no TTL (undefined/empty model, local
-  // inference), no observed cache write yet, the TTL window itself, and one
-  // fire per window (a fresh fold rewrites the prefix; the summary call
-  // bypasses this governor so lastCacheWriteAt cannot observe it —
-  // lastCompactAt covers that). Never fires with a tool batch outstanding:
-  // the stall ping that triggers this can arrive mid-work.
-  function isTtlRecompressDue(nowMs: number): boolean {
-    if (pending) return false;
-    if (turnCount <= MIN_TURNS_TO_COMPACT) return false;
-    if (atThresholdCompactCap()) return false;
-    if (outstandingToolCalls > 0) return false;
-    const ttl = cacheTtlMsFor(lastCycleSource);
-    if (ttl === undefined) return false;
-    if (lastCacheWriteAt === undefined) return false;
-    if (nowMs - lastCacheWriteAt < ttl) return false;
-    if (lastCompactAt !== undefined && nowMs - lastCompactAt < ttl)
-      return false;
-    return true;
-  }
-
   function inboundText(event: ReactorInboundEvent): string {
     if (event.type !== "message.received") return "";
     return typeof event.message.content === "string"
@@ -479,12 +440,11 @@ export function createCompactionGovernor(
     // In-flight `/compact` (manualPending without idlePending) waits on
     // interceptActions; do not steal that hop with a TTL fold.
     if (manualPending) return null;
-    if (!isTtlRecompressDue(now())) return null;
-    return issueIdleFold(
-      inboundText(event),
-      capabilities,
-      "cache-ttl-recompress",
-    );
+    // Cache expiry is a prompt transform, not a fold. Compacting here rewrites
+    // turns.jsonl and drops the history the transform is supposed to leave
+    // stored. The Anthropic prompt transform stubs tool bodies on the request
+    // when this stamp is expired.
+    return null;
   }
 
   // A context-overflow inference error would otherwise terminate the loop
@@ -594,7 +554,6 @@ export function createCompactionGovernor(
   }): void {
     syncFromTurns(args.turns);
     lastCacheWriteAt = args.at;
-    lastCycleSource = args.source;
     lastModel = args.source.model;
   }
 

src/config/index.ts

@@ -576,6 +576,9 @@ export interface Config {
   cwd: string;
   task: string;
   dangerouslySkipPermissions: boolean;
+  // Experimental prompt shrink after an Anthropic cache expiry. Off unless
+  // settings set anthropicCachePrompt.
+  anthropicCachePrompt: boolean;
   // True when dangerouslySkipPermissions came from the persisted global
   // default rather than this invocation's CLI flag. Entry points use this to
   // surface a startup notice since the persisted default is otherwise silent.
@@ -1139,6 +1142,7 @@ export async function loadConfig(
     cwd,
     task: resumeTask,
     dangerouslySkipPermissions,
+    anthropicCachePrompt: settings?.anthropicCachePrompt === true,
     skipPermissionsFromSettings,
     auto,
     command,

src/config/settings.ts

@@ -182,6 +182,10 @@ export interface Settings {
   showPromptCost?: boolean;
   // User-global YOLO default; `/yolo` writes it.
   dangerouslySkipPermissions?: boolean;
+  // Experimental. When true, an expired Anthropic prompt cache stubs old tool
+  // results on the outgoing prompt only. Default off: sessions do not depend
+  // on that shrink.
+  anthropicCachePrompt?: boolean;
 }
 
 function modelRefKey(ref: ModelRef): string {
@@ -594,6 +598,7 @@ const SettingsSchema = type({
   "favoriteModels?": ModelRefSchema.array(),
   "showPromptCost?": "boolean",
   "dangerouslySkipPermissions?": "boolean",
+  "anthropicCachePrompt?": "boolean",
 });
 
 // Per-entry MCP shape without the name key. The "exactly one transport" rule is
@@ -797,6 +802,7 @@ export const GLOBAL_SETTINGS_OPTIONAL_KEYS = [
   "recentModels",
   "favoriteModels",
   "dangerouslySkipPermissions",
+  "anthropicCachePrompt",
 ] as const satisfies readonly (keyof OptionalSettingsFields)[];
 
 /** Optional local settings keys the load path is required to consider. */
@@ -964,6 +970,10 @@ function normalizeParsedSettings(path: string, parsed: unknown): Settings {
       s.dangerouslySkipPermissions !== undefined
         ? Boolean(s.dangerouslySkipPermissions)
         : undefined,
+    anthropicCachePrompt:
+      s.anthropicCachePrompt !== undefined
+        ? Boolean(s.anthropicCachePrompt)
+        : undefined,
   };
   return {
     providers: s.providers as Settings["providers"],

src/exec/runner.ts

@@ -862,6 +862,7 @@ export async function runExec(config: Config): Promise<ExecResult> {
       },
       getDefaultSource: () =>
         liveDefaultSource.length > 0 ? liveDefaultSource : liveSource.id,
+      anthropicCachePrompt: () => config.anthropicCachePrompt,
       getCompactor: () =>
         createSessionPruningCompactor({
           summarize: summarizeForCompaction,

src/session/anthropic-cache-prompt.test.ts

@@ -92,6 +92,19 @@ function history(): ConversationTurn[] {
 }
 
 describe("anthropic cache prompt transform", () => {
+  test("settings off leaves an expired Anthropic prompt unchanged", async () => {
+    const turns = history();
+    const transform = createAnthropicCachePromptTransform({
+      nowMs: () => NOW,
+      cacheWriteAt: () => NOW - 6 * MINUTE_MS,
+      protocol: () => "anthropic",
+      enabled: () => false,
+    });
+    const result = await transform.apply(turns, CTX);
+    expect(result.output).toBe(turns);
+    expect(result.record.reason).toBe("disabled");
+  });
+
   test("expired or missing Anthropic stamp stubs old tool bodies and leaves stored turns", async () => {
     const dir = await mkdtemp(join(tmpdir(), "anthropic-cache-prompt-"));
     const store = await createOptimizedContextStore(dir);

src/session/anthropic-cache-prompt.ts

@@ -18,6 +18,8 @@ export type AnthropicCachePromptDeps = {
   cacheWriteAt: () => number | undefined;
   /** Live adapter protocol (`InferenceSource.provider`). */
   protocol: () => string | undefined;
+  /** When omitted, the shrink is on. Settings pass false unless opted in. */
+  enabled?: () => boolean;
 };
 
 const STRATEGY = "anthropic-cache-prompt";
@@ -144,6 +146,9 @@ export function createAnthropicCachePromptTransform(
     name: STRATEGY,
     version: "1",
     async apply(turns, _ctx) {
+      if (deps.enabled !== undefined && !deps.enabled()) {
+        return passthrough(turns, "disabled");
+      }
       const ttl = cacheTtlMsFor(deps.protocol());
       if (ttl === undefined) return passthrough(turns, "non-anthropic");
       const at = deps.cacheWriteAt();

src/session/assemble-runtime.ts

@@ -509,6 +509,8 @@ export interface ChatAgentWiring {
   getDefaultSource: () => string;
   /** Read at each build so a compaction-mode toggle is visible on rebuild. */
   getCompactor: () => Compactor;
+  /** Experimental Anthropic prompt shrink. Default off when omitted. */
+  anthropicCachePrompt?: () => boolean;
   /**
    * Present when a resumed run record has an Anthropic-protocol cache write
    * and the provider about to be called is the same protocol. Read at each
@@ -706,6 +708,7 @@ export function assembleChatAgent(wiring: ChatAgentWiring): AssembledChatAgent {
           createAnthropicCachePromptTransform({
             nowMs: () => Date.now(),
             cacheWriteAt: () => getActiveRun()?.lastCacheWriteAt,
+            enabled: () => wiring.anthropicCachePrompt?.() === true,
             protocol: () => {
               const sources = wiring.getSources();
               const preferred = wiring.getDefaultSource();