@cortexkit/opencode-magic-context 0.36.0 → 0.37.0

package/src/shared/tui-preferences.ts

@@ -250,6 +250,28 @@ export function queueTuiPreferenceUpdate(
 
 const WATCH_DEBOUNCE_MS = 150;
 
+type WatchReadFile = (file: string) => Promise<string>;
+type WatchDirectory = (
+    directory: string,
+    listener: (event: string, filename: string | null) => void,
+) => { close(): void };
+
+let watchReadFile: WatchReadFile = (file) => readFile(file, "utf8");
+let watchDirectory: WatchDirectory = (directory, listener) => watch(directory, listener);
+
+export function __setTuiPreferencesWatchTestHooks(hooks: {
+    readFile?: WatchReadFile;
+    watch?: WatchDirectory;
+}): void {
+    watchReadFile = hooks.readFile ?? ((file) => readFile(file, "utf8"));
+    watchDirectory = hooks.watch ?? ((directory, listener) => watch(directory, listener));
+}
+
+export function __resetTuiPreferencesWatchTestHooks(): void {
+    watchReadFile = (file) => readFile(file, "utf8");
+    watchDirectory = (directory, listener) => watch(directory, listener);
+}
+
 // Watches the DIRECTORY, not the file: editors and our own atomic writes replace
 // the file via rename, which kills file-level watchers.
 //
@@ -266,16 +288,22 @@ export function watchTuiPreferences(onChange: () => void): () => void {
     const name = basename(file);
     let timer: ReturnType<typeof setTimeout> | null = null;
     let lastSeen: string | null = null;
-    // Seed asynchronously; a real change before the seed resolves still wins
-    // because the debounce re-reads fresh and compares against `lastSeen` (null
-    // → does not match → fires).
-    void readFile(file, "utf8")
-        .then((text) => {
-            if (lastSeen === null) lastSeen = text;
-        })
-        .catch(() => {});
     try {
-        const watcher = watch(dirname(file), (_event, filename) => {
+        lastSeen = readFileSync(file, "utf8");
+    } catch {
+        // A missing or temporarily unreadable baseline is retried after registration.
+    }
+    const reconcile = (): void => {
+        void watchReadFile(file)
+            .catch(() => null)
+            .then((text) => {
+                if (text === null || text === lastSeen) return;
+                lastSeen = text;
+                onChange();
+            });
+    };
+    try {
+        const watcher = watchDirectory(dirname(file), (_event, filename) => {
             const isOurs =
                 filename === name ||
                 (filename?.startsWith(`${name}.`) && filename.endsWith(".tmp"));
@@ -283,16 +311,13 @@ export function watchTuiPreferences(onChange: () => void): () => void {
             if (timer) clearTimeout(timer);
             timer = setTimeout(() => {
                 timer = null;
-                void readFile(file, "utf8")
-                    .catch(() => null)
-                    .then((text) => {
-                        if (text === null) return;
-                        if (text === lastSeen) return;
-                        lastSeen = text;
-                        onChange();
-                    });
+                reconcile();
             }, WATCH_DEBOUNCE_MS);
         });
+        // Reconcile after registration: a change between the baseline read and
+        // watcher installation is observed here, while later changes schedule
+        // the same reconciliation path through the watcher callback above.
+        reconcile();
         return () => {
             if (timer) clearTimeout(timer);
             watcher.close();

package/src/shared/window-geometry.test.ts

@@ -0,0 +1,309 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { resolveLimit } from "./models-dev-cache";
+import {
+    deriveWindowGeometry,
+    formatWindowDerivationLine,
+    parseWindowOverlay,
+    placeholderFilteredOutput,
+    readWindowOverlayFile,
+    resolveWindowOverlayFacts,
+    scalarizeFact,
+    type WindowOverlay,
+    type WindowOverlayFact,
+} from "./window-geometry";
+
+const fixture = JSON.parse(
+    readFileSync(new URL("./__fixtures__/window-overlay.v1.json", import.meta.url), "utf8"),
+) as unknown;
+const parsedFixture = parseWindowOverlay(fixture).overlay as WindowOverlay;
+const tempDirs: string[] = [];
+
+function fact(
+    value: WindowOverlayFact["value"],
+    overrides: Partial<WindowOverlayFact> = {},
+): WindowOverlayFact {
+    return {
+        value,
+        grade: "measured",
+        units: "provider",
+        boundary: "Observed",
+        source_ref: "test",
+        observed_at: "2026-08-13T00:00:00Z",
+        ...overrides,
+    };
+}
+
+function overlay(
+    provider: string,
+    model: string,
+    facts: Record<string, WindowOverlayFact>,
+): WindowOverlay {
+    return {
+        schema: "fusiform-window-overlay/v1",
+        generated_at: "2026-08-13T00:00:00Z",
+        minted_provider_ids: [],
+        cells: [{ provider_id: provider, model_id: model, facts }],
+    };
+}
+
+afterEach(() => {
+    for (const path of tempDirs.splice(0)) rmSync(path, { recursive: true, force: true });
+});
+
+describe("Fusiform overlay v1", () => {
+    test("scalarizes every tagged union conservatively", () => {
+        expect(scalarizeFact({ kind: "stated", value: 272_000 })).toBe(272_000);
+        expect(scalarizeFact({ kind: "bracket", at_least: 340_000, below: 372_001 })).toBe(340_000);
+        expect(scalarizeFact({ kind: "bracket", below: 372_001 })).toBeUndefined();
+        expect(scalarizeFact({ kind: "unknown", why: "never_measured" })).toBeUndefined();
+    });
+
+    test("preserves a half-open bracket and derives exactly from at_least", () => {
+        const halfOpen = parseWindowOverlay({
+            schema: "fusiform-window-overlay/v1",
+            generated_at: "2026-08-13T00:00:00Z",
+            minted_provider_ids: [],
+            cells: [
+                {
+                    provider_id: "openai-chatgpt-oauth",
+                    model_id: "gpt-5.6-sol",
+                    facts: {
+                        "window.advertised": fact({ kind: "stated", value: 272_000 }),
+                        "window.enforced": fact({ kind: "bracket", at_least: 340_000 }),
+                    },
+                },
+            ],
+        }).overlay;
+        const parsedValue = halfOpen?.cells[0]?.facts["window.enforced"]?.value;
+        expect(parsedValue).toEqual({ kind: "bracket", at_least: 340_000 });
+        expect(parsedValue && "below" in parsedValue).toBe(false);
+        const halfOpenResult = deriveWindowGeometry(
+            "openai-chatgpt-oauth",
+            "gpt-5.6-sol",
+            { context: 272_000, output: 128_000 },
+            {
+                overlay: resolveWindowOverlayFacts("openai-chatgpt-oauth", "gpt-5.6-sol", halfOpen),
+            },
+        );
+        const statedResult = deriveWindowGeometry(
+            "openai-chatgpt-oauth",
+            "gpt-5.6-sol",
+            { context: 272_000, output: 128_000 },
+            {
+                overlay: resolveWindowOverlayFacts(
+                    "openai-chatgpt-oauth",
+                    "gpt-5.6-sol",
+                    overlay("openai-chatgpt-oauth", "gpt-5.6-sol", {
+                        "window.enforced": fact({ kind: "stated", value: 340_000 }),
+                    }),
+                ),
+            },
+        );
+        expect(halfOpenResult).toEqual(statedResult);
+    });
+
+    test("specific cells override wildcard facts per fact", () => {
+        const data: WindowOverlay = {
+            schema: "fusiform-window-overlay/v1",
+            generated_at: "2026-08-13T00:00:00Z",
+            minted_provider_ids: [],
+            cells: [
+                {
+                    provider_id: "ollama-cloud",
+                    model_id: "*",
+                    facts: {
+                        "output.enforced": fact({ kind: "stated", value: 65_536 }),
+                        geometry: fact({ kind: "stated", value: "shared_upfront" }),
+                    },
+                },
+                {
+                    provider_id: "ollama-cloud",
+                    model_id: "deepseek-v4",
+                    facts: {
+                        "output.enforced": fact({ kind: "stated", value: 32_000 }),
+                    },
+                },
+            ],
+        };
+        const facts = resolveWindowOverlayFacts("ollama-cloud", "deepseek-v4", data)?.facts;
+        expect(scalarizeFact(facts?.["output.enforced"]?.value as never)).toBe(32_000);
+        expect(facts?.geometry?.value).toEqual({ kind: "stated", value: "shared_upfront" });
+    });
+
+    test("refuses an unrecognized schema before considering familiar cells", () => {
+        const v2 = {
+            ...(fixture as Record<string, unknown>),
+            schema: "fusiform-window-overlay/v2",
+        };
+        const parsed = parseWindowOverlay(v2);
+        expect(parsed.overlay).toBeUndefined();
+        expect(parsed.refusal).toContain("unrecognized schema");
+    });
+
+    test("skips bad cells once and keeps valid cells", () => {
+        const badCell = {
+            provider_id: "bad",
+            model_id: "model",
+            facts: { "window.enforced": { value: { kind: "stated", value: 1_000_000 } } },
+        };
+        const parsed = parseWindowOverlay({
+            ...(fixture as Record<string, unknown>),
+            cells: [badCell, ...(fixture as { cells: unknown[] }).cells],
+        });
+        expect(parsed.badCells).toBe(1);
+        expect(parsed.overlay?.cells.length).toBe(parsedFixture.cells.length);
+    });
+
+    test("a missing file is silent and a bad file logs one summary", () => {
+        const dir = mkdtempSync(join(tmpdir(), "window-overlay-test-"));
+        tempDirs.push(dir);
+        const logs: string[] = [];
+        expect(
+            readWindowOverlayFile(join(dir, "missing.json"), (message) => logs.push(message)),
+        ).toBeUndefined();
+        expect(logs).toEqual([]);
+        const path = join(dir, "bad.json");
+        writeFileSync(path, JSON.stringify({ ...(fixture as object), schema: "v2" }));
+        expect(readWindowOverlayFile(path, (message) => logs.push(message))).toBeUndefined();
+        expect(logs).toHaveLength(1);
+    });
+});
+
+describe("window geometry", () => {
+    test("filters placeholders independently in both directions", () => {
+        expect(placeholderFilteredOutput(0, 1_000_000)).toBeUndefined();
+        expect(placeholderFilteredOutput(1_000_000, 1_000_000)).toBeUndefined();
+        expect(placeholderFilteredOutput(1_000_001, 1_000_000)).toBeUndefined();
+        expect(placeholderFilteredOutput(65_536, 1_000_000)).toBe(65_536);
+        expect(
+            deriveWindowGeometry("xai", "mixed", {
+                context: 500_000,
+                input: 300_000,
+                output: 500_000,
+            })?.usableSoft,
+        ).toBe(300_000);
+    });
+
+    test("fixture table yields the 65% execution bases from the spec", () => {
+        const cases = [
+            ["openai-chatgpt-oauth", "gpt-5.6", 272_000, 128_000, 200_200],
+            ["anthropic", "claude-opus-5", 1_000_000, 128_000, 629_200],
+            // Producer batch downgraded google's geometry to considered-unknown
+            // (Google's docs contradict the separate-quota reading), so the
+            // derivation demotes to shared_upfront and reserves OpenCode's
+            // actual request cap B = min(65_536, 32_000):
+            // floor(0.65 * (1_048_576 - 32_000)) — not the no-reserve 681_574.
+            ["google", "gemini-3.5-flash", 1_048_576, 65_536, 660_774],
+            ["xai", "grok-4.6", 500_000, 500_000, 304_200],
+            ["ollama-cloud", "deepseek-v4-flash", 1_048_576, 384_000, 660_774],
+            ["moonshotai", "kimi-k3", 1_048_576, 1_048_576, 660_774],
+        ] as const;
+        for (const [provider, model, context, output, expectedExecute] of cases) {
+            const result = deriveWindowGeometry(
+                provider,
+                model,
+                { context, output },
+                {
+                    overlay: resolveWindowOverlayFacts(provider, model, parsedFixture),
+                },
+            );
+            expect(Math.floor((result?.usableSoft ?? 0) * 0.65)).toBe(expectedExecute);
+        }
+    });
+
+    test("grok derives from geometry, window, and default output without an enforced output", () => {
+        const facts = resolveWindowOverlayFacts("xai", "grok-4.6", parsedFixture);
+        expect(facts?.facts["output.enforced"]).toBeUndefined();
+        const result = deriveWindowGeometry(
+            "xai",
+            "grok-4.6",
+            { context: 500_000, output: 500_000 },
+            { overlay: facts },
+        );
+        expect(result?.geometry).toBe("shared_truncating");
+        expect(result?.usableSoft).toBe(468_000);
+    });
+
+    test("kimi reserves its default output instead of placeholder advertised output", () => {
+        const result = deriveWindowGeometry(
+            "moonshotai",
+            "kimi-k3",
+            { context: 1_048_576, output: 1_048_576 },
+            {
+                overlay: resolveWindowOverlayFacts("moonshotai", "kimi-k3", parsedFixture),
+            },
+        );
+        expect(result?.derivation.reserve).toBe(32_000);
+        expect(result?.usableSoft).toBe(1_016_576);
+    });
+
+    test("provider hook wins over overlay, while overlay beats catalog", () => {
+        const data = overlay("provider", "model", {
+            "window.enforced": fact({ kind: "stated", value: 300_000 }),
+            "output.enforced": fact({ kind: "stated", value: 20_000 }),
+        });
+        const overlayOnly = deriveWindowGeometry(
+            "provider",
+            "model",
+            { context: 200_000, output: 10_000 },
+            { overlay: resolveWindowOverlayFacts("provider", "model", data) },
+        );
+        const hooked = deriveWindowGeometry(
+            "provider",
+            "model",
+            { context: 200_000, output: 10_000 },
+            {
+                overlay: resolveWindowOverlayFacts("provider", "model", data),
+                providerLimit: { context: 400_000, output: 30_000 },
+            },
+        );
+        expect(overlayOnly?.derivation.window).toBe(300_000);
+        expect(hooked?.derivation.window).toBe(400_000);
+        expect(hooked?.derivation.reserve).toBe(30_000);
+    });
+
+    test("clamps an inversion and logs it", () => {
+        const logs: string[] = [];
+        const result = deriveWindowGeometry(
+            "provider",
+            "model",
+            { context: 200_000, input: 190_000, output: 10_000 },
+            {
+                providerLimit: { context: 192_000, input: 190_000, output: 10_000 },
+                log: (message) => logs.push(message),
+            },
+        );
+        expect(result?.usableHard).toBe(result?.usableSoft);
+        expect(logs).toHaveLength(1);
+        expect(logs[0]).toContain("clamped");
+    });
+
+    test("keeps no-overlay usableSoft byte-identical to legacy resolveLimit", () => {
+        const corpus = [
+            ["openai", "real", { context: 200_000, output: 32_000 }],
+            ["openai", "zero", { context: 200_000, output: 0 }],
+            ["xai", "placeholder", { context: 500_000, output: 500_000 }],
+            ["google", "separate", { context: 1_000_000, output: 65_536 }],
+            ["anthropic", "input", { context: 1_000_000, input: 900_000, output: 128_000 }],
+        ] as const;
+        for (const [provider, model, limit] of corpus) {
+            const result = deriveWindowGeometry(provider, model, limit);
+            expect(result?.usableSoft).toBe(resolveLimit(limit, provider, model));
+        }
+    });
+
+    test("display percentage uses the same usableSoft scheduler base", () => {
+        const result = deriveWindowGeometry("openai", "model", {
+            context: 204_000,
+            output: 30_600,
+        }) as NonNullable<ReturnType<typeof deriveWindowGeometry>>;
+        const input = 105_900;
+        const schedulerPercentage = (input / result.usableSoft) * 100;
+        expect(formatWindowDerivationLine(input, result)).toContain(
+            `(${schedulerPercentage.toFixed(1)}%)`,
+        );
+    });
+});