@cortexkit/opencode-magic-context 0.42.6 → 0.43.0

package/src/shared/conflict-detector.test.ts

@@ -552,10 +552,14 @@ describe("detectConflicts", () => {
             }
         }
 
-        it("resolved auto=false + file layer that would default true → NO conflict (#309)", () => {
-            // No compaction block in any file + no env override → the file-based
-            // arm would default to auto=true and wrongly disable the plugin.
-            // The resolved arm says auto=false, which must win.
+        it("resolved auto=false outranks a file layer that says auto=true (#309)", () => {
+            // The file layer says auto=true, which on its own disables the
+            // plugin. The host's resolved config says auto=false, and the host
+            // is the authority — it can see layers the file reader cannot.
+            writeFileSync(
+                join(projectDir, "opencode.json"),
+                JSON.stringify({ compaction: { auto: true } }),
+            );
             withoutAutoCompactEnv(() => {
                 const result = detectConflicts(projectDir, {
                     compactionEnabled: true,
@@ -592,8 +596,17 @@ describe("detectConflicts", () => {
         });
 
         it("resolved arm is skipped when resolvedCompaction is absent (file-based fallback unchanged)", () => {
-            // No resolvedCompaction → the file-based check runs. With no
-            // compaction block and no env override, it defaults to auto=true.
+            // No resolvedCompaction → the file-based check runs and owns the
+            // verdict. The written block is what makes the file arm say
+            // auto=true; it used to be an absent block relying on the file
+            // arm's default-on, which issue #484 removed because an absent
+            // block cannot tell "the user wrote nothing" apart from "we read
+            // the wrong directory". The claim under test is unchanged: with no
+            // resolved value the file arm decides, and its reason is unlabeled.
+            writeFileSync(
+                join(projectDir, "opencode.json"),
+                JSON.stringify({ compaction: { auto: true } }),
+            );
             withoutAutoCompactEnv(() => {
                 const result = detectConflicts(projectDir, { compactionEnabled: true });
                 expect(result.conflicts.compactionAuto).toBe(true);
@@ -635,6 +648,166 @@ describe("detectConflicts", () => {
         });
     });
 
+    // --- OPENCODE_CONFIG_DIR is an ADDITION, not a replacement (issue #484) ---
+    //
+    // A launcher (Orca) exported OPENCODE_CONFIG_DIR to a directory holding
+    // only plugin scaffolding. OpenCode kept reading the user's real global
+    // config — `opencode debug config` showed compaction.auto=false — but the
+    // detector resolved the env directory INSTEAD of the global one, found no
+    // file, fell through to its default-on, and disabled the plugin.
+    //
+    // Verified against the opencode 1.18.30 binary and on a live host:
+    // `$XDG_CONFIG_HOME/opencode` is always read; `~/.opencode` is always
+    // scanned; `$OPENCODE_CONFIG_DIR` is appended LAST, so it wins ties but
+    // never hides the layers below it.
+    describe("OPENCODE_CONFIG_DIR is additive, not a replacement (issue #484)", () => {
+        let globalDir: string;
+        let launcherDir: string;
+
+        beforeEach(() => {
+            // These cases exercise compaction detection itself, so the suite's
+            // isolation env var has to go.
+            delete process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+            // HOME is the temp dir and XDG_CONFIG_HOME is cleared by the suite
+            // beforeEach, so this is the same path OpenCode would compute.
+            globalDir = join(homeDir, ".config", "opencode");
+            mkdirSync(globalDir, { recursive: true });
+            // The reporter's launcher directory: plugin scaffolding, no config.
+            launcherDir = join(root, "launcher-config-dir");
+            mkdirSync(launcherDir, { recursive: true });
+            writeFileSync(
+                join(launcherDir, "package.json"),
+                JSON.stringify({ name: "launcher-scaffold", version: "1.0.0" }),
+            );
+            process.env.OPENCODE_CONFIG_DIR = launcherDir;
+        });
+
+        afterEach(() => {
+            delete process.env.OPENCODE_CONFIG;
+        });
+
+        function writeCompaction(dir: string, file: string, compaction: unknown): void {
+            mkdirSync(dir, { recursive: true });
+            writeFileSync(join(dir, file), JSON.stringify({ compaction }));
+        }
+
+        it("reporter repro: global auto=false + config-less OPENCODE_CONFIG_DIR → no conflict", () => {
+            writeCompaction(globalDir, "opencode.json", { auto: false });
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.conflicts.compactionAuto).toBe(false);
+            expect(result.hasConflict).toBe(false);
+            expect(result.nativeCompaction.auto).toBe(false);
+        });
+
+        it("positive control: global auto=true still reports the conflict", () => {
+            writeCompaction(globalDir, "opencode.json", { auto: true });
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.conflicts.compactionAuto).toBe(true);
+            expect(result.hasConflict).toBe(true);
+            expect(result.reasons.join("; ")).toContain("compaction.auto=true");
+        });
+
+        it("an OPENCODE_CONFIG_DIR that DOES carry auto=true outranks a global auto=false", () => {
+            writeCompaction(globalDir, "opencode.json", { auto: false });
+            writeCompaction(launcherDir, "opencode.json", { auto: true });
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.conflicts.compactionAuto).toBe(true);
+            expect(result.hasConflict).toBe(true);
+        });
+
+        it("an OPENCODE_CONFIG_DIR auto=false outranks a global auto=true", () => {
+            writeCompaction(globalDir, "opencode.json", { auto: true });
+            writeCompaction(launcherDir, "opencode.jsonc", { auto: false });
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.conflicts.compactionAuto).toBe(false);
+            expect(result.hasConflict).toBe(false);
+        });
+
+        it("v1 keeps global supplementary config above the project .opencode overlay", () => {
+            writeCompaction(launcherDir, "opencode.json", { auto: false });
+            writeCompaction(join(projectDir, ".opencode"), "opencode.json", { auto: true });
+            const result = detectConflicts(projectDir, {
+                compactionEnabled: true,
+                hostGeneration: "v1",
+            });
+            expect(result.nativeCompaction.auto).toBe(false);
+            expect(result.conflicts.compactionAuto).toBe(false);
+        });
+
+        it("v2 ranks the project .opencode overlay above global supplementary config", () => {
+            writeCompaction(launcherDir, "opencode.json", { auto: false });
+            writeCompaction(join(projectDir, ".opencode"), "opencode.json", { auto: true });
+            const result = detectConflicts(projectDir, {
+                compactionEnabled: true,
+                hostGeneration: "v2",
+            });
+            expect(result.nativeCompaction.auto).toBe(true);
+            expect(result.conflicts.compactionAuto).toBe(false);
+        });
+
+        it("reads the global directory's legacy config.json layer", () => {
+            writeCompaction(globalDir, "config.json", { auto: true });
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.conflicts.compactionAuto).toBe(true);
+        });
+
+        it("global opencode.jsonc overrides global opencode.json", () => {
+            writeCompaction(globalDir, "opencode.json", { auto: true });
+            writeCompaction(globalDir, "opencode.jsonc", { auto: false });
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.conflicts.compactionAuto).toBe(false);
+            expect(result.hasConflict).toBe(false);
+        });
+
+        it("~/.opencode outranks the global config directory", () => {
+            writeCompaction(globalDir, "opencode.json", { auto: false });
+            writeCompaction(join(homeDir, ".opencode"), "opencode.json", { auto: true });
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.conflicts.compactionAuto).toBe(true);
+        });
+
+        it("reads the $OPENCODE_CONFIG single-file override", () => {
+            const explicit = join(root, "explicit-opencode.json");
+            writeFileSync(explicit, JSON.stringify({ compaction: { auto: true } }));
+            process.env.OPENCODE_CONFIG = explicit;
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.conflicts.compactionAuto).toBe(true);
+        });
+
+        it("merges keys across layers instead of letting one file erase the other", () => {
+            writeCompaction(globalDir, "opencode.json", { auto: false });
+            writeCompaction(projectDir, "opencode.json", { prune: true });
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.nativeCompaction.auto).toBe(false);
+            expect(result.nativeCompaction.prune).toBe(true);
+            expect(result.conflicts.compactionAuto).toBe(false);
+            expect(result.conflicts.compactionPrune).toBe(true);
+        });
+
+        it("no compaction key in any readable layer is inconclusive, never a disable", () => {
+            // Nothing anywhere. OpenCode's own default is auto=true, but we
+            // cannot tell "the user wrote nothing" from "the value lives in a
+            // layer we cannot read" (managed/enterprise config, an org layer,
+            // a file we failed to parse). Guessing the disabling direction
+            // leaves NOTHING managing the window — the unrecoverable failure
+            // issue #309 established for the resolved arm.
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.conflicts.compactionAuto).toBe(false);
+            expect(result.conflicts.compactionPrune).toBe(false);
+            expect(result.hasConflict).toBe(false);
+            expect(result.nativeCompaction.auto).toBe(false);
+        });
+
+        it("still finds a conflicting plugin declared in the global config", () => {
+            writeFileSync(
+                join(globalDir, "opencode.json"),
+                JSON.stringify({ plugin: ["@tarquinen/opencode-dcp"] }),
+            );
+            const result = detectConflicts(projectDir, { compactionEnabled: true });
+            expect(result.conflicts.dcpPlugin).toBe(true);
+        });
+    });
+
     // --- resolveCompactionForBoot (the resolved-config fetch helper) ---
     describe("resolveCompactionForBoot", () => {
         it("returns the resolved compaction block from the client", async () => {
@@ -649,6 +822,40 @@ describe("detectConflicts", () => {
             expect(result).toEqual({ auto: false, prune: true });
         });
 
+        it("resolves a host block that carries only compaction.auto (issue #484)", async () => {
+            // The shape opencode 1.18.30 actually serves for the ordinary
+            // `"compaction": { "auto": false }` config: OpenCode merges only
+            // the keys the user wrote and never materialises schema defaults,
+            // so `prune` is simply absent. Requiring it here used to reject
+            // this block and hand the decision to the file arm.
+            const client = {
+                config: {
+                    get: async () => ({ data: { compaction: { auto: false } } }),
+                },
+            };
+            const result = await resolveCompactionForBoot(client);
+            expect(result).toEqual({ auto: false, prune: false });
+        });
+
+        it("resolves auto=true without prune and keeps it a conflict", async () => {
+            const client = {
+                config: {
+                    get: async () => ({ data: { compaction: { auto: true } } }),
+                },
+            };
+            const resolved = await resolveCompactionForBoot(client);
+            expect(resolved).toEqual({ auto: true, prune: false });
+            // The suite beforeEach sets OPENCODE_DISABLE_AUTOCOMPACT, which
+            // short-circuits both arms; this case is about the verdict.
+            delete process.env.OPENCODE_DISABLE_AUTOCOMPACT;
+            const result = detectConflicts(projectDir, {
+                compactionEnabled: true,
+                resolvedCompaction: resolved ?? undefined,
+            });
+            expect(result.conflicts.compactionAuto).toBe(true);
+            expect(result.reasons.join("; ")).toContain("(resolved config)");
+        });
+
         it("returns null when the compaction block is absent (file-based fallback, not host defaults)", async () => {
             // An absent block means the response shape did not carry the resolved
             // state (server version drift, a fetch racing boot) — NOT that the
@@ -665,7 +872,7 @@ describe("detectConflicts", () => {
             expect(result).toBeNull();
         });
 
-        it("returns null when compaction values are not explicit booleans", async () => {
+        it("returns null when compaction.auto is not an explicit boolean", async () => {
             const client = {
                 config: {
                     get: async () => ({ data: { compaction: { auto: "true", prune: null } } }),
@@ -675,6 +882,16 @@ describe("detectConflicts", () => {
             expect(result).toBeNull();
         });
 
+        it("treats a non-boolean prune as false rather than discarding an explicit auto", async () => {
+            const client = {
+                config: {
+                    get: async () => ({ data: { compaction: { auto: true, prune: "yes" } } }),
+                },
+            };
+            const result = await resolveCompactionForBoot(client);
+            expect(result).toEqual({ auto: true, prune: false });
+        });
+
         it("returns null when the response data is missing entirely", async () => {
             const client = {
                 config: {

package/src/shared/conflict-detector.ts

@@ -2,7 +2,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";
+import { getOpenCodeConfigDirs, getOpenCodeGlobalConfigDir } from "./opencode-config-dir";
 import type { OpenCodeHostGeneration } from "./opencode-db-path";
 
 interface OpenCodeConfig {
@@ -252,12 +252,17 @@ 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,
@@ -312,16 +317,27 @@ export async function resolveCompactionForBoot(
                 ...(buffer === undefined ? {} : { buffer }),
             };
         }
-        // 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") {
+        // `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 {
@@ -337,83 +353,130 @@ function checkCompaction(
         return { auto: false, prune: false };
     }
 
-    // Check project-level config first (higher precedence)
-    const projectResult = readProjectCompaction(directory, hostGeneration);
-    if (projectResult.resolved) return projectResult;
-
-    // Fall back to user-level config
-    const userResult = readUserCompaction(hostGeneration);
-    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(
+/**
+ * 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,
-): ResolvedCompaction & { 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 ||
-            (hostGeneration === "v1" && c.prune !== undefined) ||
-            (hostGeneration === "v2" && (c.keep?.tokens !== undefined || c.buffer !== undefined))
-        ) {
-            return resolvedCompactionBlock(c, hostGeneration);
-        }
-    }
-
-    // Root-level project config
-    const rootJsonc = join(directory, "opencode.jsonc");
-    const rootJson = join(directory, "opencode.json");
-    const rootConfig =
-        readJsoncFile<OpenCodeConfig>(rootJsonc) ?? readJsoncFile<OpenCodeConfig>(rootJson);
-
-    if (rootConfig?.compaction) {
-        const c = rootConfig.compaction;
-        if (
-            c.auto !== undefined ||
-            (hostGeneration === "v1" && c.prune !== undefined) ||
-            (hostGeneration === "v2" && (c.keep?.tokens !== undefined || c.buffer !== undefined))
-        ) {
-            return resolvedCompactionBlock(c, hostGeneration);
-        }
-    }
+): 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"),
+    ];
 
-    return { auto: false, prune: false, resolved: false };
+    const files =
+        hostGeneration === "v2"
+            ? [
+                  ...wellKnown,
+                  ...globalSupplementary,
+                  ...explicit,
+                  ...direct,
+                  ...projectSupplementary,
+              ]
+            : [
+                  ...wellKnown,
+                  ...explicit,
+                  ...direct,
+                  ...projectSupplementary,
+                  ...globalSupplementary,
+              ];
+    return [...new Set(files)];
 }
 
-function readUserCompaction(
-    hostGeneration: OpenCodeHostGeneration,
-): ResolvedCompaction & { resolved: boolean } {
-    try {
-        const paths = getOpenCodeConfigPaths({ binary: "opencode" });
-        const config =
-            readJsoncFile<OpenCodeConfig>(paths.configJsonc) ??
-            readJsoncFile<OpenCodeConfig>(paths.configJson);
+type CompactionBlock = NonNullable<OpenCodeConfig["compaction"]>;
 
-        if (config?.compaction) {
-            const c = config.compaction;
-            if (
-                c.auto !== undefined ||
-                (hostGeneration === "v1" && c.prune !== undefined) ||
-                (hostGeneration === "v2" &&
-                    (c.keep?.tokens !== undefined || c.buffer !== undefined))
-            ) {
-                return resolvedCompactionBlock(c, hostGeneration);
-            }
+/**
+ * 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.
         }
-    } catch {
-        // Intentional: config read is best-effort
+        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 { auto: false, prune: false, resolved: false };
+    return merged;
+}
+
+/** 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 resolvedCompactionBlock(
@@ -523,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
@@ -593,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();
+}