@cortexkit/opencode-magic-context 0.36.1 → 0.38.0

package/src/shared/conflict-detector.ts

@@ -1,6 +1,7 @@
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { readJsoncFile } from "./jsonc-parser";
+import { log } from "./logger";
 import { getOpenCodeConfigPaths } from "./opencode-config-dir";
 
 interface OpenCodeConfig {
@@ -51,6 +52,18 @@ export interface ConflictResult {
     };
 }
 
+/**
+ * Resolved native compaction state, as reported by the host's own config
+ * resolution (ctx.client.config.get() — the same object `opencode debug
+ * config` prints). `auto`/`prune` are booleans; the OpenCode schema annotates
+ * `auto` with default `true` and `prune` with default `false`, so an absent
+ * compaction block resolves to `{ auto: true, prune: false }`.
+ */
+export interface ResolvedCompaction {
+    auto: boolean;
+    prune: boolean;
+}
+
 /**
  * Options for {@link detectConflicts}.
  *
@@ -63,6 +76,13 @@ export interface ConflictResult {
  * omit it and accept the default `true` (mode-on) behavior, which preserves
  * today's conflict semantics; it must never silently skip the check.
  *
+ * `resolvedCompaction` is the host's RESOLVED native compaction state
+ * (fetched via {@link resolveCompactionForBoot}). When present, the
+ * file-based {@link checkCompaction} is NOT called — the resolved values are
+ * used directly. Absent means the file-based fallback is used. The
+ * OPENCODE_DISABLE_AUTOCOMPACT env short-circuit is applied on top of
+ * whichever arm produced the value.
+ *
  * When `compactionEnabled` is `false` (compaction-off mode), OpenCode
  * `compaction.auto=true` / `compaction.prune=true` are NOT plugin-disabling
  * conflicts — native compaction is the user's chosen window manager. DCP
@@ -71,6 +91,7 @@ export interface ConflictResult {
  */
 export interface DetectConflictsOptions {
     compactionEnabled?: boolean;
+    resolvedCompaction?: ResolvedCompaction;
 }
 
 /**
@@ -81,6 +102,11 @@ export interface DetectConflictsOptions {
  * When `false` (compaction-off mode), native `compaction.auto`/`prune` are
  * reported in {@link ConflictResult.nativeCompaction} but are NOT flagged as
  * conflicts — native compaction is the intended window manager in that mode.
+ *
+ * `resolvedCompaction` (optional) is the host's RESOLVED native compaction
+ * state from {@link resolveCompactionForBoot}. When present it is used
+ * directly and the file-based {@link checkCompaction} is skipped; when absent
+ * the file-based fallback runs unchanged.
  */
 export function detectConflicts(
     directory: string,
@@ -98,18 +124,38 @@ export function detectConflicts(
     const reasons: string[] = [];
 
     // --- Check OpenCode compaction config ---
-    const compactionResult = checkCompaction(directory);
+    // The host's resolved config is the authority when available (issue #309:
+    // the file-based re-derivation defaults to auto=true when no file resolves,
+    // wrongly disabling the plugin for users whose auto=false lives in a layer
+    // the file reader cannot see). When the resolved fetch failed, fall back to
+    // the file-based check unchanged.
+    let compactionResult = options?.resolvedCompaction ?? checkCompaction(directory);
+    // OPENCODE_DISABLE_AUTOCOMPACT short-circuits BOTH arms: it is the first,
+    // cheapest check and is correct regardless of which arm produced the value.
+    // (checkCompaction already applies it internally for the file arm; this
+    // covers the resolved arm, which skips checkCompaction entirely.)
+    if (process.env.OPENCODE_DISABLE_AUTOCOMPACT) {
+        compactionResult = { auto: false, prune: false };
+    }
     // Native compaction is a conflict ONLY when MC compaction is ON. In
     // compaction-off mode the user has explicitly handed the window to native
     // compaction (or nothing), so compaction.auto=true / prune=true are the
     // intended state, not a plugin-disabling conflict.
     if (compactionEnabled && compactionResult.auto) {
         conflicts.compactionAuto = true;
-        reasons.push("OpenCode auto-compaction is enabled (compaction.auto=true)");
+        reasons.push(
+            options?.resolvedCompaction
+                ? "OpenCode auto-compaction is enabled (compaction.auto=true) (resolved config)"
+                : "OpenCode auto-compaction is enabled (compaction.auto=true)",
+        );
     }
     if (compactionEnabled && compactionResult.prune) {
         conflicts.compactionPrune = true;
-        reasons.push("OpenCode prune is enabled (compaction.prune=true)");
+        reasons.push(
+            options?.resolvedCompaction
+                ? "OpenCode prune is enabled (compaction.prune=true) (resolved config)"
+                : "OpenCode prune is enabled (compaction.prune=true)",
+        );
     }
 
     // --- Check for DCP plugin ---
@@ -152,6 +198,83 @@ export function detectConflicts(
 
 // --- Compaction detection (extracted from opencode-compaction-detector.ts) ---
 
+/**
+ * Minimal shape of the OpenCode SDK client's `config.get()` response. The
+ * SDK's generated `Config` type does not declare a `compaction` field (the
+ * schema lives in OpenCode's core config, not the SDK surface), so we read it
+ * defensively at runtime. `config.get()` returns a `RequestResult` whose
+ * `data` is the resolved config object — the same object `opencode debug
+ * config` prints. The `data` is typed as `unknown` here so the real SDK client
+ * (whose `Config` has no `compaction` key) is structurally assignable.
+ */
+export interface OpencodeConfigClientLike {
+    config: {
+        get: () => Promise<{ data?: unknown }>;
+    };
+}
+
+/**
+ * Shape of the `compaction` block inside the resolved config, read defensively
+ * from the SDK response at runtime.
+ */
+interface ResolvedCompactionBlock {
+    compaction?: {
+        auto?: boolean;
+        prune?: boolean;
+    };
+}
+
+/**
+ * Fetch the host's RESOLVED native compaction state from the OpenCode SDK
+ * client (`ctx.client.config.get()`). This is the authority for the plugin's
+ * conflict decision (issue #309): the file-based re-derivation cannot see
+ * every layer OpenCode folds in (env-var config path, managed configs,
+ * multi-file merge), so any user whose `auto=false` lives in a layer we don't
+ * read would be wrongly flagged. We never re-derive what the host will tell
+ * us.
+ *
+ * A response WITHOUT a compaction block is INCONCLUSIVE, not "host defaults
+ * apply": a server whose `/config` shape drifted (OpenCode Desktop bundles
+ * its own server version) or a fetch racing boot returns data with no
+ * `compaction` key, and reading that absence as `auto=true` disables the
+ * plugin — the one wrong direction, because a false disable leaves NOTHING
+ * managing the window and every long session overflows (issue #309, second
+ * arm). Only an explicit boolean from the host resolves this arm; anything
+ * else returns `null` so the caller falls back to the file-based check,
+ * which reads the layers the user actually wrote.
+ *
+ * Returns `null` when the fetch fails, times out (bounded to `timeoutMs` so
+ * boot never hangs), or serves no explicit compaction block.
+ */
+export async function resolveCompactionForBoot(
+    client: OpencodeConfigClientLike,
+    timeoutMs = 2_000,
+): Promise<ResolvedCompaction | null> {
+    try {
+        const result = await Promise.race([
+            client.config.get(),
+            new Promise<never>((_, reject) =>
+                setTimeout(() => reject(new Error("config.get() timed out")), timeoutMs),
+            ),
+        ]);
+        // The SDK's generated `Config` type has no `compaction` key, so read it
+        // defensively from the runtime response.
+        const compaction = (result?.data as ResolvedCompactionBlock | undefined)?.compaction;
+        // Explicit booleans only. An absent block (or non-boolean values) means
+        // the response shape did not carry the resolved state — fall back to the
+        // file arm rather than resolving to the plugin-disabling default.
+        if (typeof compaction?.auto !== "boolean" || typeof compaction?.prune !== "boolean") {
+            log(
+                `[magic-context] conflict-detector: resolved config carried no explicit compaction block (${JSON.stringify(compaction) ?? "absent"}); falling back to file-based detection`,
+            );
+            return null;
+        }
+        return { auto: compaction.auto, prune: compaction.prune };
+    } catch {
+        return null;
+    }
+}
+
 function checkCompaction(directory: string): { auto: boolean; prune: boolean } {
     if (process.env.OPENCODE_DISABLE_AUTOCOMPACT) {
         return { auto: false, prune: false };

package/src/shared/harness-provider-map.test.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it } from "bun:test";
 import {
+    modelRefLookupOrder,
     ompModelRefToCanonical,
     piModelRefToCanonical,
     resolveModelRefForOmp,
@@ -64,6 +65,25 @@ describe("harness-provider-map", () => {
             const piForm = "openai-codex/gpt-5.5";
             expect(resolveModelRefForPi(piModelRefToCanonical(piForm))).toBe(piForm);
         });
+
+        describe("modelRefLookupOrder (config read edge)", () => {
+            it("tries canonical before the Pi-native spelling", () => {
+                expect(modelRefLookupOrder("openai-codex/gpt-5.6-sol")).toEqual([
+                    "openai/gpt-5.6-sol",
+                    "openai-codex/gpt-5.6-sol",
+                ]);
+                expect(modelRefLookupOrder("openai/gpt-5.6-sol")).toEqual([
+                    "openai/gpt-5.6-sol",
+                    "openai-codex/gpt-5.6-sol",
+                ]);
+            });
+
+            it("keeps unknown provider prefixes as a single passthrough key", () => {
+                expect(modelRefLookupOrder("custom-provider/model")).toEqual([
+                    "custom-provider/model",
+                ]);
+            });
+        });
     });
 });
 

package/src/shared/harness-provider-map.ts

@@ -77,6 +77,25 @@ export function resolveModelRefForPi(ref: string): string {
     return remapProviderPrefix(piModelRefToCanonical(ref), CANONICAL_TO_PI_PROVIDER);
 }
 
+/**
+ * Return every known spelling of a model reference with the canonical shared
+ * form first. The raw input remains the first fallback, so a single config file
+ * works on every harness: canonical wins when both spellings are present, while
+ * Pi/OMP-native provider ids are still accepted at the read edge. Unknown
+ * providers pass through unchanged and therefore produce one candidate.
+ */
+export function modelRefLookupOrder(ref: string): string[] {
+    const canonical = piModelRefToCanonical(ompModelRefToCanonical(ref));
+    return [
+        ...new Set([
+            canonical,
+            ref,
+            resolveModelRefForPi(canonical),
+            resolveModelRefForOmp(canonical),
+        ]),
+    ];
+}
+
 /** OMP-native selector -> canonical shared-config model reference. */
 export function ompModelRefToCanonical(ref: string): string {
     return remapProviderPrefix(ref, OMP_TO_CANONICAL_PROVIDER);

package/src/shared/logger.test.ts

@@ -0,0 +1,119 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { mkdtempSync, rmSync } from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+type LoggerScenarioResult = {
+    exists: boolean;
+    content: string;
+    healthyDiagnostics: {
+        swallowedWriteCount: number;
+        lastErrorMessage: string | null;
+        lastErrorTime: string | null;
+    };
+    failedDiagnostics: {
+        swallowedWriteCount: number;
+        lastErrorMessage: string | null;
+        lastErrorTime: string | null;
+    };
+};
+
+const loggerScenario = `
+import { existsSync, readFileSync } from "node:fs";
+import * as path from "node:path";
+
+const root = process.env.LOGGER_SCENARIO_ROOT;
+const loggerModuleUrl = process.env.LOGGER_MODULE_URL;
+if (!root || !loggerModuleUrl) throw new Error("logger scenario environment is incomplete");
+
+const logger = await import(loggerModuleUrl);
+const logPath = path.join(root, "nested", "magic-context.log");
+process.env.MAGIC_CONTEXT_LOG_PATH = logPath;
+logger.log("first");
+logger.flushLogger();
+const healthyDiagnostics = logger.getLoggerDiagnostics();
+
+const logDirectory = path.dirname(logPath);
+if (process.env.LOGGER_SCENARIO === "recovery") {
+    const { rmSync } = await import("node:fs");
+    rmSync(logDirectory, { recursive: true, force: true });
+    logger.log("second");
+    logger.flushLogger();
+}
+
+// A directory used as the file target makes append fail deterministically on every platform.
+const failedPath = path.join(root, "unwritable-log-target");
+const { mkdirSync } = await import("node:fs");
+mkdirSync(failedPath, { recursive: true });
+process.env.MAGIC_CONTEXT_LOG_PATH = failedPath;
+logger.log("failed write");
+logger.flushLogger();
+const failedDiagnostics = logger.getLoggerDiagnostics();
+
+const content = existsSync(logPath) ? readFileSync(logPath, "utf8") : "";
+console.log(JSON.stringify({
+    exists: existsSync(logPath),
+    content,
+    healthyDiagnostics,
+    failedDiagnostics,
+}));
+`;
+
+const scenarioRoots: string[] = [];
+
+afterEach(() => {
+    for (const root of scenarioRoots.splice(0)) {
+        rmSync(root, { recursive: true, force: true });
+    }
+});
+
+async function runLoggerScenario(
+    scenario: "recovery" | "diagnostics",
+): Promise<LoggerScenarioResult> {
+    const root = mkdtempSync(path.join(os.tmpdir(), "magic-context-logger-test-"));
+    scenarioRoots.push(root);
+    const child = Bun.spawn({
+        cmd: ["bun", "--eval", loggerScenario],
+        cwd: import.meta.dir,
+        env: {
+            ...process.env,
+            NODE_ENV: "production",
+            LOGGER_MODULE_URL: new URL("./logger.ts", import.meta.url).href,
+            LOGGER_SCENARIO: scenario,
+            LOGGER_SCENARIO_ROOT: root,
+        },
+        stdout: "pipe",
+        stderr: "pipe",
+    });
+    const [exitCode, stdout, stderr] = await Promise.all([
+        child.exited,
+        new Response(child.stdout).text(),
+        new Response(child.stderr).text(),
+    ]);
+    expect(exitCode, stderr).toBe(0);
+    return JSON.parse(stdout.trim()) as LoggerScenarioResult;
+}
+
+describe("logger", () => {
+    test("recreates a log directory removed while the process is running", async () => {
+        const result = await runLoggerScenario("recovery");
+
+        expect(result.exists).toBe(true);
+        expect(result.content).toContain("second");
+    });
+
+    test("reports swallowed writes while healthy writes leave the counter at zero", async () => {
+        const result = await runLoggerScenario("diagnostics");
+
+        expect(result.healthyDiagnostics).toEqual({
+            swallowedWriteCount: 0,
+            lastErrorMessage: null,
+            lastErrorTime: null,
+        });
+        expect(result.failedDiagnostics.swallowedWriteCount).toBe(1);
+        expect(result.failedDiagnostics.lastErrorMessage).toBeTruthy();
+        expect(result.failedDiagnostics.lastErrorTime).toMatch(
+            /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/,
+        );
+    });
+});

package/src/shared/logger.ts

@@ -9,25 +9,30 @@ let flushTimer: ReturnType<typeof setTimeout> | null = null;
 const FLUSH_INTERVAL_MS = 500;
 const BUFFER_SIZE_LIMIT = 50;
 
-// Cache the last log directory we mkdir'd successfully so we only retry the
-// filesystem call when the resolved path actually changes. The path is
-// re-evaluated on every flush because `setHarness("pi")` runs after module
-// load on Pi; we MUST NOT freeze it at import time, or Pi's first flush
-// could land in the OpenCode subtree.
-let lastEnsuredDir: string | null = null;
+export interface LoggerDiagnostics {
+    swallowedWriteCount: number;
+    lastErrorMessage: string | null;
+    lastErrorTime: string | null;
+}
 
-function ensureDir(filePath: string): void {
-    const dir = path.dirname(filePath);
-    if (dir === lastEnsuredDir) return;
+let swallowedWriteCount = 0;
+let lastErrorMessage: string | null = null;
+let lastErrorTime: string | null = null;
+
+function recordSwallowedWrite(error: unknown): void {
     try {
-        fs.mkdirSync(dir, { recursive: true });
-        lastEnsuredDir = dir;
+        swallowedWriteCount++;
+        lastErrorMessage = error instanceof Error ? error.message : String(error);
+        lastErrorTime = new Date().toISOString();
     } catch {
-        // Intentional: logging must never throw. If mkdir fails we still
-        // try the append; failure there is also swallowed.
+        // Diagnostics must not make the logger throw either.
     }
 }
 
+function ensureDir(filePath: string): void {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+}
+
 function flush(): void {
     if (flushTimer) {
         clearTimeout(flushTimer);
@@ -40,8 +45,8 @@ function flush(): void {
         const logFile = getMagicContextLogPath();
         ensureDir(logFile);
         fs.appendFileSync(logFile, data);
-    } catch {
-        // Intentional: logging must never throw
+    } catch (error) {
+        recordSwallowedWrite(error);
     }
 }
 
@@ -78,6 +83,19 @@ export function sessionLog(sessionId: string, message: string, data?: unknown):
     log(`[magic-context][${sessionId}] ${message}`, data);
 }
 
+export function getLoggerDiagnostics(): LoggerDiagnostics {
+    return {
+        swallowedWriteCount,
+        lastErrorMessage,
+        lastErrorTime,
+    };
+}
+
+/** Flush buffered log entries immediately. Primarily useful to diagnostic readers and tests. */
+export function flushLogger(): void {
+    flush();
+}
+
 /**
  * Resolve the current log file path. The path is harness-aware (see
  * {@link getMagicContextLogPath}) and re-evaluated on every call, so callers

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

@@ -7,6 +7,7 @@ import {
     getModelsDevCacheState,
     getSdkContextLimit,
     getSdkInputLimit,
+    getSdkWindowGeometry,
     refreshModelLimitsAfterAuthOnce,
     refreshModelLimitsFromApi,
     resetAuthRewarmLatchForTest,
@@ -78,6 +79,23 @@ describe("output-token reservation", () => {
         ).toBe(1_048_576);
     });
 
+    test("output_reserve accepts both harness provider spellings with canonical precedence", () => {
+        const limit = { context: 100_000, output: 20_000 };
+        expect(
+            resolveLimit(limit, "openai-codex", "gpt-5.6-sol", {
+                default: 0,
+                "openai-codex/gpt-5.6-sol": 8_000,
+            }),
+        ).toBe(92_000);
+        expect(
+            resolveLimit(limit, "openai-codex", "gpt-5.6-sol", {
+                default: 0,
+                "openai-codex/gpt-5.6-sol": 8_000,
+                "openai/gpt-5.6-sol": 4_000,
+            }),
+        ).toBe(96_000);
+    });
+
     test("output_reserve overrides shared and separate quota defaults", () => {
         expect(resolveLimit({ context: 100_000, output: 20_000 }, "anthropic", "claude", 0)).toBe(
             100_000,
@@ -131,6 +149,30 @@ describe("models-dev-cache (SDK-only)", () => {
         clearModelsDevCache();
     });
 
+    test("honors the reporter's default output_reserve on the SDK geometry path", async () => {
+        await refreshModelLimitsFromApi(
+            makeClient([
+                {
+                    id: "openai-codex",
+                    models: {
+                        "gpt-5.6-sol": {
+                            limit: { context: 400_000, input: 272_000, output: 128_000 },
+                        },
+                    },
+                },
+            ]),
+        );
+        setOutputReserveConfig({ default: 16_384 });
+
+        const geometry = getSdkWindowGeometry("openai-codex", "gpt-5.6-sol");
+        expect(geometry?.usableSoft).toBe(272_000 - 16_384);
+        expect(geometry?.derivation).toMatchObject({
+            window: 272_000,
+            reserve: 16_384,
+            reserveSource: "output_config",
+        });
+    });
+
     test("resolves from the SDK and prefers limit.input over limit.context", async () => {
         // github-copilot / codex shape: input is the max prompt, context the total
         // window. Pressure math must use the input cap (OpenCode's own overflow.ts

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,22 +202,20 @@ 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)];
 }
 
-function configuredOutputReserve(
-    config: OutputReserveConfig | undefined,
+/** Resolve the user-tier output reservation for one runtime model. */
+export function resolveOutputReserve(
     providerID: string,
     modelID: string,
+    config: OutputReserveConfig | undefined = outputReserveConfig,
 ): number | undefined {
     if (typeof config === "number")
         return Number.isFinite(config) && config >= 0 ? config : undefined;
@@ -256,7 +260,7 @@ export function resolveLimit(
     if (input !== undefined && (context === undefined || input < context)) return input;
     if (context === undefined) return undefined;
 
-    const configuredReserve = configuredOutputReserve(reserveConfig, providerID, modelID);
+    const configuredReserve = resolveOutputReserve(providerID, modelID, reserveConfig);
     let reserve: number;
     if (configuredReserve !== undefined) {
         reserve = configuredReserve;
@@ -493,6 +497,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()),
+            outputReserveOverride: resolveOutputReserve(providerID, modelID),
+            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 +550,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) {