@cortexkit/opencode-magic-context 0.42.5 → 0.43.0

package/src/shared/conflict-detector.ts

@@ -2,12 +2,15 @@ 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";
+import { getOpenCodeConfigDirs, getOpenCodeGlobalConfigDir } from "./opencode-config-dir";
+import type { OpenCodeHostGeneration } from "./opencode-db-path";
 
 interface OpenCodeConfig {
     compaction?: {
         auto?: boolean;
         prune?: boolean;
+        keep?: { tokens?: number };
+        buffer?: number;
     };
     // OpenCode allows plugins as plain strings or [name, options] tuples.
     plugin?: Array<string | [string, unknown]>;
@@ -62,6 +65,8 @@ export interface ConflictResult {
 export interface ResolvedCompaction {
     auto: boolean;
     prune: boolean;
+    keepTokens?: number;
+    buffer?: number;
 }
 
 /**
@@ -92,6 +97,7 @@ export interface ResolvedCompaction {
 export interface DetectConflictsOptions {
     compactionEnabled?: boolean;
     resolvedCompaction?: ResolvedCompaction;
+    hostGeneration?: OpenCodeHostGeneration;
 }
 
 /**
@@ -113,6 +119,7 @@ export function detectConflicts(
     options?: DetectConflictsOptions,
 ): ConflictResult {
     const compactionEnabled = options?.compactionEnabled ?? true;
+    const hostGeneration = options?.hostGeneration ?? "v1";
     const conflicts: ConflictResult["conflicts"] = {
         compactionAuto: false,
         compactionPrune: false,
@@ -129,7 +136,8 @@ export function detectConflicts(
     // 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);
+    let compactionResult =
+        options?.resolvedCompaction ?? checkCompaction(directory, hostGeneration);
     // 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
@@ -141,7 +149,7 @@ export function detectConflicts(
     // 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) {
+    if (hostGeneration === "v1" && compactionEnabled && compactionResult.auto) {
         conflicts.compactionAuto = true;
         reasons.push(
             options?.resolvedCompaction
@@ -149,7 +157,7 @@ export function detectConflicts(
                 : "OpenCode auto-compaction is enabled (compaction.auto=true)",
         );
     }
-    if (compactionEnabled && compactionResult.prune) {
+    if (hostGeneration === "v1" && compactionEnabled && compactionResult.prune) {
         conflicts.compactionPrune = true;
         reasons.push(
             options?.resolvedCompaction
@@ -192,7 +200,10 @@ export function detectConflicts(
         hasConflict: reasons.length > 0,
         reasons,
         conflicts,
-        nativeCompaction: { auto: compactionResult.auto, prune: compactionResult.prune },
+        nativeCompaction: {
+            auto: compactionResult.auto,
+            prune: hostGeneration === "v1" ? compactionResult.prune : false,
+        },
     };
 }
 
@@ -221,6 +232,8 @@ interface ResolvedCompactionBlock {
     compaction?: {
         auto?: boolean;
         prune?: boolean;
+        keep?: { tokens?: number };
+        buffer?: number;
     };
 }
 
@@ -239,16 +252,22 @@ interface ResolvedCompactionBlock {
  * `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.
+ * arm). Only an explicit `compaction.auto` 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.
+ *
+ * `compaction.prune` is read when present and treated as `false` when absent.
+ * OpenCode serves only the keys the user wrote, so requiring it here rejected
+ * the ordinary `{"compaction": {"auto": false}}` config and sent an
+ * answerable question to the file arm (issue #484).
  *
  * Returns `null` when the fetch fails, times out (bounded to `timeoutMs` so
- * boot never hangs), or serves no explicit compaction block.
+ * boot never hangs), or serves no explicit `compaction.auto`.
  */
 export async function resolveCompactionForBoot(
     client: OpencodeConfigClientLike,
     timeoutMs = 2_000,
+    hostGeneration: OpenCodeHostGeneration = "v1",
 ): Promise<ResolvedCompaction | null> {
     const controller = new AbortController();
     let timer: ReturnType<typeof setTimeout> | undefined;
@@ -276,16 +295,49 @@ export async function resolveCompactionForBoot(
         // 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") {
+        if (hostGeneration === "v2") {
+            if (typeof compaction?.auto !== "boolean") {
+                log(
+                    `[magic-context] conflict-detector: resolved v2 config carried no explicit compaction.auto (${JSON.stringify(compaction) ?? "absent"}); falling back to file-based detection`,
+                );
+                return null;
+            }
+            const keepTokens = compaction.keep?.tokens;
+            const buffer = compaction.buffer;
+            if (
+                (keepTokens !== undefined && (!Number.isInteger(keepTokens) || keepTokens < 0)) ||
+                (buffer !== undefined && (!Number.isInteger(buffer) || buffer < 0))
+            ) {
+                return null;
+            }
+            return {
+                auto: compaction.auto,
+                prune: false,
+                ...(keepTokens === undefined ? {} : { keepTokens }),
+                ...(buffer === undefined ? {} : { buffer }),
+            };
+        }
+        // `compaction.auto` is the value the whole conflict decision turns on,
+        // so an explicit boolean for it is required: an absent block means the
+        // response did not carry the resolved state, and reading that absence
+        // as the host default would disable the plugin (issue #309).
+        //
+        // `compaction.prune` is NOT required. OpenCode merges only the keys a
+        // user actually wrote and does not materialise schema defaults into the
+        // resolved config, so the ordinary `{"compaction": {"auto": false}}`
+        // setup serves a block with no `prune` key at all — verified against
+        // opencode 1.18.30 with `opencode debug config`. Demanding both
+        // booleans rejected that every-day shape and pushed the decision onto
+        // the file arm, which is how issue #484's reporter reached the file
+        // arm at all. An absent `prune` takes OpenCode's documented default of
+        // `false`, which is also the non-disabling direction.
+        if (typeof compaction?.auto !== "boolean") {
             log(
-                `[magic-context] conflict-detector: resolved config carried no explicit compaction block (${JSON.stringify(compaction) ?? "absent"}); falling back to file-based detection`,
+                `[magic-context] conflict-detector: resolved config carried no explicit compaction.auto (${JSON.stringify(compaction) ?? "absent"}); falling back to file-based detection`,
             );
             return null;
         }
-        return { auto: compaction.auto, prune: compaction.prune };
+        return { auto: compaction.auto, prune: compaction.prune === true };
     } catch {
         return null;
     } finally {
@@ -293,74 +345,154 @@ export async function resolveCompactionForBoot(
     }
 }
 
-function checkCompaction(directory: string): { auto: boolean; prune: boolean } {
+function checkCompaction(
+    directory: string,
+    hostGeneration: OpenCodeHostGeneration,
+): ResolvedCompaction {
     if (process.env.OPENCODE_DISABLE_AUTOCOMPACT) {
         return { auto: false, prune: false };
     }
 
-    // Check project-level config first (higher precedence)
-    const projectResult = readProjectCompaction(directory);
-    if (projectResult.resolved) return projectResult;
-
-    // Fall back to user-level config
-    const userResult = readUserCompaction();
-    if (userResult.resolved) return userResult;
+    const merged = readCompactionFromConfigFiles(directory, hostGeneration);
+    if (isRelevantCompactionBlock(merged, hostGeneration)) {
+        return resolvedCompactionBlock(merged, hostGeneration);
+    }
 
-    // Default: OpenCode has compaction enabled by default
-    return { auto: true, prune: false };
+    // Nothing in any file OpenCode reads carried an explicit compaction key.
+    // That is INCONCLUSIVE, not "the host default applies", and it must never
+    // resolve to the plugin-disabling `auto: true`. We cannot tell "the user
+    // wrote nothing" apart from "the user's setting lives somewhere this
+    // reader cannot see" — a managed/remote config layer, a directory a
+    // launcher pointed us away from, a file we failed to parse. Guessing the
+    // disabling direction is the one guess with an unrecoverable cost: the
+    // plugin switches off and NOTHING manages the context window, so every
+    // long session overflows. Guessing the other way at worst leaves both
+    // managers running, which is visible and fixable. Issue #309 established
+    // this for the resolved-config arm; issue #484 extends it here after a
+    // launcher exporting OPENCODE_CONFIG_DIR to a scaffolding-only directory
+    // made this default fire against a user whose global config said
+    // auto=false.
+    log(
+        "[magic-context] conflict-detector: no OpenCode config file carried an explicit compaction block; treating native compaction as inconclusive (not disabling the plugin)",
+    );
+    return { auto: false, prune: false };
 }
 
-function readProjectCompaction(directory: string): {
-    auto: boolean;
-    prune: boolean;
-    resolved: boolean;
-} {
-    // .opencode/ config has higher precedence
-    const dotOcJsonc = join(directory, ".opencode", "opencode.jsonc");
-    const dotOcJson = join(directory, ".opencode", "opencode.json");
-    const dotOcConfig =
-        readJsoncFile<OpenCodeConfig>(dotOcJsonc) ?? readJsoncFile<OpenCodeConfig>(dotOcJson);
-
-    if (dotOcConfig?.compaction) {
-        const c = dotOcConfig.compaction;
-        if (c.auto !== undefined || c.prune !== undefined) {
-            return { auto: c.auto === true, prune: c.prune === true, resolved: true };
-        }
-    }
+/**
+ * Every readable config file OpenCode merges for this project, ordered from
+ * LOWEST to HIGHEST precedence.
+ *
+ * OpenCode 1.18.30 (`Config.loadInstanceState`) uses:
+ *
+ *   1. `$XDG_CONFIG_HOME/opencode/` — `config.json`, `opencode.json`, `opencode.jsonc`
+ *   2. `$OPENCODE_CONFIG`          — the explicit single-file override
+ *   3. the project's own `opencode.json` / `opencode.jsonc`
+ *   4. the project's `.opencode/` directory
+ *   5. `~/.opencode/` and `$OPENCODE_CONFIG_DIR` (see getOpenCodeConfigDirs)
+ *
+ * OpenCode 2.x orders the corresponding groups as well-known, global
+ * supplementary, explicit, direct, then project supplementary. See
+ * `packages/core/src/config.ts:220-236` at 7e70f7e1ab. Consequently project
+ * `.opencode` files outrank global supplementary directories only on v2.
+ *
+ * Remote, org, managed-enterprise, and content layers are NOT readable from
+ * here. That is why an empty result is inconclusive rather than the host
+ * default.
+ */
+function openCodeConfigFileChain(
+    directory: string,
+    hostGeneration: OpenCodeHostGeneration,
+): string[] {
+    const globalDir = getOpenCodeGlobalConfigDir();
+    const wellKnown = [
+        join(globalDir, "config.json"),
+        join(globalDir, "opencode.json"),
+        join(globalDir, "opencode.jsonc"),
+    ];
+    const globalSupplementary = getOpenCodeConfigDirs()
+        .filter((dir) => dir !== globalDir)
+        .flatMap((dir) => [join(dir, "opencode.json"), join(dir, "opencode.jsonc")]);
+    const explicitConfig = process.env.OPENCODE_CONFIG?.trim();
+    const explicit = explicitConfig ? [explicitConfig] : [];
+    const direct = [join(directory, "opencode.json"), join(directory, "opencode.jsonc")];
+    const projectSupplementary = [
+        join(directory, ".opencode", "opencode.json"),
+        join(directory, ".opencode", "opencode.jsonc"),
+    ];
+
+    const files =
+        hostGeneration === "v2"
+            ? [
+                  ...wellKnown,
+                  ...globalSupplementary,
+                  ...explicit,
+                  ...direct,
+                  ...projectSupplementary,
+              ]
+            : [
+                  ...wellKnown,
+                  ...explicit,
+                  ...direct,
+                  ...projectSupplementary,
+                  ...globalSupplementary,
+              ];
+    return [...new Set(files)];
+}
 
-    // Root-level project config
-    const rootJsonc = join(directory, "opencode.jsonc");
-    const rootJson = join(directory, "opencode.json");
-    const rootConfig =
-        readJsoncFile<OpenCodeConfig>(rootJsonc) ?? readJsoncFile<OpenCodeConfig>(rootJson);
+type CompactionBlock = NonNullable<OpenCodeConfig["compaction"]>;
 
-    if (rootConfig?.compaction) {
-        const c = rootConfig.compaction;
-        if (c.auto !== undefined || c.prune !== undefined) {
-            return { auto: c.auto === true, prune: c.prune === true, resolved: true };
+/**
+ * Merge the `compaction` blocks of every readable config file, in OpenCode's
+ * own precedence order. Merging (rather than taking the first file that has a
+ * block) is what OpenCode does, so a global `auto: false` and a project-level
+ * `prune: true` both survive instead of one silently erasing the other.
+ */
+function readCompactionFromConfigFiles(
+    directory: string,
+    hostGeneration: OpenCodeHostGeneration,
+): CompactionBlock {
+    const merged: CompactionBlock = {};
+    for (const filePath of openCodeConfigFileChain(directory, hostGeneration)) {
+        let block: CompactionBlock | undefined;
+        try {
+            block = readJsoncFile<OpenCodeConfig>(filePath)?.compaction;
+        } catch {
+            // Intentional: each config read is best-effort. An unreadable file
+            // leaves the chain inconclusive rather than failing detection.
         }
+        if (!block || typeof block !== "object") continue;
+        if (block.auto !== undefined) merged.auto = block.auto;
+        if (block.prune !== undefined) merged.prune = block.prune;
+        if (block.buffer !== undefined) merged.buffer = block.buffer;
+        if (block.keep !== undefined) merged.keep = { ...merged.keep, ...block.keep };
     }
+    return merged;
+}
 
-    return { auto: false, prune: false, resolved: false };
+/** Whether a merged block carries any key this host generation acts on. */
+function isRelevantCompactionBlock(
+    block: CompactionBlock,
+    hostGeneration: OpenCodeHostGeneration,
+): boolean {
+    if (block.auto !== undefined) return true;
+    if (hostGeneration === "v1") return block.prune !== undefined;
+    return block.keep?.tokens !== undefined || block.buffer !== undefined;
 }
 
-function readUserCompaction(): { auto: boolean; prune: boolean; resolved: boolean } {
-    try {
-        const paths = getOpenCodeConfigPaths({ binary: "opencode" });
-        const config =
-            readJsoncFile<OpenCodeConfig>(paths.configJsonc) ??
-            readJsoncFile<OpenCodeConfig>(paths.configJson);
-
-        if (config?.compaction) {
-            const c = config.compaction;
-            if (c.auto !== undefined || c.prune !== undefined) {
-                return { auto: c.auto === true, prune: c.prune === true, resolved: true };
-            }
-        }
-    } catch {
-        // Intentional: config read is best-effort
+function resolvedCompactionBlock(
+    block: NonNullable<OpenCodeConfig["compaction"]>,
+    hostGeneration: OpenCodeHostGeneration,
+): ResolvedCompaction & { resolved: true } {
+    if (hostGeneration === "v2") {
+        return {
+            auto: block.auto !== false,
+            prune: false,
+            resolved: true,
+            ...(typeof block.keep?.tokens === "number" ? { keepTokens: block.keep.tokens } : {}),
+            ...(typeof block.buffer === "number" ? { buffer: block.buffer } : {}),
+        };
     }
-    return { auto: false, prune: false, resolved: false };
+    return { auto: block.auto === true, prune: block.prune === true, resolved: true };
 }
 
 // --- DCP detection ---
@@ -454,12 +586,21 @@ function collectPluginEntries(directory: string): string[] {
         pushFrom(config?.plugin);
     }
 
-    // User-level config
+    // User-level config. Every directory OpenCode reads is searched, not just
+    // the one we would write to: a launcher that exports OPENCODE_CONFIG_DIR
+    // does not stop OpenCode from loading the plugin list in the user's global
+    // config, so a conflicting plugin declared there is still installed.
     try {
-        const paths = getOpenCodeConfigPaths({ binary: "opencode" });
-        for (const configPath of [paths.configJsonc, paths.configJson]) {
-            const config = readJsoncFile<OpenCodeConfig>(configPath);
-            pushFrom(config?.plugin);
+        const globalDir = getOpenCodeGlobalConfigDir();
+        for (const dir of getOpenCodeConfigDirs()) {
+            const names =
+                dir === globalDir
+                    ? ["config.json", "opencode.json", "opencode.jsonc"]
+                    : ["opencode.json", "opencode.jsonc"];
+            for (const name of names) {
+                const config = readJsoncFile<OpenCodeConfig>(join(dir, name));
+                pushFrom(config?.plugin);
+            }
         }
     } catch {
         // best-effort
@@ -524,13 +665,13 @@ function readOmoDisabledHooks(directory: string): Set<string> {
     ];
 
     try {
-        const paths = getOpenCodeConfigPaths({ binary: "opencode" });
-        for (const name of configNames) {
-            const configPath = join(paths.configDir, name);
-            const config = readJsoncFile<OmoConfig>(configPath);
-            if (config?.disabled_hooks) {
-                for (const hook of config.disabled_hooks) {
-                    disabled.add(hook);
+        for (const dir of getOpenCodeConfigDirs()) {
+            for (const name of configNames) {
+                const config = readJsoncFile<OmoConfig>(join(dir, name));
+                if (config?.disabled_hooks) {
+                    for (const hook of config.disabled_hooks) {
+                        disabled.add(hook);
+                    }
                 }
             }
         }

package/src/shared/hidden-variant-warnings.ts

@@ -0,0 +1,21 @@
+const warnings = new Map<string, string>();
+
+/** Remember a host catalog mismatch until the process exits so status can show it once. */
+export function recordHiddenVariantWarning(
+    providerID: string,
+    modelID: string,
+    variant: string,
+): string {
+    const key = `${providerID}/${modelID}:${variant}`;
+    const message = `variant '${variant}' not offered by ${providerID}/${modelID} on this host; running without it`;
+    warnings.set(key, message);
+    return message;
+}
+
+export function listHiddenVariantWarnings(): string[] {
+    return [...warnings.values()];
+}
+
+export function clearHiddenVariantWarningsForTest(): void {
+    warnings.clear();
+}

package/src/shared/host-limitations.ts

@@ -0,0 +1,43 @@
+import { USER_FACING_FAILURES, type UserFacingFailureKey } from "./user-facing-codes";
+
+/**
+ * Named things the host Magic Context is running in cannot do.
+ *
+ * A limitation is not a failed operation: it is a capability the current host
+ * lacks for as long as this process lives, so every status surface keeps
+ * printing it instead of showing it once and forgetting. Each one is an
+ * existing MC-* user-facing code, so the status dialog, the plain-text status
+ * summary and the sidebar all print the same sentence for it.
+ *
+ * Process-global on purpose. The surfaces that show these (the RPC status and
+ * sidebar handlers) are built without a reference to the adapter that
+ * discovered the limitation, and a limitation of the host is true for every
+ * session in the process rather than for one of them.
+ */
+const declared = new Set<UserFacingFailureKey>();
+
+/**
+ * Record a limitation of this host. Returns true only the first time a given
+ * limitation is declared, which is what callers use to log their explanation
+ * once instead of on every pass.
+ */
+export function declareHostLimitation(key: UserFacingFailureKey): boolean {
+    if (declared.has(key)) return false;
+    declared.add(key);
+    return true;
+}
+
+/** Limitations declared so far, in the order they were first declared. */
+export function activeHostLimitations(): UserFacingFailureKey[] {
+    return [...declared];
+}
+
+/** The MC-* codes for the declared limitations, for logs and reports. */
+export function activeHostLimitationCodes(): string[] {
+    return activeHostLimitations().map((key) => USER_FACING_FAILURES[key].code);
+}
+
+/** Test helper: forget every declared limitation so suites do not leak them. */
+export function __resetHostLimitations(): void {
+    declared.clear();
+}

package/src/shared/keep-subagents.ts

@@ -1,11 +1,11 @@
 /**
- * Debug / data-collection switch for settled ordinary child sessions
- * (historian and memory migration). Privacy-sensitive Dreamer and
- * smart-note children are still deleted after their prompts settle.
+ * Debug / data-collection switch for every settled Magic Context child session,
+ * including historian, Dreamer, smart-note, user-memory, and migration work.
  *
  * Unsettled children are never deleted inline because OpenCode's server loop may
- * still be writing after a client timeout or abort. They remain for the
- * age-gated sweep; privacy-sensitive rows are swept even when this switch is on.
+ * still be writing after a client timeout or abort. They remain archived for the
+ * age-gated sweep; archived privacy-sensitive rows are swept even when this
+ * switch is on.
  *
  * Process-global, set once at boot from config (mirrors `harness.ts`). A config
  * change requires a restart to take effect.
@@ -17,7 +17,7 @@ export function setKeepSubagents(value: boolean): void {
     keepSubagents = value === true;
 }
 
-/** True when settled ordinary child sessions should be retained. */
+/** True when every settled Magic Context child session should be retained. */
 export function shouldKeepSubagents(): boolean {
     return keepSubagents;
 }

package/src/shared/model-suggestion-retry.test.ts

@@ -225,6 +225,49 @@ describe("promptSyncWithModelSuggestionRetry", () => {
         expect((abort.mock.calls[0]?.[0] as { path: { id: string } }).path.id).toBe("ses-test");
     });
 
+    test("timeout with a resolving transport still aborts the child", async () => {
+        const abort = mock(async () => ({}));
+        const client = createClient(
+            mock(async () => ({})),
+            abort,
+        );
+        const transport = Object.assign(
+            ({ signal }: { signal?: AbortSignal }) =>
+                new Promise<void>((resolve) => signal?.addEventListener("abort", () => resolve())),
+            { childSessionId: "child-test" },
+        );
+        await expect(
+            promptSyncWithModelSuggestionRetry(client, createArgs(), {
+                timeoutMs: 10,
+                transport,
+            }),
+        ).rejects.toThrow("prompt timed out after 10ms");
+        expect(abort).toHaveBeenCalledTimes(1);
+        expect((abort.mock.calls[0]?.[0] as { path: { id: string } }).path.id).toBe("child-test");
+    });
+
+    test("external abort with a resolving transport still aborts the child", async () => {
+        const controller = new AbortController();
+        const abort = mock(async () => ({}));
+        const client = createClient(
+            mock(async () => ({})),
+            abort,
+        );
+        const transport = Object.assign(
+            ({ signal }: { signal?: AbortSignal }) =>
+                new Promise<void>((resolve) => signal?.addEventListener("abort", () => resolve())),
+            { childSessionId: "child-test" },
+        );
+        setTimeout(() => controller.abort(), 10);
+        await expect(
+            promptSyncWithModelSuggestionRetry(client, createArgs(), {
+                signal: controller.signal,
+                transport,
+            }),
+        ).rejects.toThrow("prompt aborted by external signal");
+        expect(abort).toHaveBeenCalledTimes(1);
+    });
+
     // External abort (e.g. dreamer lease loss) mid-flight must also stop the
     // server-side loop, not just our fetch.
     test("external abort fires session.abort on the child session", async () => {

package/src/shared/model-suggestion-retry.ts

@@ -254,6 +254,18 @@ async function promptWithTimeout(
         clearTimeout(timeout);
         signal?.removeEventListener("abort", onExternalAbort);
     }
+    // Some transports resolve with an error result when their fetch is aborted.
+    // A resolved fetch does not mean the server-side child run has stopped.
+    if (signal?.aborted || controller.signal.aborted) {
+        if (!transport || transport.childSessionId) {
+            await abortChildRun(client, transport?.childSessionId ?? args.path.id);
+        }
+        throw new Error(
+            signal?.aborted
+                ? "prompt aborted by external signal"
+                : `prompt timed out after ${timeoutMs}ms`,
+        );
+    }
 }
 
 /**

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

@@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { resolveKnownHistorianContextLimit } from "../hooks/magic-context/derive-budgets";
 import {
     clearModelsDevCache,
     getModelsDevCacheState,
@@ -230,6 +231,30 @@ describe("models-dev-cache (SDK-only)", () => {
         expect(getSdkContextLimit("openai", "gpt-5.4-mini")).toBe(922000);
     });
 
+    test("explicit SDK-resolved config limit wins over a larger catalog or detected value", async () => {
+        // OpenCode's config.providers() has already applied opencode.json over its
+        // catalog. The cache must preserve that 120K effective value, and a later
+        // API-detected 262K value may narrow but never enlarge it.
+        await refreshModelLimitsFromApi(
+            makeClient([
+                {
+                    id: "regolo",
+                    models: {
+                        "qwen3.5-122b": { limit: { context: 120_000, output: 32_000 } },
+                    },
+                },
+            ]),
+        );
+
+        expect(
+            getSdkContextLimit("regolo", "qwen3.5-122b", 262_144, {
+                reservation: "none",
+                detectedLimitProvenance: "combined",
+            }),
+        ).toBe(120_000);
+        expect(resolveKnownHistorianContextLimit("regolo/qwen3.5-122b")).toBe(120_000);
+    });
+
     test("narrows raw context with detected wire truth before reserving output", async () => {
         await refreshModelLimitsFromApi(
             makeClient([

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

@@ -601,6 +601,11 @@ export function modelSupportsVision(providerID: string, modelID: string): boolea
         : false;
 }
 
+export function getSdkOutputLimit(providerID: string, modelID: string): number | undefined {
+    loadPersistedApiCacheOnce();
+    return lookupMetadataWithTagFallback(apiCache, providerID, modelID)?.outputLimit;
+}
+
 export function getSdkInputLimit(providerID: string, modelID: string): number | undefined {
     loadPersistedApiCacheOnce();
     if (!apiCache) return undefined;