fix(compaction): key cache ttl off last-cycle source identity

Production LastCycleSource stamps a bare model and openai-compatible
provider. Keying TTL only off model treated local Ollama as a 10-minute
cache window.

Author: TheGreatAxios

docs/ARCHITECTURE.md

@@ -191,8 +191,7 @@ 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.
-- **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.
+- **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                                                                                  |
 | ----------------------------------------------------------------- | ----------------------------- | ------------------------------------------------------------------------------------ |
@@ -203,6 +202,8 @@ When a cycle's input tokens cross a threshold, the director compacts the inferen
 | `ollama`                                                          | never                         | Local inference has no remote cache to expire                                        |
 | anything else                                                     | 10 min                        | Assumed OpenAI-style in-memory economics; tune per upstream                          |
 
+- **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.
 
 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.

src/agent/compaction.test.ts

@@ -791,9 +791,15 @@ describe("provider-aware idle recompress (CL-8745)", () => {
   const MINUTE_MS = 60_000;
 
   function ttlInferenceDone(
-    model: string,
+    modelOrSource:
+      | string
+      | { sourceId: string; provider: string; model: string },
     withTools: boolean,
   ): Extract<ReactorInboundEvent, { type: "inference.done" }> {
+    const source =
+      typeof modelOrSource === "string"
+        ? { sourceId: "s", provider: "p", model: modelOrSource }
+        : modelOrSource;
     return {
       type: "inference.done",
       turn: {
@@ -810,7 +816,7 @@ describe("provider-aware idle recompress (CL-8745)", () => {
           : [{ type: "text", text: "ok" }],
       },
       usage: usage(1000),
-      source: { sourceId: "s", provider: "p", model },
+      source,
     } as unknown as Extract<ReactorInboundEvent, { type: "inference.done" }>;
   }
 
@@ -894,6 +900,35 @@ describe("provider-aware idle recompress (CL-8745)", () => {
     ).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.
+    let nowMs = 25_000_000;
+    const governor = createCompactionGovernor(
+      () => undefined,
+      "",
+      [],
+      () => nowMs,
+    );
+    governor.noteInferenceDone(
+      ttlInferenceDone(
+        {
+          sourceId: "ollama/default",
+          provider: "openai-compatible",
+          model: "llama3",
+        },
+        false,
+      ),
+      tenTurns,
+    );
+
+    nowMs += 11 * MINUTE_MS;
+    expect(
+      governor.interceptIdleContinuation(emptyMessage(), capabilities),
+    ).toBeNull();
+  });
+
   test("stays inert with no observed cache write", () => {
     const governor = createCompactionGovernor(() => undefined);
     expect(

src/agent/compaction.ts

@@ -1,5 +1,6 @@
 import type {
   ConversationTurn,
+  LastCycleSource,
   ReactorAction,
   ReactorCapabilities,
   ReactorInboundEvent,
@@ -81,9 +82,13 @@ export function createCompactionGovernor(
   // can flag the number as approximate instead of implying provider-grade
   // precision.
   let usingEstimate = false;
-  // Model of the last inference.done turn, kept for live re-checks between
-  // inference cycles (see interceptActions) where the event carries no model.
+  // 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
@@ -189,6 +194,7 @@ 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
@@ -308,7 +314,7 @@ export function createCompactionGovernor(
     if (turnCount <= MIN_TURNS_TO_COMPACT) return false;
     if (atThresholdCompactCap()) return false;
     if (outstandingToolCalls > 0) return false;
-    const ttl = cacheTtlMsFor(lastModel);
+    const ttl = cacheTtlMsFor(lastCycleSource);
     if (ttl === undefined) return false;
     if (lastCacheWriteAt === undefined) return false;
     if (nowMs - lastCacheWriteAt < ttl) return false;

src/provider/cache-ttl.test.ts

@@ -27,6 +27,31 @@ describe("cacheTtlMsFor", () => {
     expect(cacheTtlMsFor("")).toBeUndefined();
   });
 
+  test("keys ollama off production LastCycleSource, not a slash-form model", () => {
+    expect(
+      cacheTtlMsFor({
+        sourceId: "ollama/default",
+        provider: "openai-compatible",
+        model: "llama3",
+      }),
+    ).toBeUndefined();
+  });
+
+  test("maps bare LastCycleSource ids through provider and family", () => {
+    expect(
+      cacheTtlMsFor({
+        provider: "anthropic",
+        model: "claude-opus-4-6",
+      }),
+    ).toBe(5 * MINUTE_MS);
+    expect(
+      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);

src/provider/cache-ttl.ts

@@ -23,13 +23,20 @@
 //   60 min.
 // - ollama: local inference has no remote cache to expire, so an idle
 //   recompress would burn local compute for no cache benefit. Disabled.
+//   Production LastCycleSource is `{ sourceId, provider, model }` with a
+//   bare model; Ollama is `buildOpenAISource` (`provider: openai-compatible`,
+//   `sourceId` like `ollama/default`, model `llama3` / `qwen3`). Identity is
+//   `sourceId` via `isOllamaProviderId`, not a slash-form string the harness
+//   never stamps.
 // - Unknown/custom providers (bifrost proxy, `openai-compatible` fronting an
 //   unlisted upstream, unrecognized strings): assumed OpenAI-style in-memory
 //   economics. 10 min.
 //
 // Deliberate non-goal: the summary call itself carries no `cache_control` —
 // prompt-caching the fold is not attempted.
 
+import { isOllamaProviderId } from "./ollama.js";
+
 const MINUTE_MS = 60_000;
 
 const PROVIDER_TTLS_MS: Record<string, number | undefined> = {
@@ -65,6 +72,12 @@ const FAMILY_TTLS_MS: readonly (readonly [string, number | undefined])[] = [
   ["ollama", undefined],
 ];
 
+type CacheTtlIdentity = {
+  sourceId?: string;
+  provider?: string;
+  model?: string;
+};
+
 // Canonical provider segment of a `provider:model` string: the account or
 // adapter name before the first "/" (custom names like `xai/thegreataxios`
 // carry the provider there), else the head before ":". Mirrors the
@@ -78,13 +91,7 @@ function canonicalSegment(model: string): string {
   return colon >= 0 ? head.slice(0, colon) : head;
 }
 
-/**
- * Milliseconds of provider-cache idle after which a recompress is allowed,
- * or `undefined` when the model is undefined/empty or the provider has no
- * remote cache (local inference). Never throws; unknown strings get the
- * default 10-minute window.
- */
-export function cacheTtlMsFor(model: string | undefined): number | undefined {
+function ttlForModelString(model: string | undefined): number | undefined {
   if (model === undefined) return undefined;
   const segment = canonicalSegment(model);
   if (segment.length === 0) return undefined;
@@ -96,3 +103,34 @@ export function cacheTtlMsFor(model: string | undefined): number | undefined {
   }
   return DEFAULT_TTL_MS;
 }
+
+/**
+ * Milliseconds of provider-cache idle after which a recompress is allowed,
+ * or `undefined` when the identity is missing/empty or the provider has no
+ * remote cache (local inference). Never throws; unknown strings get the
+ * default 10-minute window.
+ *
+ * Accepts a slash-form `provider/model` string or a LastCycleSource-shaped
+ * identity. Production events stamp a bare `model`; Ollama is recognized
+ * from `sourceId` (`isOllamaProviderId`), not from a combined string the
+ * harness never stamps.
+ */
+export function cacheTtlMsFor(
+  identity: string | CacheTtlIdentity | undefined,
+): number | undefined {
+  if (identity === undefined) return undefined;
+  if (typeof identity === "string") return ttlForModelString(identity);
+
+  if (identity.sourceId !== undefined && isOllamaProviderId(identity.sourceId))
+    return undefined;
+  if (identity.provider !== undefined && isOllamaProviderId(identity.provider))
+    return undefined;
+
+  if (identity.provider !== undefined) {
+    const provider = identity.provider.toLowerCase();
+    if (Object.hasOwn(PROVIDER_TTLS_MS, provider))
+      return PROVIDER_TTLS_MS[provider];
+  }
+
+  return ttlForModelString(identity.model);
+}