fix(session): keep cache expiry from compacting stored turns

The settings fixture covers anthropicCachePrompt.

Unused governor clocks are gone.

Author: TheGreatAxios

docs/ARCHITECTURE.md

@@ -191,20 +191,13 @@ When a cycle's input tokens cross a threshold, the director compacts the inferen
 
 - **Threshold at a tool pause** — Once over threshold, the follow-up `infer` after a tool batch is swapped for a `compact` cycle, and inference resumes via a host continuation message. After a compact that remains over the high watermark, the governor uses **growth hysteresis** (wait for usage to grow by ~10% of the window) instead of re-arming on every cycle; dropping under 60% is not required.
 - **Idle (end-of-turn)** — An interactive turn can end with a reply and then sit idle with no tool batch to intercept; the governor requests a continuation at that pause and compacts when it arrives. An operator message that races the continuation still compacts first, then re-enters inference to answer it.
-- **Idle recompress past the provider TTL** — The fold is a re-compress, not a cache play: provider KV caches expire on their own schedule, so a session compresses _after_ that expiry (the next turn is a cheaper write and later reads compound on the shrunk context) instead of only at 60% tokens. It is not limited to under-threshold sessions: once growth hysteresis has cleared `pending`, an over-threshold session in that gap can fire the same fold. Any live re-entry past the window fires it — an empty stall ping re-enters meter-only, a raced operator message re-infers — under reason `cache-ttl-recompress` through the same compactor, so the fresh tail stays raw exactly as in the threshold path. The interval follows provider cache economics (`src/provider/cache-ttl.ts`), not a global N minutes:
-
-| Provider segment                                               | Idle recompress allowed after | Why                                                                                                              |
-| -------------------------------------------------------------- | ----------------------------- | ---------------------------------------------------------------------------------------------------------------- |
-| `anthropic`, `zen-messages`, `opencode-go-messages`            | 5 min                         | Published default ephemeral cache TTL; the 1-hour TTL is never set                                               |
-| anything else, including OpenAI, xAI, Gemini, DeepSeek, ollama | never                         | No published 5-minute expiry, or no remote cache. Guessing a shorter window folds a cache that may still be warm |
+- **Idle recompress past the provider TTL** — Cache expiry does not compact. Stored turns stay. When settings set `anthropicCachePrompt`, and the saved Anthropic-protocol cache write is at least 5 minutes old, the pre-inference context transform stubs old tool-result bodies on the outgoing prompt only. `turns.jsonl` is not rewritten. The setting defaults off.
 
 The `ollama` table key is the bare provider segment; the harness stamps slash-form on `sourceId` (`ollama/default` / `ollama/<instance>`), with `provider: openai-compatible` (`buildOpenAISource`) and a bare model (`llama3` / `qwen3`). Idle-recompress disable matches via `isOllamaProviderId` on that `sourceId` (`src/provider/ollama.ts`), not by looking up slash-form as a table key.
 
 - **Operator `/compact`** — A first-class slash command folds now without waiting for the occupancy governor. Optional trailing instructions go to the summarizer (empty uses the default structured fold) and are stored on the compact record so later auto-folds still see them. Director rebuild (`/model`, interrupt, resume) restores those instructions from the latest compact record's parameters. An in-flight turn uses the same pair-safe compact-then-continue hop as threshold compact; an idle compact shows the fold and does not start a new turn.
 - **Overflow recovery** — A `context_overflow` inference error would otherwise become a terminal error reply; the governor compacts and retries instead, bounded so a history the compactor cannot shrink does not loop forever. Overflow ignores hysteresis for the compact itself.
 
-The TTL window is measured from the last `inference.done` (every inference rewrites the provider's prefix cache) with one fire per window per compact of any kind, and it never fires with a tool batch outstanding — stall pings can arrive mid-work. The consecutive-compact cap shared with the threshold path still bounds compact→infer→compact. Prompt-caching the summary call itself is an explicit non-goal: the fold carries no cache options. That write time is stored on the session run record for Anthropic-protocol identities only. A new process restores it and, once the stamp is at least 5 minutes old and the stored turn count is above the compact floor, issues the same `cache-ttl-recompress` fold before the first infer so the request reads the trimmed turns.
-
 The compaction control flow is shaped by a reactor invariant: a `compact` action runs in its own cycle (it cannot be paired with `infer`), and **the reactor delivers no event after a compact cycle**. A director that simply emitted `compact` in place of the follow-up `infer` would leave the loop idle forever — the cause of an earlier stall. Instead the governor pairs `compact` with an emit action (`custom.compaction.continue`), and the host answers that emission by delivering a content-less inbound message (`buildCompactionContinuationMessage()`) through the serial operation queue, generation-guarded like every other deliver. A hop superseded because interrupt already bumped generation and enqueued a rebuild is re-queued onto the replacement agent rather than consumed on the outgoing liveAgent. That message adds no turn (`createInboundTurn` returns `null` for empty content) but re-enters the loop, where the director issues the follow-up `infer` against the freshly truncated history. Each emission is answered at most once (a replayed duplicate of an already-answered emission is ignored), and an unsolicited continuation with neither resume flag set answers `wait` rather than burning a billable inference. The legacy `requestContinuation` closure survives only on the sub-agent path, which delivers directly with no host emit hop; idle arming keeps the two channels exclusive (closure fires and the arming flag stays false, or no closure and the flag reports the arming) so a caller honoring both cannot double-deliver.
 
 Compaction replaces older turns with a structured, workflow-aware summary rather than a stats blob: sections for **What Happened / What We're Doing / Relevant Links / Action Items / Next Steps**, with the active workflow and step woven in so compacting mid-`/build` or mid-`/plan` preserves the contract. The summary is produced by a one-shot model call; on any failure it falls back to a deterministic summary so a compaction cycle never breaks the session.

src/agent/compaction.test.ts

@@ -984,14 +984,6 @@ describe("provider-aware idle recompress (CL-8745)", () => {
     } as ReactorInboundEvent;
   }
 
-  const ttlCompact = [
-    {
-      type: "compact",
-      compactor: "pruning-compactor",
-      reason: "cache-ttl-recompress",
-    },
-  ] as ReactorAction[];
-
   test("fires past the provider TTL while under threshold, meter-only on empty", () => {
     let continuations = 0;
     let nowMs = 10_000_000;

src/agent/compaction.ts

@@ -135,7 +135,7 @@ export function createCompactionGovernor(
   requestContinuation?: () => void,
   systemPrompt = "",
   toolDefinitions: readonly ToolDefinition[] = [],
-  now: () => number = Date.now,
+  _now: () => number = Date.now,
 ) {
   let pending = false;
   let idlePending = false;
@@ -163,16 +163,6 @@ export function createCompactionGovernor(
   let usingEstimate = false;
   let lastModel: string | 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
-  // provider/cache-ttl.ts is measured from here. Stamped on every
-  // inference.done — estimated-usage providers wrote a cache entry too.
-  let lastCacheWriteAt: number | undefined;
-  // Wall-clock of the last issued compact of any kind. A fresh fold rewrites
-  // the session prefix, so the TTL recompress must not fire again inside the
-  // same window even when its own cache write has not been observed yet (the
-  // summary call bypasses this governor).
-  let lastCompactAt: number | undefined;
   // Tool calls issued by the last inference.done and not yet settled. A TTL
   // recompress must never fold while a batch is outstanding — the stall ping
   // that triggers it can arrive mid-work, and folding under it would rewrite
@@ -218,7 +208,6 @@ export function createCompactionGovernor(
 
   function noteCompactIssued(): void {
     awaitingPostCompactMeasurement = true;
-    lastCompactAt = now();
   }
 
   function atThresholdCompactCap(): boolean {
@@ -278,7 +267,6 @@ export function createCompactionGovernor(
     }
     syncFromTurns(turns);
     lastModel = event.source?.model;
-    lastCacheWriteAt = now();
     // The terminal reply ends the previous tool batch (its results are
     // already in the turns) and opens the batch the reply just issued. A TTL
     // recompress must never fold while a batch is outstanding — the stall
@@ -543,17 +531,16 @@ export function createCompactionGovernor(
     extraInstructions = trimmed;
   }
 
-  // A new process has no in-memory cache write. Seed the stored stamp, the
-  // identity that wrote it, and the stored turns so the next message.received
-  // can fold before its infer. Turn count is the stored set: the inbound
-  // message is appended after this, and the floor is measured without it.
+  // A new process has no in-memory turn count. Seed the stored turns so
+  // threshold and manual compact see the resumed history. The cache-write
+  // time lives on the run record for the prompt transform, not here.
   function restoreCacheWrite(args: {
     at: number;
     source: LastCycleSource;
     turns: readonly ConversationTurn[];
   }): void {
+    void args.at;
     syncFromTurns(args.turns);
-    lastCacheWriteAt = args.at;
     lastModel = args.source.model;
   }
 

tests/unit/config.test.ts

@@ -324,6 +324,7 @@ test("loadSettings cannot silently drop a known optional key", async () => {
       recentModels: [{ provider: "p", model: "m" }],
       favoriteModels: [{ provider: "p", model: "m" }],
       dangerouslySkipPermissions: true,
+      anthropicCachePrompt: true,
     };
     await writeFile(globalPath, JSON.stringify(fixture));
     const loaded = await loadSettings(globalPath);