@cortexkit/opencode-magic-context 0.36.1 → 0.37.0

package/src/shared/rpc-utils.ts

@@ -50,13 +50,22 @@ export function legacyRpcPortFilePath(storageDir: string, directory: string): st
     return join(rpcPortDir(storageDir, directory), "port");
 }
 
-export function isPidAlive(pid: number): boolean {
-    if (!Number.isInteger(pid) || pid <= 0) return false;
+export type PidLiveness = "alive" | "dead" | "inconclusive";
+
+/**
+ * Check whether the platform confirms a PID is live without treating a denied
+ * probe as confirmation. Windows uses tasklist because MSYS2/Cygwin ps does not
+ * support the options used by the Unix probe. Sandboxes commonly reject
+ * `kill(pid, 0)` with EPERM even when the PID does not exist outside their view.
+ */
+export function isPidAlive(pid: number): PidLiveness {
+    if (!Number.isInteger(pid) || pid <= 0) return "dead";
+    if (rpcIdentityPlatform === "win32") return readWindowsProcess(pid).state;
     try {
-        process.kill(pid, 0);
-        return true;
-    } catch (err) {
-        return (err as NodeJS.ErrnoException).code === "EPERM";
+        rpcIdentityProcessKill(pid, 0);
+        return "alive";
+    } catch (error) {
+        return (error as NodeJS.ErrnoException).code === "ESRCH" ? "dead" : "inconclusive";
     }
 }
 
@@ -64,9 +73,12 @@ const RPC_IDENTITY_SKEW_TOLERANCE_MS = 120_000;
 const LINUX_CLOCK_TICKS_PER_SECOND = 100;
 const PS_PROBE_TIMEOUT_MS = 1_000;
 const OPEN_CODE_COMMAND_MARKERS = ["opencode", "node", "bun", "electron"];
+const TASKLIST_NO_TASKS_PATTERN =
+    /^INFO:\s+No tasks are running which match the specified criteria\.?$/im;
 
 let rpcIdentityReadFileSync: typeof readFileSync = readFileSync;
 let rpcIdentityExecFileSync: typeof execFileSync = execFileSync;
+let rpcIdentityProcessKill: typeof process.kill = process.kill;
 let rpcProcessListExecFileSync: typeof execFileSync = execFileSync;
 let rpcProcessListTestOverride = false;
 let rpcIdentityPlatform: NodeJS.Platform = process.platform;
@@ -116,6 +128,7 @@ function readPsProcessStartTime(pid: number): number | null {
         const output = rpcIdentityExecFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
             encoding: "utf8",
             timeout: PS_PROBE_TIMEOUT_MS,
+            stdio: ["ignore", "pipe", "pipe"],
         });
         const processStartTime = Date.parse(String(output).trim());
         return Number.isFinite(processStartTime) ? processStartTime : null;
@@ -124,6 +137,72 @@ function readPsProcessStartTime(pid: number): number | null {
     }
 }
 
+interface ProcessListEntry {
+    pid: number;
+    command: string;
+}
+
+function parseCsvLine(line: string): string[] | null {
+    const fields: string[] = [];
+    let field = "";
+    let quoted = false;
+    for (let index = 0; index < line.length; index += 1) {
+        const character = line[index];
+        if (character === '"') {
+            if (quoted && line[index + 1] === '"') {
+                field += '"';
+                index += 1;
+            } else {
+                quoted = !quoted;
+            }
+        } else if (character === "," && !quoted) {
+            fields.push(field);
+            field = "";
+        } else {
+            field += character;
+        }
+    }
+    if (quoted) return null;
+    fields.push(field);
+    return fields;
+}
+
+function parseTasklistOutput(output: string): ProcessListEntry[] | null {
+    const entries: ProcessListEntry[] = [];
+    let sawHeader = false;
+    for (const rawLine of output.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line) continue;
+        if (TASKLIST_NO_TASKS_PATTERN.test(line)) return [];
+        const fields = parseCsvLine(line);
+        if (!fields) continue;
+        if (fields[1]?.trim().toLowerCase() === "pid") {
+            sawHeader = true;
+            continue;
+        }
+        const pid = Number(fields[1]);
+        if (!Number.isInteger(pid) || pid <= 0 || !fields[0]) continue;
+        entries.push({ pid, command: fields[0] });
+    }
+    return entries.length > 0 || sawHeader ? entries : null;
+}
+
+function readWindowsProcess(pid: number): { state: PidLiveness; command?: string } {
+    try {
+        const output = rpcIdentityExecFileSync("tasklist", ["/FO", "CSV", "/FI", `PID eq ${pid}`], {
+            encoding: "utf8",
+            timeout: PS_PROBE_TIMEOUT_MS,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const entries = parseTasklistOutput(String(output));
+        if (entries === null) return { state: "inconclusive" };
+        const process = entries.find((entry) => entry.pid === pid);
+        return process ? { state: "alive", command: process.command } : { state: "dead" };
+    } catch {
+        return { state: "inconclusive" };
+    }
+}
+
 function readLinuxProcessCommand(pid: number): string | null {
     try {
         return String(rpcIdentityReadFileSync(`/proc/${pid}/cmdline`, "utf8"));
@@ -137,6 +216,7 @@ function readPsProcessCommand(pid: number): string | null {
         const output = rpcIdentityExecFileSync("ps", ["-p", String(pid), "-o", "command="], {
             encoding: "utf8",
             timeout: PS_PROBE_TIMEOUT_MS,
+            stdio: ["ignore", "pipe", "pipe"],
         });
         return String(output);
     } catch {
@@ -153,40 +233,51 @@ function commandLooksLikeOpenCode(command: string): boolean {
  * Verify that a live PID still belongs to the process that wrote a port record.
  *
  * A PID can be reused after its original process exits. On Linux, procfs gives
- * us a process start time without spawning a helper; other platforms use `ps`
- * only on this cold database-open guard path. Legacy records without a start
- * time use a weaker command-name check, and every probe failure stays live so
- * this identity check cannot weaken the migration guard on uncertainty.
+ * us a process start time without spawning a helper; macOS and other Unix-like
+ * platforms use `ps`, while Windows uses `tasklist`, only on this cold
+ * database-open guard path. Legacy records without a start time use a weaker
+ * command-name check. A failed filesystem or process probe is inconclusive,
+ * not proof that this port record still belongs to OpenCode.
  */
-export function isPidIdentityPlausible(record: RpcPortFileRecord): boolean {
-    if (!Number.isInteger(record.pid) || record.pid <= 0) return false;
+export type PidIdentityPlausibility = "plausible" | "implausible" | "inconclusive";
+
+export function isPidIdentityPlausible(record: RpcPortFileRecord): PidIdentityPlausibility {
+    if (!Number.isInteger(record.pid) || record.pid <= 0) return "implausible";
 
     if (Number.isFinite(record.started_at) && record.started_at > 0) {
         const processStartTime =
             rpcIdentityPlatform === "linux"
                 ? readLinuxProcessStartTime(record.pid)
-                : readPsProcessStartTime(record.pid);
-        if (processStartTime === null) return true;
-        return processStartTime <= record.started_at + RPC_IDENTITY_SKEW_TOLERANCE_MS;
+                : rpcIdentityPlatform === "win32"
+                  ? null
+                  : readPsProcessStartTime(record.pid);
+        if (processStartTime === null) return "inconclusive";
+        return processStartTime <= record.started_at + RPC_IDENTITY_SKEW_TOLERANCE_MS
+            ? "plausible"
+            : "implausible";
     }
 
     const command =
         rpcIdentityPlatform === "linux"
             ? readLinuxProcessCommand(record.pid)
-            : readPsProcessCommand(record.pid);
-    if (command === null) return true;
-    return commandLooksLikeOpenCode(command);
+            : rpcIdentityPlatform === "win32"
+              ? (readWindowsProcess(record.pid).command ?? null)
+              : readPsProcessCommand(record.pid);
+    if (command === null) return "inconclusive";
+    return commandLooksLikeOpenCode(command) ? "plausible" : "implausible";
 }
 
 export function __setRpcIdentityTestHooks(hooks: {
     readFileSync?: typeof readFileSync;
     execFileSync?: typeof execFileSync;
+    processKill?: typeof process.kill;
     processListExecFileSync?: typeof execFileSync;
     platform?: NodeJS.Platform;
     nowMs?: () => number;
 }): void {
     rpcIdentityReadFileSync = hooks.readFileSync ?? readFileSync;
     rpcIdentityExecFileSync = hooks.execFileSync ?? execFileSync;
+    rpcIdentityProcessKill = hooks.processKill ?? process.kill;
     rpcProcessListExecFileSync = hooks.processListExecFileSync ?? execFileSync;
     rpcProcessListTestOverride = hooks.processListExecFileSync !== undefined;
     rpcIdentityPlatform = hooks.platform ?? process.platform;
@@ -196,6 +287,7 @@ export function __setRpcIdentityTestHooks(hooks: {
 export function __resetRpcIdentityTestHooks(): void {
     rpcIdentityReadFileSync = readFileSync;
     rpcIdentityExecFileSync = execFileSync;
+    rpcIdentityProcessKill = process.kill;
     rpcProcessListExecFileSync = execFileSync;
     rpcProcessListTestOverride = false;
     rpcIdentityPlatform = process.platform;
@@ -228,28 +320,49 @@ export interface PiProcessDiscovery {
 
 /**
  * Inspect Pi/OMP processes without converting a failed process-list probe into
- * false evidence that no harness is running. Destructive maintenance callers
- * use the unreadable state to fail closed; ordinary migration guards retain
- * their historical best-effort process list through discoverLivePiProcessIds().
+ * false evidence that no harness is running. Callers choose their own policy
+ * for the unreadable state: destructive maintenance can fail closed, while a
+ * migration guard can proceed after reporting that no live Pi process was confirmed.
  */
 export function inspectLivePiProcesses(): PiProcessDiscovery {
     if (process.env.NODE_ENV === "test" && !rpcProcessListTestOverride) {
         return { state: "known", processIds: [] };
     }
     try {
+        const isWindows = rpcIdentityPlatform === "win32";
         const output = String(
-            rpcProcessListExecFileSync("ps", ["-axo", "pid=,command="], {
-                encoding: "utf8",
-                timeout: PS_PROBE_TIMEOUT_MS,
-            }),
+            rpcProcessListExecFileSync(
+                isWindows ? "tasklist" : "ps",
+                isWindows ? ["/FO", "CSV"] : ["-axo", "pid=,command="],
+                {
+                    encoding: "utf8",
+                    timeout: PS_PROBE_TIMEOUT_MS,
+                    stdio: ["ignore", "pipe", "pipe"],
+                },
+            ),
         );
         const pids = new Set<number>();
-        for (const line of output.split(/\r?\n/)) {
-            const match = /^\s*(\d+)\s+(.+)$/.exec(line);
-            if (!match) continue;
-            const pid = Number(match[1]);
-            if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid) continue;
-            if (commandLooksLikePi(match[2])) pids.add(pid);
+        if (isWindows) {
+            const entries = parseTasklistOutput(output);
+            if (entries === null) {
+                return {
+                    state: "unreadable",
+                    processIds: [],
+                    error: "tasklist output unavailable",
+                };
+            }
+            for (const entry of entries) {
+                if (entry.pid === process.pid) continue;
+                if (commandLooksLikePi(entry.command)) pids.add(entry.pid);
+            }
+        } else {
+            for (const line of output.split(/\r?\n/)) {
+                const match = /^\s*(\d+)\s+(.+)$/.exec(line);
+                if (!match) continue;
+                const pid = Number(match[1]);
+                if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid) continue;
+                if (commandLooksLikePi(match[2])) pids.add(pid);
+            }
         }
         return { state: "known", processIds: [...pids].sort((left, right) => left - right) };
     } catch (error) {

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)}%)`,
+        );
+    });
+});