opencode-cache-engine 0.3.6 → 0.4.1

package/test/cache-engine.test.mjs

@@ -48,6 +48,15 @@ import {
   toolFingerprint,
   toolWireFingerprint,
 } from "../src/cache-engine-core.mjs"
+import {
+  BASELINES,
+  MODEL_ALIASES,
+  OVERLAYS,
+  POLICY_REGISTRY,
+  resolveLegacyFamily,
+  resolvePolicy,
+  resolveRuntimePolicy,
+} from "../src/cache-policy-core.mjs"
 
 const asst = (id, read, write) => ({
   info: { id, role: "assistant", tokens: { cache: { read, write } } },
@@ -1316,3 +1325,419 @@ test("affinity telemetry preserves non-OpenRouter families and reports provider
   assert.equal(glmChange.to.providerID, "zai")
   assert.equal(glmChange.policy, POLICY_GLM53)
 })
+
+// ===========================================================================
+// v0.4.0 policy registry + resolvePolicy() (research-backed, pure, unwired)
+//
+// The inventory (docs/cache-policy-inventory.md) is the authority. These tests
+// assert the structured resolution layer and that detectPolicy() remains
+// byte-compatible with its pre-v0.4.0 behavior.
+// ===========================================================================
+
+const overlayIds = (r) => r.overlays.map((o) => o.id)
+const baseId = (r) => (r.baseline ? r.baseline.id : null)
+
+test("resolvePolicy: GPT-5.6 exact + inventory aliases resolve to the gpt-5.6 family", () => {
+  const exact = resolvePolicy(M("openai", "gpt-5.6-sol"))
+  assert.equal(exact.creator, "openai")
+  assert.equal(exact.family, "gpt-5.6")
+  assert.equal(exact.matchType, "exact")
+  assert.equal(baseId(exact), "openai.gpt56.cache")
+  assert.deepEqual(overlayIds(exact), ["gpt56.prompt-cache-options"])
+  assert.equal(exact.transport.kind, "direct")
+
+  // Inventory alias: gpt-5.6 -> gpt-5.6-sol
+  const alias = resolvePolicy(M("openai", "gpt-5.6"))
+  assert.equal(alias.family, "gpt-5.6")
+  assert.equal(alias.matchType, "exact")
+  assert.ok(alias.matchReason.startsWith("alias:gpt-5.6"))
+  assert.deepEqual(overlayIds(alias), ["gpt56.prompt-cache-options"])
+
+  // OpenRouter-prefixed documented variant resolves by exact id (prefix stripped)
+  const orVariant = resolvePolicy(M("openrouter", "openai/gpt-5.6-luna"))
+  assert.equal(orVariant.family, "gpt-5.6")
+  assert.equal(orVariant.matchType, "exact")
+})
+
+test("resolvePolicy: GPT-6 resolves via explicit documented inheritance, with no overlay", () => {
+  const r = resolvePolicy(M("openrouter", "openai/gpt-6-luna"))
+  assert.equal(r.creator, "openai")
+  assert.equal(r.family, "gpt-6")
+  assert.equal(baseId(r), "openai.gpt56.cache")
+  assert.deepEqual(overlayIds(r), [])
+  assert.equal(resolvePolicy(M("openai", "gpt-6-astra")).family, "gpt-6")
+
+  // Inheritance is explicit, not "newer means same": the registry records it.
+  const gpt6 = POLICY_REGISTRY.find((e) => e.family === "gpt-6")
+  assert.equal(gpt6.inheritsFrom, "gpt-5.6")
+  assert.ok(gpt6.inventoryRef)
+  // And no overlay is implied by that inheritance.
+  assert.deepEqual(gpt6.overlays, [])
+})
+
+test("resolvePolicy: GPT-6 is not classified by the legacy detectPolicy wrapper", () => {
+  // Intentional: the new layer knows gpt-6, the compatibility wrapper does not.
+  assert.equal(detectPolicy(M("openai", "gpt-6-astra")), POLICY_NEUTRAL)
+  assert.equal(resolvePolicy(M("openai", "gpt-6-astra")).family, "gpt-6")
+})
+
+test("resolvePolicy: pre-5.6 GPT negative controls are neutral with no overlays", () => {
+  for (const id of ["gpt-5.5", "gpt-5.4", "gpt-5.2", "gpt-5.1", "gpt-5", "gpt-4.1", "gpt-4o"]) {
+    const r = resolvePolicy(M("openai", id))
+    assert.equal(r.family, "neutral", `${id} must be neutral`)
+    assert.deepEqual(overlayIds(r), [])
+    assert.equal(r.matchType, "neutral")
+  }
+})
+
+test("resolvePolicy: DeepSeek V4 / V4.1 resolve to the creator baseline (passive, no overlay)", () => {
+  const v4 = resolvePolicy(M("deepseek", "deepseek-v4-pro"))
+  assert.equal(v4.creator, "deepseek")
+  assert.equal(v4.family, "deepseek")
+  assert.equal(v4.matchType, "creator")
+  assert.equal(baseId(v4), "deepseek.kv-cache")
+  assert.deepEqual(overlayIds(v4), [])
+
+  assert.equal(resolvePolicy(M("deepseek", "deepseek-flash")).family, "deepseek")
+
+  // Inventory alias: retired deepseek-v4-flash -> deepseek-flash
+  const legacy = resolvePolicy(M("deepseek", "deepseek-v4-flash"))
+  assert.equal(legacy.family, "deepseek")
+  assert.ok(legacy.matchReason.startsWith("alias:deepseek-v4-flash"))
+
+  // pre-V4 negative control still resolves to the creator baseline
+  assert.equal(resolvePolicy(M("deepseek", "deepseek-chat")).family, "deepseek")
+})
+
+test("resolvePolicy: GLM-5.3 + documented 5.3 variants carry the overlay; 5.2 and earlier do not", () => {
+  const r = resolvePolicy(M("zai", "glm-5.3"))
+  assert.equal(r.creator, "z.ai")
+  assert.equal(r.family, "glm-5.3")
+  assert.equal(baseId(r), "zai.implicit-cache")
+  assert.deepEqual(overlayIds(r), ["glm53.env-relocation"])
+
+  assert.equal(resolvePolicy(M("zai", "glm-5.3-flash")).family, "glm-5.3")
+  assert.equal(resolvePolicy(M("z-ai", "glm-5.3-flashx")).family, "glm-5.3")
+
+  for (const id of ["glm-5.2", "glm-5.1", "glm-5", "glm-4.7", "glm-4.6", "glm-4.5"]) {
+    const g = resolvePolicy(M("zai", id))
+    assert.equal(g.family, "neutral", `${id} must be neutral`)
+    assert.deepEqual(overlayIds(g), [])
+  }
+})
+
+test("resolvePolicy: MiMo V2.6 Flash/Pro carry the overlay; Pro UltraSpeed is an explicit no-overlay series member", () => {
+  const flash = resolvePolicy(M("xiaomi", "mimo-v2.6-flash"))
+  assert.equal(flash.creator, "xiaomi")
+  assert.equal(flash.family, "mimo-v2.6")
+  assert.equal(baseId(flash), "xiaomi.implicit-cache")
+  assert.deepEqual(overlayIds(flash), ["mimo26.env-relocation"])
+
+  const pro = resolvePolicy(M("xiaomi", "mimo-v2.6-pro"))
+  assert.equal(pro.family, "mimo-v2.6")
+  assert.deepEqual(overlayIds(pro), ["mimo26.env-relocation"])
+
+  // Documented as the same V2.6 series but with NO registered overlay.
+  const ultraspeed = resolvePolicy(M("xiaomi", "mimo-v2.6-pro-ultraspeed"))
+  assert.equal(ultraspeed.family, "mimo-v2.6")
+  assert.equal(ultraspeed.matchType, "exact")
+  assert.deepEqual(overlayIds(ultraspeed), [])
+  const uEntry = POLICY_REGISTRY.find((e) => e.id === "xiaomi.mimo-v2.6-pro-ultraspeed")
+  assert.equal(uEntry.policyStatus, "documented-series-member-without-registered-overlay")
+
+  const v25 = resolvePolicy(M("xiaomi", "mimo-v2.5"))
+  assert.equal(v25.family, "neutral")
+  assert.deepEqual(overlayIds(v25), [])
+})
+
+test("resolvePolicy: overlays are never implied by creator/family classification", () => {
+  // Being GLM/MiMo/DeepSeek does not by itself grant a transformation overlay.
+  assert.deepEqual(overlayIds(resolvePolicy(M("zai", "glm-4.6"))), [])
+  assert.deepEqual(overlayIds(resolvePolicy(M("xiaomi", "mimo-v2.5"))), [])
+  assert.deepEqual(overlayIds(resolvePolicy(M("deepseek", "deepseek-v4-pro"))), [])
+  // A hypothetical future GLM does not silently inherit the 5.3 overlay.
+  assert.deepEqual(overlayIds(resolvePolicy(M("zai", "glm-5.4"))), [])
+})
+
+test("resolvePolicy: malformed and unknown model ids resolve safely", () => {
+  for (const bad of [undefined, null, {}, 42, "gpt-5.6", [], true]) {
+    const r = resolvePolicy(bad)
+    assert.equal(r.family, "neutral")
+    assert.equal(r.matchType, "neutral")
+    assert.equal(baseId(r), "neutral.none")
+    assert.deepEqual(r.overlays, [])
+  }
+  // A provider with no model identity gets no family.
+  assert.equal(resolvePolicy({ providerID: "openai" }).family, "neutral")
+})
+
+test("resolvePolicy: unknown providers/creators do not gain policy from transport identity", () => {
+  const orUnknown = resolvePolicy(M("openrouter", "acme/mystery-model-9"))
+  assert.equal(orUnknown.family, "neutral")
+  assert.deepEqual(orUnknown.overlays, [])
+  assert.equal(orUnknown.transport.kind, "openrouter")
+  assert.equal(orUnknown.transport.sessionAffinityHeader, "x-session-id")
+
+  // gpt-5.6 on a non-OpenAI gateway stays neutral even though the id looks OpenAI
+  assert.equal(resolvePolicy(M("some-gateway", "gpt-5.6")).family, "neutral")
+  assert.equal(resolvePolicy(M("xiaomi", "not-a-mimo")).family, "neutral")
+})
+
+test("resolvePolicy: transport is computed independently from cache policy", () => {
+  const ds = resolvePolicy(M("deepseek", "deepseek-v4-pro"))
+  assert.equal(ds.transport.kind, "direct")
+  assert.equal(ds.transport.sessionAffinityHeader, null)
+
+  const or = resolvePolicy(M("openrouter", "openai/gpt-5.6-luna"))
+  assert.equal(or.family, "gpt-5.6")
+  assert.equal(or.transport.kind, "openrouter")
+  assert.equal(or.transport.sessionAffinityHeader, "x-session-id")
+
+  const zai = resolvePolicy(M("zai", "glm-5.3"))
+  assert.equal(zai.transport.kind, "direct")
+  assert.equal(zai.transport.sessionAffinityHeader, null)
+
+  const noProvider = resolvePolicy({ modelID: "gpt-6-astra" })
+  assert.equal(noProvider.transport.kind, "unknown")
+})
+
+test("resolvePolicy is pure and does not mutate its input", () => {
+  const model = Object.freeze({ providerID: "openai", modelID: "gpt-5.6-sol" })
+  const r = resolvePolicy(model)
+  assert.equal(r.family, "gpt-5.6")
+  assert.equal(model.modelID, "gpt-5.6-sol")
+})
+
+test("detectPolicy remains compatible with the legacy family resolution", () => {
+  const legacyMap = {
+    "gpt-5.6": POLICY_GPT56,
+    "glm-5.3": POLICY_GLM53,
+    "mimo-v2.6": POLICY_MIMO26,
+    deepseek: POLICY_DEEPSEEK,
+  }
+  const samples = [
+    M("openrouter", "openai/gpt-5.6-luna"),
+    M("openai", "gpt-5.6"),
+    M("openai-compatible", "gpt-5.6"),
+    M("openai", "gpt-5.5"),
+    M("zai", "glm-5.3-flash"),
+    M("zai", "glm-4.6"),
+    M("xiaomi", "mimo-v2.6-flash"),
+    M("xiaomi", "mimo-v2.6-pro-ultraspeed"),
+    M("xiaomi", "mimo-v2.5"),
+    M("deepseek", "deepseek-chat"),
+    M("openrouter", "x-ai/grok-4"),
+    M("anthropic", "claude-sonnet-4-5"),
+    {},
+    null,
+    undefined,
+    42,
+  ]
+  for (const m of samples) {
+    const expected = legacyMap[resolveLegacyFamily(m)] ?? POLICY_NEUTRAL
+    assert.equal(detectPolicy(m), expected)
+  }
+})
+
+test("registry is traceable and internally consistent", () => {
+  for (const entry of POLICY_REGISTRY) {
+    assert.ok(entry.inventoryRef, `${entry.id} must cite the inventory`)
+    assert.ok(BASELINES[entry.baseline], `${entry.id} baseline must exist`)
+    for (const overlayId of entry.overlays) {
+      assert.ok(OVERLAYS[overlayId], `${entry.id} overlay ${overlayId} must exist`)
+    }
+  }
+  for (const [id, alias] of Object.entries(MODEL_ALIASES)) {
+    assert.ok(alias.inventoryRef, `alias ${id} must cite the inventory`)
+    assert.ok(alias.family)
+  }
+})
+
+// ===========================================================================
+// v0.4.1 runtime policy migration (behavior preservation)
+//
+// The runtime now classifies via resolveRuntimePolicy(). These tests prove the
+// resolved policy equals the legacy detectPolicy() string for every supported
+// model, and that the hook-observable behavior (GPT cache options, <env>
+// relocation, OpenRouter affinity) is unchanged. Newer/unknown models must
+// gain no mutation.
+// ===========================================================================
+
+const policyCoreURL = new URL("../src/cache-policy-core.mjs", import.meta.url).href
+
+test("v0.4.1: resolveRuntimePolicy.policy matches detectPolicy across a broad matrix", () => {
+  const samples = [
+    M("openai", "gpt-5.6"),
+    M("openai", "gpt-5.6-sol"),
+    M("openrouter", "openai/gpt-5.6-luna"),
+    M("openai-compatible", "gpt-5.6"),
+    M("openai", "gpt-6-astra"),
+    M("openai", "gpt-5.5"),
+    M("openai", "gpt-daybreak-blue-latest"),
+    M("openai", "gpt-daybreak-red-latest"),
+    M("zai", "glm-5.3"),
+    M("zai", "glm-5.3-flash"),
+    M("zai", "glm-5.2"),
+    M("xiaomi", "mimo-v2.6-flash"),
+    M("xiaomi", "mimo-v2.6-pro"),
+    M("xiaomi", "mimo-v2.6-pro-ultraspeed"),
+    M("xiaomi", "mimo-v2.5"),
+    M("deepseek", "deepseek-v4-pro"),
+    M("deepseek", "deepseek-flash"),
+    M("deepseek", "deepseek-v4-flash"),
+    M("deepseek", "deepseek-chat"),
+    M("openrouter", "x-ai/grok-4"),
+    {},
+    null,
+    undefined,
+    42,
+  ]
+  for (const m of samples) {
+    assert.equal(resolveRuntimePolicy(m).policy, detectPolicy(m))
+  }
+})
+
+test("v0.4.1: GPT-5.6 alias keeps the overlay but a newer alias stays runtime-neutral", () => {
+  // Legacy alias: gpt-5.6 -> gpt-5.6-sol (was matched by the old regex).
+  const legacy = resolveRuntimePolicy(M("openai", "gpt-5.6"))
+  assert.equal(legacy.policy, "gpt56")
+  assert.equal(legacy.gptCacheMetadata, true)
+  // Newer documented alias that the old classifier did NOT match: no mutation.
+  const newer = resolveRuntimePolicy(M("openai", "gpt-daybreak-blue-latest"))
+  assert.equal(newer.policy, "neutral")
+  assert.equal(newer.gptCacheMetadata, false)
+  assert.equal(resolvePolicy(M("openai", "gpt-daybreak-blue-latest")).family, "gpt-5.6")
+})
+
+async function runPolicyMigrationProbe() {
+  const home = mkdtempSync(join(tmpdir(), "ce-policy-migration-"))
+  const pluginURL = new URL("../src/cache-engine.ts", import.meta.url).href
+  const coreURL = new URL("../src/cache-engine-core.mjs", import.meta.url).href
+  const script = `
+    import assert from "node:assert/strict"
+    process.env.CACHE_ENGINE_METRICS_FILE = process.env.HOME + "/policy-migration.jsonl"
+    const { CacheEngine } = await import(${JSON.stringify(pluginURL)})
+    const { detectPolicy } = await import(${JSON.stringify(coreURL)})
+    const { resolvePolicy, resolveRuntimePolicy } = await import(${JSON.stringify(policyCoreURL)})
+    const client = {
+      app: { log: async () => ({}) },
+      session: { get: async () => ({ data: { parentID: null } }) },
+      tool: { list: async () => ({ data: [] }) },
+    }
+    const hooks = await CacheEngine({ client, directory: process.env.HOME })
+    assert.equal(typeof hooks["chat.params"], "function")
+    assert.equal(typeof hooks["chat.headers"], "function")
+    assert.equal(typeof hooks["experimental.chat.system.transform"], "function")
+    const SYS = ["A: keep1", "B: You are powered by the model named x. The exact model ID is acme/x", "C: <env>", "D: Today's date: 2026-08-17", "E: </env>", "F: keep2"].join("\\n")
+    const CASES = [
+      { name: "gpt-5.6", model: { providerID: "openai", id: "gpt-5.6", api: { id: "gpt-5.6", npm: "@ai-sdk/openai" } }, expect: { policy: "gpt56", env: false, gpt: true, header: false } },
+      { name: "gpt-5.6-openrouter", model: { providerID: "openrouter", id: "openai/gpt-5.6-sol", api: { id: "openai/gpt-5.6-sol" } }, expect: { policy: "gpt56", env: false, gpt: true, header: false } },
+      { name: "gpt-6-astra", model: { providerID: "openai", id: "gpt-6-astra", api: { id: "gpt-6-astra", npm: "@ai-sdk/openai" } }, expect: { policy: "neutral", env: false, gpt: false, header: false } },
+      { name: "gpt-5.5", model: { providerID: "openai", id: "gpt-5.5", api: { id: "gpt-5.5", npm: "@ai-sdk/openai" } }, expect: { policy: "neutral", env: false, gpt: false, header: false } },
+      { name: "gpt-daybreak-alias", model: { providerID: "openai", id: "gpt-daybreak-blue-latest", api: { id: "gpt-daybreak-blue-latest", npm: "@ai-sdk/openai" } }, expect: { policy: "neutral", env: false, gpt: false, header: false } },
+      { name: "deepseek-v4-pro", model: { providerID: "deepseek", id: "deepseek-v4-pro", api: { id: "deepseek-v4-pro" } }, expect: { policy: "deepseek", env: false, gpt: false, header: false } },
+      { name: "deepseek-flash", model: { providerID: "deepseek", id: "deepseek-flash", api: { id: "deepseek-flash" } }, expect: { policy: "deepseek", env: false, gpt: false, header: false } },
+      { name: "glm-5.3-direct", model: { providerID: "zai", id: "glm-5.3", api: { id: "glm-5.3" } }, expect: { policy: "glm53", env: true, gpt: false, header: false } },
+      { name: "glm-5.3-openrouter", model: { providerID: "openrouter", id: "z-ai/glm-5.3-flash", api: { id: "z-ai/glm-5.3-flash" } }, expect: { policy: "glm53", env: true, gpt: false, header: true } },
+      { name: "glm-5.2", model: { providerID: "zai", id: "glm-5.2", api: { id: "glm-5.2" } }, expect: { policy: "neutral", env: false, gpt: false, header: false } },
+      { name: "mimo-v2.6-flash-direct", model: { providerID: "xiaomi", id: "mimo-v2.6-flash", api: { id: "mimo-v2.6-flash" } }, expect: { policy: "mimo26", env: true, gpt: false, header: false } },
+      { name: "mimo-v2.6-pro-openrouter", model: { providerID: "openrouter", id: "xiaomi/mimo-v2.6-pro", api: { id: "xiaomi/mimo-v2.6-pro" } }, expect: { policy: "mimo26", env: true, gpt: false, header: true } },
+      { name: "mimo-v2.6-pro-ultraspeed", model: { providerID: "xiaomi", id: "mimo-v2.6-pro-ultraspeed", api: { id: "mimo-v2.6-pro-ultraspeed" } }, expect: { policy: "neutral", env: false, gpt: false, header: false } },
+      { name: "mimo-v2.5", model: { providerID: "xiaomi", id: "mimo-v2.5", api: { id: "mimo-v2.5" } }, expect: { policy: "neutral", env: false, gpt: false, header: false } },
+      { name: "unknown-provider", model: { providerID: "mystery-provider", id: "xiaomi/mimo-v2.6-flash", api: { id: "xiaomi/mimo-v2.6-flash" } }, expect: { policy: "mimo26", env: true, gpt: false, header: false } },
+      { name: "unknown-openrouter", model: { providerID: "openrouter", id: "acme/mystery-9", api: { id: "acme/mystery-9" } }, expect: { policy: "neutral", env: false, gpt: false, header: false } },
+    ]
+    const results = []
+    for (const c of CASES) {
+      const model = c.model
+      const sid = "ses_" + c.name
+      const provider = { source: "config", info: { id: String(model.providerID ?? "") }, options: {} }
+      const existing = { "User-Agent": "preserve", "x-custom": "preserve" }
+      const paramsOut = { options: {} }
+      const headersOut = { headers: { ...existing } }
+      const sysOut = { system: [SYS] }
+      await hooks["chat.params"]({ sessionID: sid, agent: "build", model, provider, message: { id: "msg-" + c.name, sessionID: sid, role: "user", content: "probe" } }, paramsOut)
+      await hooks["experimental.chat.system.transform"]({ sessionID: sid, model, provider }, sysOut)
+      await hooks["chat.headers"]({ sessionID: sid, agent: "build", model, provider, message: { id: "msg-" + c.name, sessionID: sid, role: "user", content: "probe" } }, headersOut)
+      const rt = resolveRuntimePolicy(model)
+      const existingHeadersPreserved = Object.entries(existing).every(([k, v]) => headersOut.headers[k] === v)
+      results.push({
+        name: c.name,
+        runtimePolicy: rt.policy,
+        detectPolicy: detectPolicy(model),
+        richFamily: resolvePolicy(model).family,
+        overlays: resolvePolicy(model).overlays.map((o) => o.id),
+        systemRelocated: sysOut.system[0] !== SYS,
+        gptOptionInjected: paramsOut.options.promptCacheKey !== undefined,
+        gptOptions: paramsOut.options.promptCacheOptions ?? null,
+        affinityHeaderAttached: headersOut.headers["x-session-id"] !== undefined,
+        existingHeadersPreserved,
+        expect: c.expect,
+      })
+    }
+    process.stdout.write(JSON.stringify({ results }))
+  `
+  const stdout = execFileSync(process.execPath, ["--experimental-strip-types", "--input-type=module", "-e", script], {
+    cwd: process.cwd(),
+    env: { ...process.env, HOME: home },
+    encoding: "utf8",
+  })
+  return JSON.parse(stdout.trim())
+}
+
+let policyMigrationProbe
+const policyMigrationResults = async () => (policyMigrationProbe ??= runPolicyMigrationProbe())
+
+test("v0.4.1: runtime policy is the resolver's and stays equal to detectPolicy (hook path)", async () => {
+  const { results } = await policyMigrationResults()
+  assert.ok(results.length >= 15)
+  for (const r of results) {
+    assert.equal(r.runtimePolicy, r.detectPolicy, `${r.name}: resolver policy must equal legacy detectPolicy`)
+    assert.equal(r.runtimePolicy, r.expect.policy, `${r.name}: unexpected policy`)
+  }
+})
+
+test("v0.4.1: every supported model keeps its pre-migration hook behavior", async () => {
+  const { results } = await policyMigrationResults()
+  for (const r of results) {
+    assert.equal(r.systemRelocated, r.expect.env, `${r.name}: <env> relocation`)
+    assert.equal(r.gptOptionInjected, r.expect.gpt, `${r.name}: GPT cache-options injection`)
+    assert.equal(r.affinityHeaderAttached, r.expect.header, `${r.name}: OpenRouter affinity header`)
+    // No provider in the matrix mutates or drops pre-existing headers.
+    assert.equal(r.existingHeadersPreserved, true, `${r.name}: existing headers preserved`)
+  }
+})
+
+test("v0.4.1: GPT-5.6 keeps promptCacheOptions implicit/30m through the resolver", async () => {
+  const { results } = await policyMigrationResults()
+  const gpt = results.find((r) => r.name === "gpt-5.6")
+  assert.deepEqual(gpt.gptOptions, { mode: "implicit", ttl: "30m" })
+})
+
+test("v0.4.1: future-looking and unknown models gain no mutation", async () => {
+  const { results } = await policyMigrationResults()
+  const noMutation = [
+    "gpt-6-astra",
+    "gpt-daybreak-alias",
+    "gpt-5.5",
+    "glm-5.2",
+    "mimo-v2.6-pro-ultraspeed",
+    "mimo-v2.5",
+    "unknown-openrouter",
+  ]
+  for (const name of noMutation) {
+    const r = results.find((x) => x.name === name)
+    assert.ok(r, `${name} present`)
+    assert.equal(r.gptOptionInjected, false, `${name}: no GPT options`)
+    assert.equal(r.systemRelocated, false, `${name}: no <env> relocation`)
+    assert.equal(r.affinityHeaderAttached, false, `${name}: no affinity header`)
+  }
+})
+
+test("v0.4.1: non-OpenRouter models never receive the OpenRouter header", async () => {
+  const { results } = await policyMigrationResults()
+  for (const name of ["glm-5.3-direct", "mimo-v2.6-flash-direct", "unknown-provider", "gpt-5.6", "deepseek-v4-pro"]) {
+    const r = results.find((x) => x.name === name)
+    assert.equal(r.affinityHeaderAttached, false, `${name}: no affinity header off OpenRouter`)
+  }
+})