fix(compaction): limit idle recompress to the Anthropic cache

Guessed windows for other providers fold a cache that is still warm. Only Anthropic publishes a 5-minute expiry this client actually uses.

Author: TheGreatAxios

docs/ARCHITECTURE.md

@@ -193,14 +193,10 @@ When a cycle's input tokens cross a threshold, the director compacts the inferen
 - **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                         | Default ephemeral cache TTL; hour-long breakpoints are never set                     |
-| `openai-responses`, `codex-responses`, `openai-compatible`, `xai` | 10 min                        | In-memory prefixes typically evicted after 5–10 min idle; xAI assumed same economics |
-| `gemini`                                                          | 15 min                        | No published implicit-cache eviction window; conservative                            |
-| `deepseek`                                                        | 60 min                        | On-disk context cache persists for hours-to-days                                     |
-| `ollama`                                                          | never                         | Local inference has no remote cache to expire                                        |
-| anything else                                                     | 10 min                        | Assumed OpenAI-style in-memory economics; tune per upstream                          |
+| 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 |
 
 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.
 

src/agent/compaction.test.ts

@@ -67,6 +67,7 @@ function turnsOfLength(count: number, textLength: number): ConversationTurn[] {
 function inferenceDone(
   input: number,
   text = "",
+  provider = "p",
 ): Extract<ReactorInboundEvent, { type: "inference.done" }> {
   return {
     type: "inference.done",
@@ -75,7 +76,7 @@ function inferenceDone(
       content: text.length > 0 ? [{ type: "text", text }] : [],
     },
     usage: usage(input),
-    source: { sourceId: "s", provider: "p", model: "m" },
+    source: { sourceId: "s", provider, model: "m" },
   } as unknown as Extract<ReactorInboundEvent, { type: "inference.done" }>;
 }
 
@@ -946,7 +947,11 @@ describe("provider-aware idle recompress (CL-8745)", () => {
   ): Extract<ReactorInboundEvent, { type: "inference.done" }> {
     const source =
       typeof modelOrSource === "string"
-        ? { sourceId: "s", provider: "p", model: modelOrSource }
+        ? {
+            sourceId: "s",
+            provider: modelOrSource.split("/")[0] ?? "p",
+            model: modelOrSource,
+          }
         : {
             sourceId: modelOrSource.sourceId ?? "s",
             provider: modelOrSource.provider ?? "p",
@@ -1021,11 +1026,12 @@ describe("provider-aware idle recompress (CL-8745)", () => {
     expect(governor.resumeAfterCompact(emptyMessage())).toBe("meter");
   });
 
-  test("production LastCycleSource: anthropic fires at 5m, codex stays quiet until 10m", () => {
+  test("production LastCycleSource: anthropic fires at 5m, codex never does", () => {
     // Harness stamps { sourceId, provider, model } with a bare model, not
     // slash-form "anthropic/claude-opus-4-6". Anthropic's 5-minute window
-    // must come from provider, not a dummy model string; Codex must not
-    // inherit that 5-minute fire from sourceId "codex/work".
+    // must come from provider, not a dummy model string. Codex has no
+    // published 5-minute expiry, so it must stay quiet past the old 10-minute
+    // guess as well.
     let nowMs = 15_000_000;
     const clock = () => nowMs;
     const anthropic = createCompactionGovernor(() => undefined, "", [], clock);
@@ -1057,13 +1063,13 @@ describe("provider-aware idle recompress (CL-8745)", () => {
       codex.interceptIdleContinuation(emptyMessage(), capabilities),
     ).toBeNull();
 
-    nowMs += 5 * MINUTE_MS;
+    nowMs += 30 * MINUTE_MS;
     expect(
       codex.interceptIdleContinuation(emptyMessage(), capabilities),
-    ).toEqual(ttlCompact);
+    ).toBeNull();
   });
 
-  test("follows provider economics: deepseek waits out its long window, ollama never fires", () => {
+  test("does not idle-recompress DeepSeek or ollama", () => {
     let nowMs = 20_000_000;
     const clock = () => nowMs;
     const deepseek = createCompactionGovernor(() => undefined, "", [], clock);
@@ -1077,30 +1083,20 @@ describe("provider-aware idle recompress (CL-8745)", () => {
       tenTurns,
     );
 
-    // Past Anthropic/OpenAI windows but inside DeepSeek's hour: neither fires.
-    nowMs += 30 * MINUTE_MS;
+    nowMs += 90 * MINUTE_MS;
     expect(
       deepseek.interceptIdleContinuation(emptyMessage(), capabilities),
     ).toBeNull();
     expect(
       local.interceptIdleContinuation(emptyMessage(), capabilities),
     ).toBeNull();
-
-    // Past DeepSeek's hour: recompress fires; local inference still never
-    // does — no remote cache means no cache benefit.
-    nowMs += 31 * MINUTE_MS;
-    expect(
-      deepseek.interceptIdleContinuation(emptyMessage(), capabilities),
-    ).toEqual(ttlCompact);
-    expect(
-      local.interceptIdleContinuation(emptyMessage(), capabilities),
-    ).toBeNull();
   });
 
   test("production ollama LastCycleSource never fires cache-ttl-recompress", () => {
     // Harness stamps { sourceId, provider, model } with a bare model. Ollama is
     // buildOpenAISource: sourceId "ollama/default", provider openai-compatible,
-    // model llama3. Keying TTL only off model would take the 10-minute default.
+    // Keying TTL off the bare model would miss the ollama sourceId. Local
+    // inference stays disabled.
     let nowMs = 25_000_000;
     const governor = createCompactionGovernor(
       () => undefined,
@@ -1120,7 +1116,7 @@ describe("provider-aware idle recompress (CL-8745)", () => {
       tenTurns,
     );
 
-    nowMs += 11 * MINUTE_MS;
+    nowMs += 5 * MINUTE_MS + 1;
     expect(
       governor.interceptIdleContinuation(emptyMessage(), capabilities),
     ).toBeNull();
@@ -1142,8 +1138,8 @@ describe("provider-aware idle recompress (CL-8745)", () => {
       () => nowMs,
     );
     governor.noteInferenceDone(inferenceDone(overThreshold), tenTurns);
-    // The "m" fixture model carries the 10-minute default TTL; advance past it.
-    nowMs += 11 * MINUTE_MS;
+    // Fixture provider "p" has no TTL. Threshold arming still owns this session.
+    nowMs += 5 * MINUTE_MS + 1;
     // Threshold arming owns the over-threshold session: no TTL double-fold.
     expect(
       governor.interceptIdleContinuation(emptyMessage(), capabilities),
@@ -1165,18 +1161,24 @@ describe("provider-aware idle recompress (CL-8745)", () => {
       [],
       () => nowMs,
     );
-    governor.noteInferenceDone(inferenceDone(overThreshold), tenTurns);
+    governor.noteInferenceDone(
+      inferenceDone(overThreshold, "", "anthropic"),
+      tenTurns,
+    );
     expect(
       governor.interceptActions(toolDone(), inferAction, capabilities),
     ).not.toBeNull();
     expect(governor.resumeAfterCompact(emptyMessage())).toBe("infer");
 
-    governor.noteInferenceDone(inferenceDone(overThreshold), tenTurns);
+    governor.noteInferenceDone(
+      inferenceDone(overThreshold, "", "anthropic"),
+      tenTurns,
+    );
     expect(
       governor.interceptActions(toolDone(), inferAction, capabilities),
     ).toBeNull();
 
-    nowMs += 11 * MINUTE_MS;
+    nowMs += 5 * MINUTE_MS + 1;
     expect(
       governor.interceptIdleContinuation(emptyMessage(), capabilities),
     ).toEqual(ttlCompact);
@@ -1193,14 +1195,20 @@ describe("provider-aware idle recompress (CL-8745)", () => {
       [],
       () => nowMs,
     );
-    governor.noteInferenceDone(inferenceDone(overThreshold), tenTurns);
+    governor.noteInferenceDone(
+      inferenceDone(overThreshold, "", "anthropic"),
+      tenTurns,
+    );
     expect(
       governor.interceptActions(toolDone(), inferAction, capabilities),
     ).not.toBeNull();
     expect(governor.resumeAfterCompact(emptyMessage())).toBe("infer");
 
-    governor.noteInferenceDone(inferenceDone(overThreshold), tenTurns);
-    nowMs += 11 * MINUTE_MS;
+    governor.noteInferenceDone(
+      inferenceDone(overThreshold, "", "anthropic"),
+      tenTurns,
+    );
+    nowMs += 5 * MINUTE_MS + 1;
     expect(
       governor.interceptIdleContinuation(emptyMessage(), capabilities),
     ).toEqual(ttlCompact);

src/provider/cache-ttl.test.ts

@@ -4,24 +4,21 @@ import { cacheTtlMsFor } from "./cache-ttl.js";
 const MINUTE_MS = 60_000;
 
 describe("cacheTtlMsFor", () => {
-  test("maps providers to their documented cache TTL windows", () => {
+  test("allows idle recompress only for the published Anthropic 5-minute window", () => {
     expect(cacheTtlMsFor("anthropic/claude-opus-4-6")).toBe(5 * MINUTE_MS);
-    expect(cacheTtlMsFor("openai-responses/gpt-5.6")).toBe(10 * MINUTE_MS);
-    expect(cacheTtlMsFor("codex-responses/gpt-5.6")).toBe(10 * MINUTE_MS);
-    expect(cacheTtlMsFor("openai-compatible/custom")).toBe(10 * MINUTE_MS);
-    expect(cacheTtlMsFor("xai/thegreataxios")).toBe(10 * MINUTE_MS);
-    expect(cacheTtlMsFor("gemini/gemini-3-pro")).toBe(15 * MINUTE_MS);
-    expect(cacheTtlMsFor("deepseek/deepseek-chat")).toBe(60 * MINUTE_MS);
-  });
-
-  test("covers Anthropic-protocol adapters with the 5-minute window", () => {
     expect(cacheTtlMsFor("zen-messages/claude-opus-4-6")).toBe(5 * MINUTE_MS);
     expect(cacheTtlMsFor("opencode-go-messages/claude-opus-4-6")).toBe(
       5 * MINUTE_MS,
     );
   });
 
-  test("disables idle recompress for local inference and missing model ids", () => {
+  test("disables providers whose expiry is unpublished or longer than 5 minutes", () => {
+    expect(cacheTtlMsFor("openai-responses/gpt-5.6")).toBeUndefined();
+    expect(cacheTtlMsFor("codex-responses/gpt-5.6")).toBeUndefined();
+    expect(cacheTtlMsFor("openai-compatible/custom")).toBeUndefined();
+    expect(cacheTtlMsFor("xai/thegreataxios")).toBeUndefined();
+    expect(cacheTtlMsFor("gemini/gemini-3-pro")).toBeUndefined();
+    expect(cacheTtlMsFor("deepseek/deepseek-chat")).toBeUndefined();
     expect(cacheTtlMsFor("ollama/llama3.1")).toBeUndefined();
     expect(cacheTtlMsFor(undefined)).toBeUndefined();
     expect(cacheTtlMsFor("")).toBeUndefined();
@@ -37,7 +34,7 @@ describe("cacheTtlMsFor", () => {
     ).toBeUndefined();
   });
 
-  test("maps bare LastCycleSource ids through provider and family", () => {
+  test("maps a bare Anthropic LastCycleSource and leaves Codex quiet", () => {
     expect(
       cacheTtlMsFor({
         provider: "anthropic",
@@ -49,25 +46,17 @@ describe("cacheTtlMsFor", () => {
         provider: "codex-responses",
         model: "gpt-5.6-luna",
       }),
-    ).toBe(10 * MINUTE_MS);
-  });
-
-  test("falls back to model family for unrecognized provider prefixes", () => {
-    expect(cacheTtlMsFor("proxy-acme/grok-4")).toBe(10 * MINUTE_MS);
-    expect(cacheTtlMsFor("proxy-acme/gemini-3-pro")).toBe(15 * MINUTE_MS);
-    expect(cacheTtlMsFor("proxy-acme/ollama-qwen")).toBeUndefined();
-    // An exact provider-segment match wins over the model family: an
-    // openai-compatible account fronting Claude keeps the generic window.
-    expect(cacheTtlMsFor("openai-compatible/claude-opus-4-6")).toBe(
-      10 * MINUTE_MS,
-    );
+    ).toBeUndefined();
   });
 
-  test("assumes OpenAI-style economics for unrecognized providers", () => {
-    expect(cacheTtlMsFor("bifrost/some-model")).toBe(10 * MINUTE_MS);
-    expect(cacheTtlMsFor("totally-new-provider/model-x")).toBe(10 * MINUTE_MS);
-    // A truly unknown id (no provider segment, no family substring) still
-    // gets the 10-minute default — not the local-inference disable.
-    expect(cacheTtlMsFor("unknown-id")).toBe(10 * MINUTE_MS);
+  test("does not inherit a window from the model family or an unknown provider", () => {
+    expect(cacheTtlMsFor("proxy-acme/grok-4")).toBeUndefined();
+    expect(cacheTtlMsFor("proxy-acme/gemini-3-pro")).toBeUndefined();
+    expect(cacheTtlMsFor("proxy-acme/claude-opus-4-6")).toBeUndefined();
+    // The provider segment wins: an openai-compatible account fronting
+    // Claude is not the Anthropic messages protocol.
+    expect(cacheTtlMsFor("openai-compatible/claude-opus-4-6")).toBeUndefined();
+    expect(cacheTtlMsFor("bifrost/some-model")).toBeUndefined();
+    expect(cacheTtlMsFor("unknown-id")).toBeUndefined();
   });
 });