@cortexkit/opencode-magic-context 0.36.0 → 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

@@ -1,7 +1,13 @@
 import { describe, expect, it } from "bun:test";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
 
 import { resolveCacheTtl } from "../hooks/magic-context/event-resolvers";
-import { modelKeyLookupOrder, resolvePromptSurface } from "./prompt-surface";
+import {
+    modelKeyLookupOrder,
+    promptSurfaceConfigIdentity,
+    resolvePromptSurface,
+} from "./prompt-surface";
 
 describe("prompt-surface resolution", () => {
     it("keeps cache_ttl and prompt-surface routing on the same lookup walk", () => {
@@ -11,6 +17,7 @@ describe("prompt-surface resolution", () => {
             "google/*": "light" as const,
             "CaseSensitive/model": "light" as const,
             "progressive/base": "light" as const,
+            "bare-model": "light" as const,
         };
         const cacheTtl = {
             default: "full",
@@ -26,6 +33,7 @@ describe("prompt-surface resolution", () => {
             ["casesensitive/model", "full"],
             ["CaseSensitive/model", "light"],
             ["progressive/base-extra", "light"],
+            ["provider/bare-model", "light"],
             ["unknown/model", "full"],
             [undefined, "full"],
         ] as const;
@@ -39,11 +47,88 @@ describe("prompt-surface resolution", () => {
         }
     });
 
-    it("applies exact, wildcard, then default precedence", () => {
+    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",
+            models: { "provider/b": "light", "provider/a": "full" },
+            tool_descriptions: { ctx_search: "Search", ctx_note: "Note" },
+        });
+        const right = promptSurfaceConfigIdentity({
+            tool_descriptions: { ctx_note: "Note", ctx_search: "Search" },
+            models: { "provider/a": "full", "provider/b": "light" },
+            default: "full",
+        });
+        expect(left).toBe(right);
+        expect(
+            promptSurfaceConfigIdentity({ default: "light", models: { "provider/a": "full" } }),
+        ).not.toBe(right);
+    });
+
+    it("matches the Rust cache_ttl resolver over shared routing vectors", () => {
+        const vectors = JSON.parse(
+            readFileSync(
+                resolve(
+                    import.meta.dir,
+                    "../../../../crates/mc-module/testdata/cache-ttl-routing-vectors.json",
+                ),
+                "utf8",
+            ),
+        ) as {
+            default: string;
+            models: Record<string, string>;
+            cases: Array<{ name: string; modelKey: string; expected: string }>;
+        };
+        const config = { default: vectors.default, ...vectors.models };
+
+        for (const vector of vectors.cases) {
+            expect(resolveCacheTtl(config, vector.modelKey), vector.name).toBe(vector.expected);
+        }
+    });
+
+    it("applies exact, bare, wildcard, then default precedence", () => {
         const config = {
             default: "full" as const,
             models: {
                 "provider/model": "light" as const,
+                bare: "light" as const,
                 "provider/*": "full" as const,
             },
         };
@@ -52,6 +137,10 @@ describe("prompt-surface resolution", () => {
             preset: "light",
             source: "exact",
         });
+        expect(resolvePromptSurface(config, "provider/bare")).toEqual({
+            preset: "light",
+            source: "bare",
+        });
         expect(resolvePromptSurface(config, "provider/other")).toEqual({
             preset: "full",
             source: "wildcard",

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";
 
@@ -13,14 +15,29 @@ export interface PromptSurfaceConfig {
     tool_descriptions?: Readonly<Record<string, string>>;
 }
 
-export type PromptSurfaceResolutionSource = "exact" | "wildcard" | "default";
+/** Stable wire identity for the config fields that can alter a served prompt surface. */
+export function promptSurfaceConfigIdentity(config: PromptSurfaceConfig | undefined): string {
+    return JSON.stringify({
+        default: config?.default ?? "full",
+        models: Object.entries(config?.models ?? {}).sort(([left], [right]) =>
+            left < right ? -1 : left > right ? 1 : 0,
+        ),
+        guidanceOverridePath: config?.guidance_override_path ?? null,
+        toolDescriptions: Object.entries(config?.tool_descriptions ?? {}).sort(([left], [right]) =>
+            left < right ? -1 : left > right ? 1 : 0,
+        ),
+    });
+}
+
+export type PromptSurfaceResolutionSource = "exact" | "bare" | "wildcard" | "default";
 
-/** Validate the literal provider/model and provider/* key grammar. */
+/** Validate bare model, provider/model, and provider/* routing keys. */
 export function isValidPromptSurfaceModelKey(key: string): boolean {
     if (key.length === 0 || key.trim() !== key) return false;
 
     const slash = key.indexOf("/");
-    if (slash <= 0 || slash === key.length - 1) return false;
+    if (slash < 0) return !key.includes("*");
+    if (slash === 0 || slash === key.length - 1) return false;
 
     const provider = key.slice(0, slash);
     const modelID = key.slice(slash + 1);
@@ -42,7 +59,7 @@ export function isValidPromptSurfaceModelKey(key: string): boolean {
     );
 }
 
-export type ModelKeyLookupSource = PromptSurfaceResolutionSource | "bare";
+export type ModelKeyLookupSource = Exclude<PromptSurfaceResolutionSource, "default">;
 
 export interface ModelKeyCandidate {
     key: string;
@@ -54,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
@@ -67,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("-");
@@ -78,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) => {
@@ -117,11 +145,7 @@ export function resolvePromptSurface(
     const fallback = config?.default ?? "full";
     const match = resolveModelConfigValue(config?.models, modelKey);
 
-    // Bare model keys are accepted by cache_ttl for compatibility, but the
-    // prompt_surface schema deliberately accepts only provider/model keys and
-    // provider wildcards. Ignore a bare entry if an unvalidated object reaches
-    // this API so prompt routing keeps its documented grammar.
-    if (match && match.source !== "bare") {
+    if (match) {
         return { preset: match.value, source: match.source };
     }
 

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