fix(provider): resume anthropic cache stamps from the protocol

Runners persist the catalog id, which is not the messages adapter
name. Requiring that id to match the protocol dropped an expired
stamp, so the next request sent the untrimmed history.

Author: TheGreatAxios

src/exec/runner.ts

@@ -891,6 +891,7 @@ export async function runExec(config: Config): Promise<ExecResult> {
           at: activeRunHandle.lastCacheWriteAt,
           storedModel: activeRunHandle.cacheWriteModel,
           liveProvider: config.providerName,
+          liveProtocol: liveSource.provider,
         }),
       onBuilt: (agent, storage) => {
         currentAgent = agent;

src/provider/cache-ttl.test.ts

@@ -1,4 +1,9 @@
 import { describe, expect, test } from "bun:test";
+import {
+  buildAnthropicSource,
+  buildGoSource,
+  buildZenSource,
+} from "../config/index.js";
 import {
   anthropicCacheWriteAt,
   cacheTtlMsFor,
@@ -79,28 +84,88 @@ describe("anthropic cache-write stamp", () => {
         at: 10,
         storedModel: "anthropic:claude-opus-4-6",
         liveProvider: "anthropic",
+        liveProtocol: "anthropic",
       }),
     ).toEqual({ at: 10, model: "anthropic:claude-opus-4-6" });
     expect(
       resumeCacheWriteSeed({
         at: 10,
         storedModel: "openai:gpt-5.6",
         liveProvider: "openai",
+        liveProtocol: "openai",
       }),
     ).toBeUndefined();
     expect(
       resumeCacheWriteSeed({
         at: 10,
         storedModel: "anthropic:claude-opus-4-6",
         liveProvider: "openai",
+        liveProtocol: "openai",
       }),
     ).toBeUndefined();
     expect(
       resumeCacheWriteSeed({
         at: undefined,
         storedModel: "anthropic:claude-opus-4-6",
         liveProvider: "anthropic",
+        liveProtocol: "anthropic",
       }),
     ).toBeUndefined();
   });
+
+  test("catalog ids that speak the Anthropic protocol still return the stamp", () => {
+    const at = 10;
+    const sources = [
+      buildZenSource({
+        id: "zen",
+        model: "claude-opus-4-6",
+        sessionId: "sess-zen",
+      }),
+      buildGoSource({
+        id: "opencode-go",
+        model: "minimax-m3",
+        sessionId: "sess-go",
+      }),
+      buildAnthropicSource({
+        id: "acme",
+        baseURL: "https://example.invalid",
+        model: "claude-opus-4-6",
+      }),
+    ];
+    for (const source of sources) {
+      expect(source.id).not.toBe(source.provider);
+      const storedModel = `${source.id}:${source.model}`;
+      expect(
+        resumeCacheWriteSeed({
+          at,
+          storedModel,
+          liveProvider: source.id,
+          liveProtocol: source.provider,
+        }),
+      ).toEqual({ at, model: `${source.provider}:${source.model}` });
+    }
+
+    const gemini = buildZenSource({
+      id: "zen",
+      model: "gemini-3-flash",
+      sessionId: "sess-zen",
+    });
+    expect(
+      resumeCacheWriteSeed({
+        at,
+        storedModel: `${gemini.id}:${gemini.model}`,
+        liveProvider: gemini.id,
+        liveProtocol: gemini.provider,
+      }),
+    ).toBeUndefined();
+
+    expect(
+      resumeCacheWriteSeed({
+        at,
+        storedModel: "zen-messages:claude-opus-4-6",
+        liveProvider: "zen",
+        liveProtocol: "zen-messages",
+      }),
+    ).toEqual({ at, model: "zen-messages:claude-opus-4-6" });
+  });
 });

src/provider/cache-ttl.ts

@@ -98,19 +98,48 @@ export function anthropicCacheWriteAt(
 }
 
 /**
- * Seed for a resumed session's pre-infer fold. Absent unless both the
- * identity that wrote the cache and the provider about to be called are
- * Anthropic-protocol. A stamp alone is not enough: a non-Anthropic model
- * on the run record must not fold.
+ * Seed for a resumed session's pre-infer fold. Absent unless the provider
+ * about to be called speaks the Anthropic messages protocol. A stamp alone
+ * is not enough: a non-Anthropic live adapter must not fold.
+ *
+ * `liveProvider` is the catalog id (`source.id`). Runners persist
+ * `${id}:${model}`, and that id is `zen`, `opencode-go`, or a custom account
+ * name — not `zen-messages`, `opencode-go-messages`, or `anthropic`.
+ * `liveProtocol` is `source.provider`, the adapter that actually wrote the
+ * cache. A catalog-form stamp is accepted only for this same catalog id, and
+ * the returned model uses the protocol name so the governor's TTL check
+ * follows the adapter. A protocol-form stamp (the in-memory `provider:model`
+ * recorded at inference.done) is kept as-is.
  */
 export function resumeCacheWriteSeed(args: {
   at: number | undefined;
   storedModel: string | undefined;
   liveProvider: string;
+  liveProtocol: string;
 }): { at: number; model: string } | undefined {
   if (args.at === undefined) return undefined;
-  if (args.storedModel === undefined) return undefined;
-  if (cacheTtlMsFor(args.storedModel) === undefined) return undefined;
-  if (cacheTtlMsFor(args.liveProvider) === undefined) return undefined;
-  return { at: args.at, model: args.storedModel };
+  if (args.storedModel === undefined || args.storedModel.length === 0) {
+    return undefined;
+  }
+  if (cacheTtlMsFor(args.liveProtocol) === undefined) return undefined;
+  if (cacheTtlMsFor(args.storedModel) !== undefined) {
+    return { at: args.at, model: args.storedModel };
+  }
+
+  const stored = splitRunModel(args.storedModel);
+  if (stored.provider !== args.liveProvider) return undefined;
+  if (stored.model.length === 0) return undefined;
+  return { at: args.at, model: `${args.liveProtocol}:${stored.model}` };
+}
+
+function splitRunModel(value: string): { provider: string; model: string } {
+  const colon = value.indexOf(":");
+  if (colon > 0) {
+    return { provider: value.slice(0, colon), model: value.slice(colon + 1) };
+  }
+  const slash = value.indexOf("/");
+  if (slash > 0) {
+    return { provider: value.slice(0, slash), model: value.slice(slash + 1) };
+  }
+  return { provider: value, model: "" };
 }

src/session/cache-ttl-resume.test.ts

@@ -8,13 +8,21 @@ import { createDefaultDependencies } from "@intx/inference/providers";
 import type {
   ConversationTurn,
   InferenceEvent,
+  InferenceSource,
   ReactorAction,
 } from "@intx/types/runtime";
 import { createChatDirector } from "../agent/director.js";
 import {
   COMPACTION_CONTINUATION_EVENT,
   lastCycleSourceFromRunModel,
 } from "../agent/compaction.js";
+import {
+  buildAnthropicSource,
+  buildGoSource,
+  buildOpenAISource,
+  buildZenSource,
+} from "../config/index.js";
+import { resumeCacheWriteSeed } from "../provider/cache-ttl.js";
 import { HANDOFF_LATEST_KEY } from "./compaction-handoff.js";
 import { COMPACTED_PREFIX, createPruningCompactor } from "./compactor.js";
 import { createOptimizedContextStore } from "./optimized-context-store.js";
@@ -62,7 +70,10 @@ function actionsOf(result: ReactorAction | ReactorAction[]): ReactorAction[] {
   return Array.isArray(result) ? result : [result];
 }
 
-async function resumeAndInfer(args: { at: number; model: string }): Promise<{
+async function resumeAndInfer(args: {
+  at: number;
+  source: InferenceSource;
+}): Promise<{
   first: ReactorAction[];
   stored: ConversationTurn[];
   prompt: ConversationTurn[];
@@ -80,10 +91,21 @@ async function resumeAndInfer(args: { at: number; model: string }): Promise<{
     });
     await store.commit({ message: "seed" });
 
-    const source = lastCycleSourceFromRunModel(args.model);
-    if (source === undefined) throw new Error("missing source");
+    const storedModel = `${args.source.id}:${args.source.model}`;
+    const cacheSeed = resumeCacheWriteSeed({
+      at: args.at,
+      storedModel,
+      liveProvider: args.source.id,
+      liveProtocol: args.source.provider,
+    });
+    const source =
+      cacheSeed === undefined
+        ? undefined
+        : lastCycleSourceFromRunModel(cacheSeed.model);
     const director = createChatDirector("test", [], {});
-    director.restoreCacheWrite({ at: args.at, source, turns: seed });
+    if (cacheSeed !== undefined && source !== undefined) {
+      director.restoreCacheWrite({ at: cacheSeed.at, source, turns: seed });
+    }
     const original = director.decide.bind(director);
     let first: ReactorAction[] | undefined;
     director.decide = async (event, state, capabilities) => {
@@ -104,13 +126,7 @@ async function resumeAndInfer(args: { at: number; model: string }): Promise<{
     const reactor = createReactor({
       sessionId: "cache-ttl-resume",
       director,
-      source: {
-        id: "anthropic:claude-opus-4-6",
-        provider: "anthropic",
-        model: "claude-opus-4-6",
-        baseURL: "https://example.invalid",
-        credentialId: "test",
-      },
+      source: args.source,
       toolRunner: {
         async run(call) {
           return { callId: call.id, content: "ok" };
@@ -150,9 +166,9 @@ async function resumeAndInfer(args: { at: number; model: string }): Promise<{
               },
               usage: USAGE,
               source: {
-                sourceId: source.sourceId,
-                provider: source.provider,
-                model: source.model,
+                sourceId: args.source.id,
+                provider: args.source.provider,
+                model: args.source.model,
               },
             },
           };
@@ -216,10 +232,16 @@ async function resumeAndInfer(args: { at: number; model: string }): Promise<{
 }
 
 describe("resumed Anthropic cache write compacts before infer", () => {
+  const native = buildAnthropicSource({
+    id: "anthropic",
+    baseURL: "https://example.invalid",
+    model: "claude-opus-4-6",
+  });
+
   test("an expired Anthropic stamp folds into the context store first", async () => {
     const result = await resumeAndInfer({
       at: Date.now() - 6 * MINUTE_MS,
-      model: "anthropic:claude-opus-4-6",
+      source: native,
     });
 
     expect(result.first[0]).toMatchObject({
@@ -242,7 +264,7 @@ describe("resumed Anthropic cache write compacts before infer", () => {
   test("a write inside 5 minutes leaves the stored turns in place", async () => {
     const result = await resumeAndInfer({
       at: Date.now() - 2 * MINUTE_MS,
-      model: "anthropic:claude-opus-4-6",
+      source: native,
     });
 
     expect(result.first.some((action) => action.type === "compact")).toBe(
@@ -255,7 +277,11 @@ describe("resumed Anthropic cache write compacts before infer", () => {
   test("a non-Anthropic stored stamp does not compact", async () => {
     const result = await resumeAndInfer({
       at: Date.now() - 6 * MINUTE_MS,
-      model: "openai:gpt-5.6",
+      source: buildOpenAISource({
+        id: "openai",
+        baseURL: "https://example.invalid/v1",
+        model: "gpt-5.6",
+      }),
     });
 
     expect(result.first.some((action) => action.type === "compact")).toBe(
@@ -264,4 +290,37 @@ describe("resumed Anthropic cache write compacts before infer", () => {
     expect(texts(result.stored)).toEqual(texts(result.seed));
     expect(result.handoff).toBeUndefined();
   });
+
+  test("expired Zen, OpenCode Go, and custom Anthropic catalog ids fold before infer", async () => {
+    const sources = [
+      buildZenSource({
+        id: "zen",
+        model: "claude-opus-4-6",
+        sessionId: "sess-zen",
+      }),
+      buildGoSource({
+        id: "opencode-go",
+        model: "minimax-m3",
+        sessionId: "sess-go",
+      }),
+      buildAnthropicSource({
+        id: "acme",
+        baseURL: "https://example.invalid",
+        model: "claude-opus-4-6",
+      }),
+    ];
+    for (const source of sources) {
+      expect(source.id).not.toBe(source.provider);
+      const result = await resumeAndInfer({
+        at: Date.now() - 6 * MINUTE_MS,
+        source,
+      });
+      expect(result.first[0]).toMatchObject({
+        type: "compact",
+        compactor: "pruning-compactor",
+        reason: "cache-ttl-recompress",
+      });
+      expect(result.stored.length).toBeLessThan(result.seed.length);
+    }
+  });
 });

src/tui/runner/session.ts

@@ -738,6 +738,7 @@ export async function assembleTUISession(
         at: start.activeRunHandle.lastCacheWriteAt,
         storedModel: start.activeRunHandle.cacheWriteModel,
         liveProvider: state.config.providerName,
+        liveProtocol: state.liveSource.provider,
       }),
     onBuilt: (agent, storage) => {
       state.currentAgent = agent;