@cortexkit/opencode-magic-context 0.47.0 → 0.49.0

package/src/shared/stable-json-linear.test.ts

@@ -0,0 +1,109 @@
+/// <reference types="bun-types" />
+
+import { describe, expect, it } from "bun:test";
+import { stableStringify } from "./stable-json";
+
+/** stableStringify as it was before it collected pieces: joins at every level. */
+function frozenStableStringify(value: unknown, seen = new WeakSet<object>()): string {
+    if (value === undefined) return "undefined";
+    if (value === null || typeof value !== "object") return JSON.stringify(value) ?? String(value);
+    if (seen.has(value)) return '"[Circular]"';
+    seen.add(value);
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => frozenStableStringify(item, seen)).join(",")}]`;
+    }
+    const entries = Object.entries(value as Record<string, unknown>).sort(([a], [b]) => {
+        if (a < b) return -1;
+        if (a > b) return 1;
+        return 0;
+    });
+    return `{${entries
+        .map(([key, child]) => `${JSON.stringify(key)}:${frozenStableStringify(child, seen)}`)
+        .join(",")}}`;
+}
+
+function rng(seed: number): () => number {
+    let state = seed >>> 0 || 1;
+    return () => {
+        state ^= state << 13;
+        state >>>= 0;
+        state ^= state >>> 17;
+        state ^= state << 5;
+        state >>>= 0;
+        return state / 0x100000000;
+    };
+}
+
+function randomValue(random: () => number, depth: number, shared: object[]): unknown {
+    const roll = random();
+    if (depth > 4 || roll < 0.35) {
+        const leaves: unknown[] = [
+            "plain",
+            'quote " and \\ backslash',
+            "ünï 日本 😀 \u2028",
+            0,
+            -0,
+            1.5,
+            Number.NaN,
+            Number.POSITIVE_INFINITY,
+            true,
+            false,
+            null,
+            undefined,
+            () => 1,
+            Symbol("s"),
+        ];
+        return leaves[Math.floor(random() * leaves.length)];
+    }
+    if (roll < 0.45 && shared.length > 0) return shared[Math.floor(random() * shared.length)];
+    if (roll < 0.7) {
+        const array: unknown[] = [];
+        const length = Math.floor(random() * 5);
+        for (let index = 0; index < length; index += 1) {
+            if (random() < 0.15) continue; // leaves a hole
+            array[index] = randomValue(random, depth + 1, shared);
+        }
+        array.length = length;
+        if (random() < 0.2) shared.push(array);
+        return array;
+    }
+    const object: Record<string, unknown> = {};
+    for (let index = Math.floor(random() * 5); index > 0; index -= 1) {
+        const key = ["b", "a", "10", "2", "é", "Z", "key with space"][
+            Math.floor(random() * 7)
+        ] as string;
+        object[key] = randomValue(random, depth + 1, shared);
+    }
+    if (random() < 0.2) shared.push(object);
+    if (random() < 0.1) object.self = object;
+    return object;
+}
+
+describe("stableStringify", () => {
+    it("writes exactly what it wrote when it joined at every level", () => {
+        const random = rng(653);
+        let circular = 0;
+        let holes = 0;
+        for (let sample = 0; sample < 2_000; sample += 1) {
+            const value = randomValue(random, 0, []);
+            const text = stableStringify(value);
+            expect(text).toBe(frozenStableStringify(value));
+            if (text.includes('"[Circular]"')) circular += 1;
+            if (/\[,|,,|,\]/.test(text)) holes += 1;
+        }
+        // Shared and cyclic references and array holes were among the samples.
+        expect(circular).toBeGreaterThan(50);
+        expect(holes).toBeGreaterThan(50);
+    });
+
+    it("copies a deeply nested value once, not once per level", () => {
+        // 3,000 levels around a 2 MB string: joining at every level copied about
+        // 6 GB of text (over a second); one copy takes a few milliseconds.
+        let node: unknown = { body: "x".repeat(2_000_000) };
+        for (let depth = 0; depth < 3_000; depth += 1) node = { child: node, depth };
+        const started = performance.now();
+        const text = stableStringify(node);
+        expect(text.length).toBeGreaterThan(2_000_000);
+        expect(performance.now() - started).toBeLessThan(300);
+    }, 30_000);
+});

package/src/shared/stable-json.ts

@@ -18,12 +18,38 @@
  * signing), build a separate utility — do NOT widen this contract.
  */
 export function stableStringify(value: unknown, seen = new WeakSet<object>()): string {
-    if (value === undefined) return "undefined";
-    if (value === null || typeof value !== "object") return JSON.stringify(value) ?? String(value);
-    if (seen.has(value)) return '"[Circular]"';
+    // Collect pieces and join once. Joining at every level copied each nested
+    // value's text once per enclosing level, so a large value N levels deep cost
+    // N copies of itself.
+    const pieces: string[] = [];
+    writeStable(value, seen, pieces);
+    return pieces.join("");
+}
+
+function writeStable(value: unknown, seen: WeakSet<object>, pieces: string[]): void {
+    if (value === undefined) {
+        pieces.push("undefined");
+        return;
+    }
+    if (value === null || typeof value !== "object") {
+        pieces.push(JSON.stringify(value) ?? String(value));
+        return;
+    }
+    // Any object met a second time, shared or cyclic, is written as "[Circular]".
+    if (seen.has(value)) {
+        pieces.push('"[Circular]"');
+        return;
+    }
     seen.add(value);
     if (Array.isArray(value)) {
-        return `[${value.map((item) => stableStringify(item, seen)).join(",")}]`;
+        pieces.push("[");
+        for (let index = 0; index < value.length; index += 1) {
+            if (index > 0) pieces.push(",");
+            // A hole writes nothing between its commas, as joining a mapped array did.
+            if (index in value) writeStable(value[index], seen, pieces);
+        }
+        pieces.push("]");
+        return;
     }
     // Code-point sort (NOT localeCompare). Stable across runtimes/locales.
     const entries = Object.entries(value as Record<string, unknown>).sort(([a], [b]) => {
@@ -31,7 +57,11 @@ export function stableStringify(value: unknown, seen = new WeakSet<object>()): s
         if (a > b) return 1;
         return 0;
     });
-    return `{${entries
-        .map(([key, child]) => `${JSON.stringify(key)}:${stableStringify(child, seen)}`)
-        .join(",")}}`;
+    pieces.push("{");
+    entries.forEach(([key, child], index) => {
+        if (index > 0) pieces.push(",");
+        pieces.push(JSON.stringify(key), ":");
+        writeStable(child, seen, pieces);
+    });
+    pieces.push("}");
 }

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"));
+    });
+});

package/src/shared/subagent-temperature.ts

@@ -0,0 +1,110 @@
+import { __catalogTest, catalogTemperature } from "./models-dev-temperature";
+
+export type TemperatureMetadata = {
+    temperature?: boolean;
+    capabilities?: { temperature?: boolean };
+    compat?: { supportsTemperature?: boolean; supportsSamplingParams?: boolean };
+};
+
+const loggedDecisions = new Set<string>();
+
+export function temperatureCapability(metadata: unknown): boolean | undefined {
+    if (!metadata || typeof metadata !== "object") return undefined;
+    const model = metadata as TemperatureMetadata;
+    const supported =
+        model.capabilities?.temperature ??
+        model.temperature ??
+        model.compat?.supportsTemperature ??
+        model.compat?.supportsSamplingParams;
+    return typeof supported === "boolean" ? supported : undefined;
+}
+
+/**
+ * Where a temperature decision came from: the host's own model metadata, the models.dev
+ * catalog OpenCode caches on disk, or nothing (which omits temperature).
+ */
+export type TemperatureSource = "host" | "catalog" | "none";
+
+export interface TemperatureDecision {
+    supported: boolean | undefined;
+    source: TemperatureSource;
+    /** The models.dev entry (`provider/model`) when the catalog decided. */
+    entry?: string;
+}
+
+/**
+ * Host metadata wins whenever it states a boolean. Only when the host is silent do we
+ * consult the cached models.dev catalog, matched by provider and model id.
+ */
+export function resolveTemperatureCapability(
+    model: string,
+    metadata: unknown,
+): TemperatureDecision {
+    const host = temperatureCapability(metadata);
+    if (host !== undefined) return { supported: host, source: "host" };
+    const catalog = catalogTemperature(model);
+    if (catalog) return { supported: catalog.temperature, source: "catalog", entry: catalog.entry };
+    return { supported: undefined, source: "none" };
+}
+
+export function describeTemperatureDecision(model: string, decision: TemperatureDecision): string {
+    const verdict = decision.supported === true ? "sent" : "omitted";
+    const answer = decision.supported === true ? "yes" : "no";
+    const reason =
+        decision.source === "host"
+            ? `host model metadata says ${answer}`
+            : decision.source === "catalog"
+              ? `models.dev cache entry ${decision.entry ?? "unknown"} says ${answer}`
+              : "no host or models.dev metadata";
+    return `Subagent temperature ${verdict} for ${model}: ${reason}`;
+}
+
+/** Log each model's decision once per process, and again only if the decision changes. */
+export function logTemperatureDecision(
+    model: string,
+    decision: TemperatureDecision,
+    log: (message: string, decision: TemperatureDecision) => void,
+): void {
+    const key = `${model}\u0000${decision.source}\u0000${decision.supported}\u0000${decision.entry ?? ""}`;
+    if (loggedDecisions.has(key)) return;
+    loggedDecisions.add(key);
+    log(describeTemperatureDecision(model, decision), decision);
+}
+
+/** Only a positive capability permits sampling; reasoning alone is not evidence. */
+export function subagentTemperature(
+    model: string,
+    metadata: unknown,
+    temperature: number | undefined,
+    log: (message: string, decision: TemperatureDecision) => void,
+): number | undefined {
+    if (temperature === undefined) return undefined;
+    const decision = resolveTemperatureCapability(model, metadata);
+    logTemperatureDecision(model, decision, log);
+    return decision.supported === true ? temperature : undefined;
+}
+
+/** OpenCode 1 computes agent sampling before chat.params resolves the final model. */
+export function applyHiddenSubagentTemperature(
+    input: { agent: string; model?: TemperatureMetadata & { providerID?: string; id?: string } },
+    output: { temperature?: number },
+    log: (message: string) => void,
+): void {
+    if (!/^(?:historian(?:-|$)|dreamer(?:-|$)|smart-note-compiler$)/.test(input.agent)) return;
+    const temperature = subagentTemperature(
+        `${input.model?.providerID ?? "unknown"}/${input.model?.id ?? "unknown"}`,
+        input.model,
+        output.temperature,
+        // Host loggers treat a second argument as structured data; the message says it all.
+        (message) => log(message),
+    );
+    if (temperature === undefined) delete output.temperature;
+    else output.temperature = temperature;
+}
+
+export const __temperatureTest = {
+    reset(): void {
+        loggedDecisions.clear();
+        __catalogTest.reset();
+    },
+};

package/src/shared/user-facing-codes.ts

@@ -245,12 +245,8 @@ export const USER_FACING_FAILURES = {
         sentence: "Magic Context has no context.db.",
         action: "Run `npx @cortexkit/magic-context doctor store init`, then restart ck-mc.",
     },
-    checkout_claim_held_elsewhere: {
-        code: "MC-C16",
-        sentence:
-            "This request was not sent: this agent is checked out on another machine, so Magic Context will not work on its sessions here.",
-        action: "Move the agent back to this machine, then send your message again.",
-    },
+    // MC-C16 is retired: released builds showed it when a turn was refused because
+    // another machine held the session's agent. Do not reuse it for a new failure.
     single_store_migration_required: {
         code: "MC-C14",
         sentence: "Magic Context's Rust mode needs a one-time migration of its store.",

package/src/shared/write-transaction-attribution.test.ts

@@ -87,7 +87,7 @@ const fencedSources: Array<{ path: string; sites: string[]; reporterCalls?: stri
     },
     {
         path: "packages/pi-plugin/src/context-handler.ts",
-        sites: ["pi_compaction_queue"],
+        sites: ["pi_fallback_adoption"],
     },
 ];
 
@@ -149,7 +149,7 @@ const newlyCoveredSites = [
     "pi_materialize_cache",
     "pi_soft_refresh_cache",
     "pi_historian_publish",
-    "pi_compaction_queue",
+    "pi_fallback_adoption",
     "note_nudge_trigger",
     "user_memory_candidate_insert",
 ] as const;