test(compaction): cover production last-cycle source ttl windows

Author: TheGreatAxios

docs/ARCHITECTURE.md

@@ -202,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                          |
 
+Production identity for the `ollama` row is `sourceId` `ollama` / `ollama/<instance>` via `isOllamaProviderId` (`src/provider/ollama.ts`), not a bare model id: Ollama is `buildOpenAISource` (`provider: openai-compatible`, model `llama3` / `qwen3`). Slash-form `ollama/…` is a table key, not what the harness stamps.
+
 - **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.

src/agent/compaction.test.ts

@@ -793,13 +793,17 @@ describe("provider-aware idle recompress (CL-8745)", () => {
   function ttlInferenceDone(
     modelOrSource:
       | string
-      | { sourceId: string; provider: string; model: 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;
+        : {
+            sourceId: modelOrSource.sourceId ?? "s",
+            provider: modelOrSource.provider ?? "p",
+            model: modelOrSource.model ?? "m",
+          };
     return {
       type: "inference.done",
       turn: {
@@ -845,7 +849,10 @@ describe("provider-aware idle recompress (CL-8745)", () => {
       () => nowMs,
     );
     governor.noteInferenceDone(
-      ttlInferenceDone("anthropic/claude-opus-4-6", false),
+      ttlInferenceDone(
+        { provider: "anthropic", model: "claude-opus-4-6" },
+        false,
+      ),
       tenTurns,
     );
 
@@ -866,6 +873,44 @@ 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", () => {
+    // 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".
+    let nowMs = 15_000_000;
+    const clock = () => nowMs;
+    const anthropic = createCompactionGovernor(() => undefined, "", [], clock);
+    const codex = createCompactionGovernor(() => undefined, "", [], clock);
+    anthropic.noteInferenceDone(
+      ttlInferenceDone(
+        { provider: "anthropic", model: "claude-opus-4-6" },
+        false,
+      ),
+      tenTurns,
+    );
+    codex.noteInferenceDone(
+      ttlInferenceDone(
+        { sourceId: "codex/work", provider: "codex-responses" },
+        false,
+      ),
+      tenTurns,
+    );
+
+    nowMs += 5 * MINUTE_MS + 1;
+    expect(
+      anthropic.interceptIdleContinuation(emptyMessage(), capabilities),
+    ).toEqual(ttlCompact);
+    expect(
+      codex.interceptIdleContinuation(emptyMessage(), capabilities),
+    ).toBeNull();
+
+    nowMs += 5 * MINUTE_MS;
+    expect(
+      codex.interceptIdleContinuation(emptyMessage(), capabilities),
+    ).toEqual(ttlCompact);
+  });
+
   test("follows provider economics: deepseek waits out its long window, ollama never fires", () => {
     let nowMs = 20_000_000;
     const clock = () => nowMs;