@cortexkit/opencode-magic-context 0.36.1 → 0.37.0

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

@@ -30,9 +30,15 @@ import { join } from "node:path";
 import type { ContextLimitProvenance } from "./context-limit-provenance";
 import { getMagicContextStorageDir } from "./data-path";
 import { getHarness } from "./harness";
-import { piModelRefToCanonical } from "./harness-provider-map";
+import { modelRefLookupOrder } from "./harness-provider-map";
 import { sessionLog } from "./logger";
 import { shouldEnforcePrivateStoragePermissions } from "./storage-permissions";
+import {
+    deriveWindowGeometry,
+    getWindowOverlay,
+    resolveWindowOverlayFacts,
+    type WindowGeometryResult,
+} from "./window-geometry";
 
 interface OpencodeClientLike {
     config: {
@@ -196,14 +202,11 @@ function isFinitePositive(value: number | undefined): value is number {
 }
 
 function modelKeyLookupOrder(providerID: string, modelID: string): string[] {
-    const full = `${providerID}/${modelID}`;
-    const canonicalFull = piModelRefToCanonical(full);
-    const candidates = [full, canonicalFull, modelID];
+    const candidates = [...modelRefLookupOrder(`${providerID}/${modelID}`), modelID];
     const colon = modelID.lastIndexOf(":");
     if (colon > 0) {
         const bareModel = modelID.slice(0, colon);
-        const providerBare = `${providerID}/${bareModel}`;
-        candidates.push(providerBare, piModelRefToCanonical(providerBare), bareModel);
+        candidates.push(...modelRefLookupOrder(`${providerID}/${bareModel}`), bareModel);
     }
     return [...new Set(candidates)];
 }
@@ -493,6 +496,50 @@ async function refreshModelLimitsOnce(client: OpencodeClientLike): Promise<boole
  * `ctx.model.contextWindow`), so for Pi this returns `undefined` and Pi's
  * own resolution path is used.
  */
+export function getSdkWindowGeometry(
+    providerID: string,
+    modelID: string,
+    detectedContextLimit?: number,
+    options?: {
+        detectedLimitProvenance?: ContextLimitProvenance;
+        harness?: "opencode" | "pi";
+    },
+): WindowGeometryResult | undefined {
+    loadPersistedApiCacheOnce();
+    const metadata = lookupMetadataWithTagFallback(apiCache, providerID, modelID);
+    if (!metadata) return undefined;
+    const rawContext = metadata.contextLimit ?? metadata.limit;
+    const promptOnlyDetected =
+        options?.detectedLimitProvenance === "prompt_only" && isFinitePositive(detectedContextLimit)
+            ? detectedContextLimit
+            : undefined;
+    const result = deriveWindowGeometry(
+        providerID,
+        modelID,
+        {
+            context: rawContext,
+            input: metadata.inputLimit,
+            output: metadata.outputLimit,
+        },
+        {
+            overlay: resolveWindowOverlayFacts(providerID, modelID, getWindowOverlay()),
+            reserveConfig: outputReserveConfig,
+            harness: options?.harness ?? "opencode",
+            contextCap:
+                promptOnlyDetected === undefined && isFinitePositive(detectedContextLimit)
+                    ? detectedContextLimit
+                    : undefined,
+        },
+    );
+    if (!result || promptOnlyDetected === undefined) return result;
+    const usableSoft = promptOnlyDetected;
+    return {
+        ...result,
+        usableSoft,
+        usableHard: Math.max(usableSoft, Math.min(result.usableHard, promptOnlyDetected)),
+    };
+}
+
 export function getSdkContextLimit(
     providerID: string,
     modelID: string,
@@ -502,6 +549,11 @@ export function getSdkContextLimit(
         detectedLimitProvenance?: ContextLimitProvenance;
     },
 ): number | undefined {
+    if (options?.reservation !== "none") {
+        return getSdkWindowGeometry(providerID, modelID, detectedContextLimit, {
+            detectedLimitProvenance: options?.detectedLimitProvenance,
+        })?.usableSoft;
+    }
     loadPersistedApiCacheOnce();
     const metadata = lookupMetadataWithTagFallback(apiCache, providerID, modelID);
     if (!metadata) return undefined;

package/src/shared/prompt-surface-runtime.ts

@@ -13,6 +13,7 @@ import {
     CTX_REDUCE_LIGHT_DESCRIPTION,
     CTX_SEARCH_LIGHT_DESCRIPTION,
 } from "../tools/light-descriptions";
+import { piModelRefToCanonical } from "./harness-provider-map";
 import { detectConfigFile } from "./jsonc-parser";
 import {
     type PromptSurfaceConfig,
@@ -242,13 +243,14 @@ export function createPromptSurfaceGuidanceEpochCache(runtime: PromptSurfaceRunt
 
     return {
         resolve(sessionId, config, modelKey) {
+            const canonicalModelKey = modelKey ? piModelRefToCanonical(modelKey) : undefined;
             const cached = epochs.get(sessionId);
-            if (cached && cached.config === config && cached.modelKey === modelKey) {
+            if (cached && cached.config === config && cached.modelKey === canonicalModelKey) {
                 return cached.selection;
             }
 
-            const selection = runtime.resolveGuidance(config, modelKey);
-            epochs.set(sessionId, { config, modelKey, selection });
+            const selection = runtime.resolveGuidance(config, canonicalModelKey);
+            epochs.set(sessionId, { config, modelKey: canonicalModelKey, selection });
             return selection;
         },
         clear(sessionId) {

package/src/shared/prompt-surface.test.ts

@@ -47,6 +47,44 @@ describe("prompt-surface resolution", () => {
         }
     });
 
+    it("resolves Pi-native and canonical model keys with canonical precedence", () => {
+        const nativeKey = "openai-codex/gpt-5.6-sol";
+        const canonicalKey = "openai/gpt-5.6-sol";
+
+        expect(resolveCacheTtl({ default: "5m", [nativeKey]: "60m" }, canonicalKey)).toBe("60m");
+        expect(
+            resolvePromptSurface(
+                { default: "full", models: { [nativeKey]: "light" } },
+                canonicalKey,
+            ),
+        ).toEqual({ preset: "light", source: "exact" });
+        expect(
+            resolveCacheTtl(
+                { default: "5m", [nativeKey]: "60m", [canonicalKey]: "30m" },
+                nativeKey,
+            ),
+        ).toBe("30m");
+        expect(
+            resolvePromptSurface(
+                { default: "full", models: { [nativeKey]: "light", [canonicalKey]: "full" } },
+                nativeKey,
+            ),
+        ).toEqual({ preset: "full", source: "exact" });
+    });
+
+    it("leaves unknown provider keys unchanged", () => {
+        expect(
+            resolveCacheTtl(
+                { default: "5m", "custom-provider/model": "1m" },
+                "custom-provider/model",
+            ),
+        ).toBe("1m");
+        expect(modelKeyLookupOrder("custom-provider/model")[0]).toEqual({
+            key: "custom-provider/model",
+            source: "exact",
+        });
+    });
+
     it("derives a stable config identity independent of object key order", () => {
         const left = promptSurfaceConfigIdentity({
             default: "full",

package/src/shared/prompt-surface.ts

@@ -1,3 +1,5 @@
+import { modelRefLookupOrder } from "./harness-provider-map";
+
 /** The built-in prompt-surface variants. */
 export type PromptSurfacePreset = "full" | "light";
 
@@ -69,6 +71,8 @@ export interface ModelKeyCandidate {
  * provider/model boundary is the first slash; the rest of the string remains
  * the model ID, including additional slashes. Candidates are case-sensitive.
  *
+ * Known harness provider aliases are checked canonical-first at each specificity,
+ * so one shared config works on every harness and canonical wins on collisions.
  * Provider wildcards are checked after progressively less-specific model keys,
  * but before the caller's default. That keeps an exact or base-model override
  * authoritative while still allowing `provider/*` to cover otherwise-unlisted
@@ -82,10 +86,15 @@ export function modelKeyLookupOrder(modelKey: string | undefined): ModelKeyCandi
 
     const provider = modelKey.slice(0, slash);
     let modelID = modelKey.slice(slash + 1);
+    const providerRefs = modelRefLookupOrder(`${provider}/${modelID}`);
     const candidates: ModelKeyCandidate[] = [];
 
     while (modelID.length > 0) {
-        candidates.push({ key: `${provider}/${modelID}`, source: "exact" });
+        for (const providerRef of providerRefs) {
+            const providerSlash = providerRef.indexOf("/");
+            const providerPrefix = providerRef.slice(0, providerSlash);
+            candidates.push({ key: `${providerPrefix}/${modelID}`, source: "exact" });
+        }
         candidates.push({ key: modelID, source: "bare" });
 
         const lastDash = modelID.lastIndexOf("-");
@@ -93,7 +102,11 @@ export function modelKeyLookupOrder(modelKey: string | undefined): ModelKeyCandi
         modelID = modelID.slice(0, lastDash);
     }
 
-    candidates.push({ key: `${provider}/*`, source: "wildcard" });
+    for (const providerRef of providerRefs) {
+        const providerSlash = providerRef.indexOf("/");
+        const providerPrefix = providerRef.slice(0, providerSlash);
+        candidates.push({ key: `${providerPrefix}/*`, source: "wildcard" });
+    }
 
     const seen = new Set<string>();
     return candidates.filter((candidate) => {

package/src/shared/rpc-client.ts

@@ -149,7 +149,9 @@ export class MagicContextRpcClient {
             for (const entry of readdirSync(this.portDir)) {
                 if (!entry.startsWith("port-") || !entry.endsWith(".json")) continue;
                 const record = parseRpcPortFile(readFileSync(join(this.portDir, entry), "utf-8"));
-                if (!record || !isPidAlive(record.pid)) continue;
+                // A denied liveness probe still leaves this as a candidate; the
+                // mandatory health check below confirms whether its RPC server is reachable.
+                if (!record || isPidAlive(record.pid) === "dead") continue;
                 records.push(record);
             }
         } catch {
@@ -158,7 +160,7 @@ export class MagicContextRpcClient {
 
         try {
             const legacy = parseRpcPortFile(readFileSync(this.legacyPortFilePath, "utf-8"));
-            if (legacy && (!legacy.pid || isPidAlive(legacy.pid))) records.push(legacy);
+            if (legacy && (!legacy.pid || isPidAlive(legacy.pid) !== "dead")) records.push(legacy);
         } catch {
             // Legacy discovery is optional.
         }

package/src/shared/rpc-types.ts

@@ -7,6 +7,7 @@ import type {
     DreamTaskBacklogMap,
     DreamTaskProgress,
 } from "../features/magic-context/dreamer/task-registry";
+import type { LoggerDiagnostics } from "./logger";
 
 export interface SidebarSnapshot {
     sessionId: string;
@@ -135,6 +136,17 @@ export interface StatusDetail extends SidebarSnapshot {
     isSubagent: boolean;
     pendingOps: Array<{ tagId: number; operation: string }>;
     contextLimit: number;
+    windowGeometry?: {
+        usableSoft: number;
+        usableHard: number;
+        geometry: "shared_upfront" | "shared_truncating" | "separate";
+        derivation: {
+            window: number;
+            reserve: number;
+            reserveSource: "output_catalog" | "output_config" | "wall_margin" | "none";
+            geometry: "shared_upfront" | "shared_truncating" | "separate";
+        };
+    };
     /**
      * Parsed cache TTL in ms. -1 = never expires (cacheTtl "never"; Infinity
      * cannot ride JSON-RPC and 0 would be indistinguishable from unset). The
@@ -170,6 +182,8 @@ export interface StatusDetail extends SidebarSnapshot {
     toastDurationMs: number;
     /** One-line status data for the experimental memory mural. */
     mural?: { present: boolean; ageMs: number | null };
+    /** Runtime logger write failures observed by this plugin process. */
+    loggerDiagnostics: LoggerDiagnostics;
     /**
      * Stable storage-version probe: "which schema is the DB at, which fence does
      * this binary carry". Field names are deliberately snake_case, mirroring the

package/src/shared/rpc-utils.test.ts

@@ -8,6 +8,7 @@ import {
     __setRpcIdentityTestHooks,
     discoverLivePiProcessIds,
     inspectLivePiProcesses,
+    isPidAlive,
     isPidIdentityPlausible,
     type RpcPortFileRecord,
 } from "./rpc-utils";
@@ -42,6 +43,13 @@ function psOutput(output: string | Error): typeof execFileSync {
     }) as typeof execFileSync;
 }
 
+function tasklistOutput(entries: Array<[number, string]>): string {
+    return [
+        '"Image Name","PID","Session Name","Session#","Mem Usage"',
+        ...entries.map(([pid, command]) => `"${command}","${pid}","Console","1","10,000 K"`),
+    ].join("\r\n");
+}
+
 afterEach(() => {
     __resetRpcIdentityTestHooks();
 });
@@ -78,6 +86,103 @@ describe("discoverLivePiProcessIds", () => {
             error: "ps unavailable",
         });
     });
+
+    test("uses tasklist instead of ps on Windows", () => {
+        const calls: string[] = [];
+        __setRpcIdentityTestHooks({
+            platform: "win32",
+            processListExecFileSync: ((file: string | URL) => {
+                calls.push(String(file));
+                return tasklistOutput([
+                    [process.pid, "pi.exe"],
+                    [41001, "pi.exe"],
+                    [41002, "opencode.exe"],
+                ]);
+            }) as typeof execFileSync,
+        });
+
+        expect(inspectLivePiProcesses()).toEqual({
+            state: "known",
+            processIds: [41001],
+        });
+        expect(calls).toEqual(["tasklist"]);
+    });
+});
+
+describe("isPidAlive", () => {
+    test("distinguishes confirmed, dead, and inaccessible PID probes", () => {
+        const probeFailure = (code: string): NodeJS.ErrnoException => {
+            const error = new Error(`kill failed: ${code}`) as NodeJS.ErrnoException;
+            error.code = code;
+            return error;
+        };
+
+        __setRpcIdentityTestHooks({
+            processKill: (() => true) as typeof process.kill,
+        });
+        expect(isPidAlive(PID)).toBe("alive");
+
+        __setRpcIdentityTestHooks({
+            processKill: (() => {
+                throw probeFailure("ESRCH");
+            }) as typeof process.kill,
+        });
+        expect(isPidAlive(PID)).toBe("dead");
+
+        __setRpcIdentityTestHooks({
+            processKill: (() => {
+                throw probeFailure("EPERM");
+            }) as typeof process.kill,
+        });
+        expect(isPidAlive(PID)).toBe("inconclusive");
+    });
+
+    test("uses tasklist for Windows liveness and captures probe stderr", () => {
+        const calls: Array<{ file: string; args: readonly string[]; stdio: unknown }> = [];
+        __setRpcIdentityTestHooks({
+            platform: "win32",
+            execFileSync: ((
+                file: string | URL,
+                args: readonly string[] = [],
+                options: { stdio?: unknown } = {},
+            ) => {
+                calls.push({ file: String(file), args, stdio: options.stdio });
+                if (String(file) === "ps") throw new Error("ps must not run on Windows");
+                return tasklistOutput([[PID, "OpenCode.exe"]]);
+            }) as typeof execFileSync,
+        });
+
+        expect(isPidAlive(PID)).toBe("alive");
+        expect(calls).toEqual([
+            {
+                file: "tasklist",
+                args: ["/FO", "CSV", "/FI", `PID eq ${PID}`],
+                stdio: ["ignore", "pipe", "pipe"],
+            },
+        ]);
+    });
+
+    test("treats a successful tasklist no-match response as dead", () => {
+        __setRpcIdentityTestHooks({
+            platform: "win32",
+            execFileSync: (() =>
+                "INFO: No tasks are running which match the specified criteria.") as typeof execFileSync,
+        });
+
+        expect(isPidAlive(PID)).toBe("dead");
+    });
+
+    test("returns inconclusive when the Windows tasklist probe cannot spawn", () => {
+        __setRpcIdentityTestHooks({
+            platform: "win32",
+            execFileSync: (() => {
+                throw new Error("tasklist unavailable");
+            }) as typeof execFileSync,
+        });
+
+        expect(isPidAlive(PID)).toBe("inconclusive");
+        expect(isPidIdentityPlausible(record(0))).toBe("inconclusive");
+    });
 });
 
 describe("isPidIdentityPlausible", () => {
@@ -99,7 +204,7 @@ describe("isPidIdentityPlausible", () => {
             }) as typeof execFileSync,
         });
 
-        expect(isPidIdentityPlausible(record(500_000))).toBe(false);
+        expect(isPidIdentityPlausible(record(500_000))).toBe("implausible");
         expect(readPaths).toEqual([`/proc/${PID}/stat`, "/proc/uptime"]);
     });
 
@@ -115,10 +220,10 @@ describe("isPidIdentityPlausible", () => {
 
         // The mocked process start is 1,100,000ms. The 120s tolerance is part of
         // the contract because port-file creation follows process startup.
-        expect(isPidIdentityPlausible(record(1_000_000))).toBe(true);
+        expect(isPidIdentityPlausible(record(1_000_000))).toBe("plausible");
     });
 
-    test("treats an unreadable Linux start-time probe as live", () => {
+    test("reports an unreadable Linux start-time probe as inconclusive", () => {
         __setRpcIdentityTestHooks({
             platform: "linux",
             readFileSync: linuxFiles({
@@ -126,17 +231,17 @@ describe("isPidIdentityPlausible", () => {
             }),
         });
 
-        expect(isPidIdentityPlausible(record(500_000))).toBe(true);
+        expect(isPidIdentityPlausible(record(500_000))).toBe("inconclusive");
     });
 
-    test("uses the legacy Linux command fallback and fails closed on probe errors", () => {
+    test("uses the legacy Linux command fallback and distinguishes probe errors", () => {
         __setRpcIdentityTestHooks({
             platform: "linux",
             readFileSync: linuxFiles({
                 [`/proc/${PID}/cmdline`]: "/usr/sbin/opendkim --config /etc/opendkim.conf",
             }),
         });
-        expect(isPidIdentityPlausible(record(0))).toBe(false);
+        expect(isPidIdentityPlausible(record(0))).toBe("implausible");
 
         __setRpcIdentityTestHooks({
             platform: "linux",
@@ -144,7 +249,7 @@ describe("isPidIdentityPlausible", () => {
                 [`/proc/${PID}/cmdline`]: "/usr/local/bin/opencode serve",
             }),
         });
-        expect(isPidIdentityPlausible(record(0))).toBe(true);
+        expect(isPidIdentityPlausible(record(0))).toBe("plausible");
 
         __setRpcIdentityTestHooks({
             platform: "linux",
@@ -152,7 +257,7 @@ describe("isPidIdentityPlausible", () => {
                 [`/proc/${PID}/cmdline`]: new Error("procfs unavailable"),
             }),
         });
-        expect(isPidIdentityPlausible(record(0))).toBe(true);
+        expect(isPidIdentityPlausible(record(0))).toBe("inconclusive");
     });
 
     test("uses ps start time and command probes on non-Linux platforms", () => {
@@ -162,7 +267,7 @@ describe("isPidIdentityPlausible", () => {
         });
         expect(
             isPidIdentityPlausible(record(Date.parse("Mon Aug  7 00:00:00 1970") - 121_000)),
-        ).toBe(false);
+        ).toBe("implausible");
 
         __setRpcIdentityTestHooks({
             platform: "darwin",
@@ -170,24 +275,43 @@ describe("isPidIdentityPlausible", () => {
         });
         expect(
             isPidIdentityPlausible(record(Date.parse("Mon Aug  7 00:00:00 1970") - 120_000)),
-        ).toBe(true);
+        ).toBe("plausible");
 
         __setRpcIdentityTestHooks({
             platform: "darwin",
             execFileSync: psOutput("/usr/sbin/opendkim -f"),
         });
-        expect(isPidIdentityPlausible(record(0))).toBe(false);
+        expect(isPidIdentityPlausible(record(0))).toBe("implausible");
 
         __setRpcIdentityTestHooks({
             platform: "darwin",
             execFileSync: psOutput("/Applications/OpenCode.app/Contents/MacOS/opencode"),
         });
-        expect(isPidIdentityPlausible(record(0))).toBe(true);
+        expect(isPidIdentityPlausible(record(0))).toBe("plausible");
 
         __setRpcIdentityTestHooks({
             platform: "darwin",
             execFileSync: psOutput(new Error("ps unavailable")),
         });
-        expect(isPidIdentityPlausible(record(0))).toBe(true);
+        expect(isPidIdentityPlausible(record(0))).toBe("inconclusive");
+    });
+
+    test("uses tasklist for the Windows command fallback and skips unavailable start time", () => {
+        const calls: Array<{ file: string; args: readonly string[] }> = [];
+        __setRpcIdentityTestHooks({
+            platform: "win32",
+            execFileSync: ((file: string | URL, args: readonly string[] = []) => {
+                calls.push({ file: String(file), args });
+                if (String(file) === "ps") throw new Error("ps must not run on Windows");
+                return tasklistOutput([[PID, "OpenCode.exe"]]);
+            }) as typeof execFileSync,
+        });
+
+        expect(isPidIdentityPlausible(record(0))).toBe("plausible");
+        expect(calls).toEqual([{ file: "tasklist", args: ["/FO", "CSV", "/FI", `PID eq ${PID}`] }]);
+
+        calls.length = 0;
+        expect(isPidIdentityPlausible(record(NOW_MS))).toBe("inconclusive");
+        expect(calls).toEqual([]);
     });
 });