@cortexkit/opencode-magic-context 0.48.0 → 0.49.0

package/src/shared/auto-search-lifecycle.ts

@@ -1,4 +1,47 @@
+import type { AutoSearchHintNoHintReason } from "../features/magic-context/storage-meta-persisted";
+
 const pending = new Map<string, Set<AbortController>>();
+const unpublishedNoHints = new Map<string, Map<string, AutoSearchHintNoHintReason>>();
+
+/**
+ * A failed save can still send the user message without a search hint. Remember
+ * that no-hint decision until a later pass saves it to SQLite, including across
+ * closing and reopening the database handle. Switching or shutting down a session
+ * does not prove deletion and must not discard it. If all compare-and-swap (CAS)
+ * save retries fail and the process restarts before repair, this unsaved record
+ * is lost: that compound failure is the remaining durability gap.
+ */
+export function rememberUnpublishedAutoSearchNoHint(
+    sessionId: string,
+    messageId: string,
+    reason: AutoSearchHintNoHintReason,
+): void {
+    let messages = unpublishedNoHints.get(sessionId);
+    if (!messages) {
+        messages = new Map();
+        unpublishedNoHints.set(sessionId, messages);
+    }
+    if (!messages.has(messageId)) messages.set(messageId, reason);
+}
+
+export function getUnpublishedAutoSearchNoHint(
+    sessionId: string,
+    messageId: string,
+): AutoSearchHintNoHintReason | undefined {
+    return unpublishedNoHints.get(sessionId)?.get(messageId);
+}
+
+export function forgetUnpublishedAutoSearchNoHint(sessionId: string, messageId: string): void {
+    const messages = unpublishedNoHints.get(sessionId);
+    messages?.delete(messageId);
+    if (messages?.size === 0) unpublishedNoHints.delete(sessionId);
+}
+
+/** Deleting a session releases its unsaved no-hint records; switching away does not. */
+export function clearUnpublishedAutoSearchNoHints(sessionId?: string): void {
+    if (sessionId === undefined) unpublishedNoHints.clear();
+    else unpublishedNoHints.delete(sessionId);
+}
 
 /** Cleanup cancels optional searches and backfill, not durable served decisions. */
 export function registerAutoSearchWork(sessionId: string): {

package/src/shared/logger.test.ts

@@ -129,6 +129,28 @@ if (scenario === "retry") {
         predecessorMode: fs.statSync(predecessorPath).mode & 0o777,
         files: fs.readdirSync(path.dirname(logPath)).filter((name) => name.startsWith("magic-context.log")).sort(),
     }));
+} else if (scenario === "stale-rotation") {
+    const maxLogBytes = 32 * 1024 * 1024;
+    fs.mkdirSync(path.dirname(logPath), { recursive: true });
+    fs.writeFileSync(logPath, Buffer.alloc(maxLogBytes - 200, "o"));
+    fs.chmodSync(logPath, 0o600);
+    // This process now caches a size just under the bound.
+    logger.log("cached size");
+    logger.flushLogger();
+
+    // Another process sharing the file rotates it: the full log becomes the
+    // predecessor and the current file starts over.
+    fs.copyFileSync(logPath, logPath + ".1");
+    fs.writeFileSync(logPath, "written by the other process\\n");
+
+    // A line that crosses the bound only by this process's stale cached size.
+    logger.log("x".repeat(400));
+    logger.flushLogger();
+    console.log(JSON.stringify({
+        current: fs.readFileSync(logPath, "utf8"),
+        predecessorFirstByte: fs.readFileSync(logPath + ".1")[0],
+        predecessorSize: fs.statSync(logPath + ".1").size,
+    }));
 } else if (scenario === "hot-path") {
     for (let index = 0; index < 20; index++) {
         logger.log("hot-path-" + index);
@@ -182,6 +204,7 @@ async function runLoggerScenario<T>(
         | "recovery"
         | "diagnostics"
         | "rotation"
+        | "stale-rotation"
         | "hot-path"
         | "retry"
         | "bounded"
@@ -269,6 +292,21 @@ describe("logger", () => {
         }
     });
 
+    test("a stale cached size does not rotate a file another process already rotated", async () => {
+        const result = await runLoggerScenario<{
+            current: string;
+            predecessorFirstByte: number;
+            predecessorSize: number;
+        }>("stale-rotation");
+
+        // The other process's full predecessor survives, and the new line joins
+        // the restarted current file instead of replacing that predecessor.
+        expect(result.predecessorFirstByte).toBe("o".charCodeAt(0));
+        expect(result.predecessorSize).toBeGreaterThan(32 * 1024 * 1024 - 1024);
+        expect(result.current).toContain("written by the other process");
+        expect(result.current).toContain("x".repeat(400));
+    });
+
     test("uses cached size between periodic rotation checks", async () => {
         const result = await runLoggerScenario<HotPathScenarioResult>("hot-path");
 

package/src/shared/logger.ts

@@ -163,8 +163,16 @@ function flush(): void {
         let currentSize = getCurrentLogSize(logFile);
         const dataSize = Buffer.byteLength(data);
         if (currentSize > 0 && currentSize + dataSize > MAX_LOG_FILE_BYTES) {
-            rotateLogFile(logFile, currentSize);
-            currentSize = 0;
+            // Several processes share this file and each caches its size. A stale
+            // cache must not rotate a file another process already rotated: that
+            // second rotation would overwrite the full predecessor with the few
+            // lines written since. Decide on the file's real size instead.
+            flushesSinceSizeCheck = SIZE_CHECK_INTERVAL_FLUSHES;
+            currentSize = getCurrentLogSize(logFile);
+            if (currentSize > 0 && currentSize + dataSize > MAX_LOG_FILE_BYTES) {
+                rotateLogFile(logFile, currentSize);
+                currentSize = 0;
+            }
         }
         fs.appendFileSync(logFile, data, { encoding: "utf8", mode: 0o600 });
         buffer = [];

package/src/shared/models-dev-temperature.ts

@@ -0,0 +1,107 @@
+/**
+ * Temperature capability from the models.dev catalog that OpenCode caches on disk.
+ *
+ * OpenCode 1 copies models.dev's `temperature` flag onto each model, but OpenCode 2's
+ * model rows, Pi's model registry and Oh My Pi's Gemini models carry no equivalent
+ * field. For those hosts the cached catalog is the only positive evidence on the
+ * machine, so a missing file, an unparsable file or a missing entry all mean "unknown"
+ * and the caller omits temperature.
+ *
+ * This module is bundled into the Pi/OMP historian child extension, so it must only
+ * depend on Node built-ins.
+ */
+import { readFileSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export interface CatalogTemperature {
+    temperature: boolean;
+    /** The catalog entry that decided, as `provider/model`. */
+    entry: string;
+}
+
+/**
+ * Harness provider ids that name the same models.dev provider. Codex (`openai-codex`)
+ * is deliberately absent: the ChatGPT backend is a different transport from the
+ * OpenAI API that models.dev describes, so it gets no catalog answer and no temperature.
+ */
+const CATALOG_PROVIDER_ALIASES: Readonly<Record<string, string>> = {
+    "google-antigravity": "google",
+    "opencode-zen": "opencode",
+};
+
+/** The Antigravity auth plugins register Gemini models as `google/antigravity-<model>`. */
+const ANTIGRAVITY_MODEL_PREFIX = "antigravity-";
+
+type CatalogIndex = Map<string, boolean>;
+
+let cached: { path: string; mtimeMs: number; size: number; index: CatalogIndex } | undefined;
+
+/** OpenCode reads `OPENCODE_MODELS_PATH` instead of its cache when it is set. */
+export function modelsDevCatalogPath(env: NodeJS.ProcessEnv = process.env): string {
+    if (env.OPENCODE_MODELS_PATH) return env.OPENCODE_MODELS_PATH;
+    return join(env.XDG_CACHE_HOME || join(homedir(), ".cache"), "opencode", "models.json");
+}
+
+function buildIndex(raw: unknown): CatalogIndex {
+    const index: CatalogIndex = new Map();
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) return index;
+    for (const [providerID, provider] of Object.entries(raw as Record<string, unknown>)) {
+        const models = (provider as { models?: unknown } | null)?.models;
+        if (!models || typeof models !== "object") continue;
+        for (const [modelID, model] of Object.entries(models as Record<string, unknown>)) {
+            const temperature = (model as { temperature?: unknown } | null)?.temperature;
+            if (typeof temperature === "boolean")
+                index.set(`${providerID}/${modelID}`, temperature);
+        }
+    }
+    return index;
+}
+
+function loadIndex(): CatalogIndex | undefined {
+    const path = modelsDevCatalogPath();
+    try {
+        const stat = statSync(path);
+        if (cached?.path === path && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size)
+            return cached.index;
+        const index = buildIndex(JSON.parse(readFileSync(path, "utf8")));
+        cached = { path, mtimeMs: stat.mtimeMs, size: stat.size, index };
+        return index;
+    } catch {
+        // Absent or partially written catalog: no evidence either way.
+        return undefined;
+    }
+}
+
+/** Spellings to try for a harness `provider/model` reference, most specific first. */
+export function catalogCandidates(providerID: string, modelID: string): string[] {
+    const provider = Object.hasOwn(CATALOG_PROVIDER_ALIASES, providerID)
+        ? CATALOG_PROVIDER_ALIASES[providerID]
+        : providerID;
+    const candidates = [`${provider}/${modelID}`];
+    if (provider === "google" && modelID.startsWith(ANTIGRAVITY_MODEL_PREFIX))
+        candidates.push(`google/${modelID.slice(ANTIGRAVITY_MODEL_PREFIX.length)}`);
+    return candidates;
+}
+
+/**
+ * Look `provider/model` up in the cached catalogue, trying only the exact spellings from
+ * `catalogCandidates`. A malformed reference, a missing catalogue or no entry returns undefined.
+ */
+export function catalogTemperature(model: string): CatalogTemperature | undefined {
+    const slash = model.indexOf("/");
+    if (slash <= 0 || slash === model.length - 1) return undefined;
+    const index = loadIndex();
+    if (!index) return undefined;
+    for (const entry of catalogCandidates(model.slice(0, slash), model.slice(slash + 1))) {
+        const temperature = index.get(entry);
+        if (temperature !== undefined) return { temperature, entry };
+    }
+    return undefined;
+}
+
+export const __catalogTest = {
+    reset(): void {
+        cached = undefined;
+    },
+};

package/src/shared/project-directory-key.test.ts

@@ -13,6 +13,7 @@ import {
     __setCanonicalDirectoryRealpathForTests,
     canonicalProjectDirectory,
     projectDirectoryKey,
+    sameProjectDirectory,
 } from "./project-directory-key";
 import { projectHash, rpcPortDirsForLookup } from "./rpc-utils";
 import { createTestTempDirFromPath } from "./test-temp-dir";
@@ -109,3 +110,61 @@ describe("one discovery directory per project directory", () => {
         expect(dirs[0]).toBe(join("/storage", "rpc", projectHash("C:\\Users\\A\\Proj\\")));
     });
 });
+
+/**
+ * Background-session code compares a session's recorded directory with the
+ * plugin's own. OpenCode 2 on Windows records `D:/coding/app` while the plugin
+ * knows `D:\coding\app`; both must count as one directory, and a different
+ * directory must never be taken for this one.
+ */
+describe("sameProjectDirectory", () => {
+    for (const [name, left, right] of WINDOWS_PAIRS) {
+        test(`Windows ${name} is the same directory`, () => {
+            expect(sameProjectDirectory(left, right)).toBe(true);
+            expect(sameProjectDirectory(right, left)).toBe(true);
+        });
+    }
+
+    test("Windows forward slashes against backslashes, as OpenCode 2 stores them", () => {
+        expect(
+            sameProjectDirectory(
+                "D:/coding/siac/wt/migracion-asincrona",
+                "D:\\coding\\siac\\wt\\migracion-asincrona",
+            ),
+        ).toBe(true);
+    });
+
+    test("Windows `.` and `..` segments and a trailing forward slash", () => {
+        expect(
+            sameProjectDirectory("C:\\Users\\dev\\.\\work\\tmp\\..\\app", "C:/Users/dev/work/app/"),
+        ).toBe(true);
+    });
+
+    test("POSIX trailing slash and `..` segments", () => {
+        expect(sameProjectDirectory("/work/app/", "/work/app")).toBe(true);
+        expect(sameProjectDirectory("/work/tmp/../app", "/work/app")).toBe(true);
+    });
+
+    test("different directories are refused", () => {
+        expect(
+            sameProjectDirectory(
+                "D:/coding/siac/wt/notificaciones-pui",
+                "D:\\coding\\siac\\wt\\migracion-asincrona",
+            ),
+        ).toBe(false);
+        // A sibling whose name extends this one, a parent, and another drive.
+        expect(sameProjectDirectory("C:/Users/dev/app-worktree", "C:\\Users\\dev\\app")).toBe(
+            false,
+        );
+        expect(sameProjectDirectory("C:/Users/dev", "C:\\Users\\dev\\app")).toBe(false);
+        expect(sameProjectDirectory("D:/Users/dev/app", "C:\\Users\\dev\\app")).toBe(false);
+        // POSIX paths are case-sensitive.
+        expect(sameProjectDirectory("/work/App", "/work/app")).toBe(false);
+    });
+
+    test("an empty directory matches nothing, not even the process's working directory", () => {
+        expect(sameProjectDirectory("", process.cwd())).toBe(false);
+        expect(sameProjectDirectory(process.cwd(), "")).toBe(false);
+        expect(sameProjectDirectory("", "")).toBe(false);
+    });
+});

package/src/shared/project-directory-key.ts

@@ -20,6 +20,26 @@ export function projectDirectoryKey(directory: string): string {
     return path.resolve(directory);
 }
 
+/**
+ * Whether two spellings name the same directory, judged by spelling alone.
+ *
+ * Hosts and the plugin do not agree on how to write a directory: OpenCode 2 on
+ * Windows stores a session's directory as `D:/work/app` while the plugin's own
+ * location is `D:\work\app`, and a drive letter can arrive in either case.
+ * Both sides go through `projectDirectoryKey`, so separators, Windows case,
+ * `\\?\` prefixes, trailing separators and `.`/`..` segments cannot make one
+ * directory look like two. POSIX paths keep their case. Symlinks are not
+ * resolved here; callers that must follow them use `canonicalProjectDirectory`.
+ *
+ * An empty spelling never matches anything: `path.resolve("")` is the process's
+ * working directory, and a session with no recorded directory must not be
+ * taken for one in the directory the process happens to run in.
+ */
+export function sameProjectDirectory(a: string, b: string): boolean {
+    if (a.length === 0 || b.length === 0) return false;
+    return projectDirectoryKey(a) === projectDirectoryKey(b);
+}
+
 let realpathForCanonicalDirectory: (directory: string) => string = (directory) =>
     realpathSync.native(directory);
 

package/src/shared/subagent-temperature.test.ts

@@ -0,0 +1,270 @@
+import { afterAll, beforeEach, describe, expect, test } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { modelsDevCatalogPath } from "./models-dev-temperature";
+import {
+    __temperatureTest,
+    applyHiddenSubagentTemperature,
+    resolveTemperatureCapability,
+    subagentTemperature,
+} from "./subagent-temperature";
+import { cleanupTestTempDir, createTestTempDirFromPath } from "./test-temp-dir";
+
+// Every test reads a catalog it wrote itself, never the machine's OpenCode cache.
+const cacheRoot = createTestTempDirFromPath(join(tmpdir(), "mc-temperature-catalog-"));
+const savedEnv = {
+    XDG_CACHE_HOME: process.env.XDG_CACHE_HOME,
+    OPENCODE_MODELS_PATH: process.env.OPENCODE_MODELS_PATH,
+};
+
+/** Shape of OpenCode's cached models.dev api.json, trimmed to the fields that matter. */
+const CATALOG = {
+    google: {
+        id: "google",
+        models: {
+            "gemini-3.8-flash": { id: "gemini-3.8-flash", temperature: true, reasoning: true },
+        },
+    },
+    openrouter: {
+        id: "openrouter",
+        models: {
+            "google/gemini-3.8-flash": { temperature: true, reasoning: true },
+            "openai/gpt-6.1-sol": { temperature: false, reasoning: true },
+        },
+    },
+    openai: { id: "openai", models: { "gpt-6.1-sol": { temperature: false, reasoning: true } } },
+    opencode: { id: "opencode", models: { "gemini-3.8-flash": { temperature: true } } },
+    broken: { id: "broken", models: { "no-flag": { reasoning: true } } },
+};
+
+function writeCatalog(contents: string = JSON.stringify(CATALOG)): void {
+    const path = join(cacheRoot, "opencode", "models.json");
+    mkdirSync(join(cacheRoot, "opencode"), { recursive: true });
+    writeFileSync(path, contents);
+}
+
+function removeCatalog(): void {
+    rmSync(join(cacheRoot, "opencode"), { recursive: true, force: true });
+}
+
+beforeEach(() => {
+    process.env.XDG_CACHE_HOME = cacheRoot;
+    delete process.env.OPENCODE_MODELS_PATH;
+    removeCatalog();
+    __temperatureTest.reset();
+});
+
+afterAll(() => {
+    for (const [key, value] of Object.entries(savedEnv)) {
+        if (value === undefined) delete process.env[key];
+        else process.env[key] = value;
+    }
+    cleanupTestTempDir(cacheRoot);
+});
+
+describe("subagent sampling metadata", () => {
+    for (const [host, yes, no] of [
+        [
+            "OpenCode 1",
+            { capabilities: { temperature: true } },
+            { capabilities: { temperature: false } },
+        ],
+        ["OpenCode 2", { temperature: true }, { temperature: false }],
+        [
+            "Pi",
+            { compat: { supportsTemperature: true } },
+            { compat: { supportsTemperature: false } },
+        ],
+        [
+            "OMP",
+            { compat: { supportsSamplingParams: true } },
+            { compat: { supportsSamplingParams: false } },
+        ],
+    ] as const) {
+        test(`${host} requires affirmative metadata and preserves explicit zero`, () => {
+            const logs: string[] = [];
+            const note = (line: string) => logs.push(line);
+            expect(subagentTemperature("provider/yes", yes, 0.1, note)).toBe(0.1);
+            expect(subagentTemperature("provider/yes", yes, 0, note)).toBe(0);
+            expect(subagentTemperature("provider/no", no, 0.1, note)).toBeUndefined();
+            expect(
+                subagentTemperature("provider/missing", { reasoning: false }, 0.1, note),
+            ).toBeUndefined();
+            expect(
+                subagentTemperature("provider/unknown", { temperature: "yes" }, 0.1, note),
+            ).toBeUndefined();
+            expect(subagentTemperature("provider/unset", yes, undefined, note)).toBeUndefined();
+            expect(logs).toEqual([
+                "Subagent temperature sent for provider/yes: host model metadata says yes",
+                "Subagent temperature omitted for provider/no: host model metadata says no",
+                "Subagent temperature omitted for provider/missing: no host or models.dev metadata",
+                "Subagent temperature omitted for provider/unknown: no host or models.dev metadata",
+            ]);
+        });
+    }
+
+    test("decision logging is once per model and decision, and does not remember a denial as a capability", () => {
+        const logs: string[] = [];
+        const note = (line: string) => logs.push(line);
+        expect(subagentTemperature("p/m", undefined, 0.1, note)).toBeUndefined();
+        expect(subagentTemperature("p/m", undefined, 0.1, note)).toBeUndefined();
+        expect(subagentTemperature("p/m", { temperature: true }, 0.1, note)).toBe(0.1);
+        expect(subagentTemperature("p/m", { temperature: true }, 0.1, note)).toBe(0.1);
+        expect(logs).toEqual([
+            "Subagent temperature omitted for p/m: no host or models.dev metadata",
+            "Subagent temperature sent for p/m: host model metadata says yes",
+        ]);
+    });
+
+    test("OpenCode 1 guards historian, dreamer and compiler per resolved model, not unrelated agents", () => {
+        const yes = { providerID: "p", id: "flash", capabilities: { temperature: true } };
+        const no = { providerID: "p", id: "fallback", capabilities: { temperature: false } };
+        for (const agent of [
+            "historian",
+            "historian-editor",
+            "historian-recomp",
+            "dreamer",
+            "dreamer-classifier",
+            "smart-note-compiler",
+        ]) {
+            const output: { temperature?: number } = { temperature: 0 };
+            applyHiddenSubagentTemperature({ agent, model: yes }, output, () => {});
+            expect(output).toEqual({ temperature: 0 });
+            applyHiddenSubagentTemperature({ agent, model: no }, output, () => {});
+            expect(output).toEqual({});
+            output.temperature = 0.1;
+            applyHiddenSubagentTemperature({ agent }, output, () => {});
+            expect(output).toEqual({});
+        }
+        const output = { temperature: 0.4 };
+        applyHiddenSubagentTemperature({ agent: "build", model: no }, output, () => {});
+        expect(output.temperature).toBe(0.4);
+    });
+});
+
+describe("models.dev catalog fallback when the host is silent", () => {
+    test("resolves the cached catalog by provider and exact model id", () => {
+        writeCatalog();
+        const logs: string[] = [];
+        const note = (line: string) => logs.push(line);
+        // Pi and OpenCode 2 rows carry no temperature field.
+        const silent = { reasoning: true, compat: { thinkingFormat: "openrouter" } };
+        expect(subagentTemperature("openrouter/google/gemini-3.8-flash", silent, 0.1, note)).toBe(
+            0.1,
+        );
+        expect(subagentTemperature("google/gemini-3.8-flash", silent, 0, note)).toBe(0);
+        expect(subagentTemperature("opencode-zen/gemini-3.8-flash", silent, 0.1, note)).toBe(0.1);
+        expect(subagentTemperature("openai/gpt-6.1-sol", silent, 0.1, note)).toBeUndefined();
+        expect(
+            subagentTemperature("openrouter/openai/gpt-6.1-sol", silent, 0.1, note),
+        ).toBeUndefined();
+        expect(logs).toEqual([
+            "Subagent temperature sent for openrouter/google/gemini-3.8-flash: models.dev cache entry openrouter/google/gemini-3.8-flash says yes",
+            "Subagent temperature sent for google/gemini-3.8-flash: models.dev cache entry google/gemini-3.8-flash says yes",
+            "Subagent temperature sent for opencode-zen/gemini-3.8-flash: models.dev cache entry opencode/gemini-3.8-flash says yes",
+            "Subagent temperature omitted for openai/gpt-6.1-sol: models.dev cache entry openai/gpt-6.1-sol says no",
+            "Subagent temperature omitted for openrouter/openai/gpt-6.1-sol: models.dev cache entry openrouter/openai/gpt-6.1-sol says no",
+        ]);
+    });
+
+    test("both Antigravity spellings map to the underlying Gemini entry", () => {
+        writeCatalog();
+        for (const model of [
+            "google/antigravity-gemini-3.8-flash",
+            "google-antigravity/gemini-3.8-flash",
+            "google-antigravity/antigravity-gemini-3.8-flash",
+        ]) {
+            expect(resolveTemperatureCapability(model, {})).toEqual({
+                supported: true,
+                source: "catalog",
+                entry: "google/gemini-3.8-flash",
+            });
+        }
+        // The prefix is only an Antigravity spelling on Google, not a general rewrite.
+        expect(resolveTemperatureCapability("openrouter/antigravity-gemini-3.8-flash", {})).toEqual(
+            {
+                supported: undefined,
+                source: "none",
+            },
+        );
+    });
+
+    test("Codex and unmatched models stay unknown, so temperature is omitted", () => {
+        writeCatalog();
+        for (const model of [
+            "openai-codex/gpt-6.1-sol",
+            "google/gemini-3.8-flash-preview",
+            "google/claude-opus-4-6-thinking",
+            "broken/no-flag",
+            "unknown/unknown",
+            "no-slash",
+        ]) {
+            expect(resolveTemperatureCapability(model, undefined)).toEqual({
+                supported: undefined,
+                source: "none",
+            });
+            expect(subagentTemperature(model, undefined, 0.1, () => {})).toBeUndefined();
+        }
+    });
+
+    test("host metadata outranks the catalog in both directions", () => {
+        writeCatalog();
+        expect(
+            subagentTemperature(
+                "google/gemini-3.8-flash",
+                { capabilities: { temperature: false } },
+                0.1,
+                () => {},
+            ),
+        ).toBeUndefined();
+        expect(
+            subagentTemperature(
+                "openai/gpt-6.1-sol",
+                { compat: { supportsSamplingParams: true } },
+                0.1,
+                () => {},
+            ),
+        ).toBe(0.1);
+    });
+
+    test("a missing, empty or partially written catalog is not evidence", () => {
+        const silent = {};
+        expect(
+            subagentTemperature("google/gemini-3.8-flash", silent, 0.1, () => {}),
+        ).toBeUndefined();
+        writeCatalog(JSON.stringify(CATALOG).slice(0, 200));
+        expect(
+            subagentTemperature("google/gemini-3.8-flash", silent, 0.1, () => {}),
+        ).toBeUndefined();
+        writeCatalog("[]");
+        expect(
+            subagentTemperature("google/gemini-3.8-flash", silent, 0.1, () => {}),
+        ).toBeUndefined();
+    });
+
+    test("a rewritten catalog is re-read rather than served from memory", () => {
+        writeCatalog();
+        expect(resolveTemperatureCapability("google/gemini-3.8-flash", {}).supported).toBe(true);
+        writeCatalog(
+            JSON.stringify({
+                google: { models: { "gemini-3.8-flash": { temperature: false, note: "changed" } } },
+            }),
+        );
+        expect(resolveTemperatureCapability("google/gemini-3.8-flash", {}).supported).toBe(false);
+    });
+
+    test("OPENCODE_MODELS_PATH takes precedence over the cache, as it does for OpenCode", () => {
+        writeCatalog();
+        const override = join(cacheRoot, "override.json");
+        writeFileSync(
+            override,
+            JSON.stringify({ google: { models: { "gemini-3.8-flash": { temperature: false } } } }),
+        );
+        process.env.OPENCODE_MODELS_PATH = override;
+        expect(modelsDevCatalogPath()).toBe(override);
+        expect(resolveTemperatureCapability("google/gemini-3.8-flash", {}).supported).toBe(false);
+        delete process.env.OPENCODE_MODELS_PATH;
+        expect(modelsDevCatalogPath()).toBe(join(cacheRoot, "opencode", "models.json"));
+    });
+});