@cortexkit/opencode-magic-context 0.36.0 → 0.37.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/conflict-fixer.test.ts

@@ -434,4 +434,178 @@ describe("fixConflicts", () => {
             expect(updated.compaction).toEqual({ auto: false, prune: false });
         });
     });
+
+    describe("JSONC byte preservation", () => {
+        it("removes DCP and disables compaction without changing comments or formatting elsewhere", () => {
+            const configPath = join(projectDir, "opencode.jsonc");
+            const original =
+                "// leading file comment\r\n" +
+                "{\r\n" +
+                '\t"plugin": [\r\n' +
+                "\t\t// first plugin comment\r\n" +
+                '\t\t"@keep/first",\r\n' +
+                "\t\t// removed DCP comment\r\n" +
+                '\t\t"@tarquinen/opencode-dcp@latest",\r\n' +
+                "\t\t// second plugin comment\r\n" +
+                '\t\t"@keep/second",\r\n' +
+                "\t], // trailing array comment\r\n" +
+                '\t"compaction": {\r\n' +
+                "\t\t// nested compaction comment\r\n" +
+                '\t\t"auto": true,\r\n' +
+                '\t\t"prune": true,\r\n' +
+                "\t},\r\n" +
+                '\t"theme": "dark",\r\n' +
+                "}\r\n";
+            const expected =
+                "// leading file comment\r\n" +
+                "{\r\n" +
+                '\t"plugin": [\r\n' +
+                "\t\t// first plugin comment\r\n" +
+                '\t\t"@keep/first",\r\n' +
+                "\t\t// second plugin comment\r\n" +
+                '\t\t"@keep/second",\r\n' +
+                "\t], // trailing array comment\r\n" +
+                '\t"compaction": {\r\n' +
+                "\t\t// nested compaction comment\r\n" +
+                '\t\t"auto": false,\r\n' +
+                '\t\t"prune": false,\r\n' +
+                "\t},\r\n" +
+                '\t"theme": "dark",\r\n' +
+                "}\r\n";
+            writeFileSync(configPath, original);
+
+            const actions = fixConflicts(projectDir, {
+                compactionAuto: true,
+                compactionPrune: true,
+                dcpPlugin: true,
+                ...noOmoConflicts,
+            });
+
+            expect(actions).toEqual(["Disabled auto-compaction", "Removed opencode-dcp plugin"]);
+            expect(readFileSync(configPath, "utf-8")).toBe(expected);
+            expect(readFileSync(configPath, "utf-8")).not.toContain("removed DCP comment");
+        });
+
+        it("keeps each survivor's own comment when removing a middle plugin entry", () => {
+            const configPath = join(projectDir, "opencode.jsonc");
+            const original = `{
+    "plugin": [
+        // first plugin
+        "@keep/first",
+        // removed plugin
+        "@tarquinen/opencode-dcp@latest",
+        // second plugin
+        "@keep/second",
+    ],
+    "theme": "dark",
+}
+`;
+            const expected = `{
+    "plugin": [
+        // first plugin
+        "@keep/first",
+        // second plugin
+        "@keep/second",
+    ],
+    "theme": "dark",
+}
+`;
+            writeFileSync(configPath, original);
+
+            fixConflicts(projectDir, {
+                compactionAuto: false,
+                compactionPrune: false,
+                dcpPlugin: true,
+                ...noOmoConflicts,
+            });
+
+            expect(readFileSync(configPath, "utf-8")).toBe(expected);
+        });
+
+        it("preserves CRLF and the array's trailing comment when DCP is the final entry", () => {
+            const configPath = join(projectDir, "opencode.jsonc");
+            const original =
+                "{\r\n" +
+                '\t"plugin": [\r\n' +
+                "\t\t// surviving plugin\r\n" +
+                '\t\t"@keep/first",\r\n' +
+                "\t\t// removed final plugin\r\n" +
+                '\t\t"@tarquinen/opencode-dcp@latest",\r\n' +
+                "\t], // array trailing comment\r\n" +
+                "}\r\n";
+            const expected =
+                "{\r\n" +
+                '\t"plugin": [\r\n' +
+                "\t\t// surviving plugin\r\n" +
+                '\t\t"@keep/first"\r\n' +
+                "\t], // array trailing comment\r\n" +
+                "}\r\n";
+            writeFileSync(configPath, original);
+
+            fixConflicts(projectDir, {
+                compactionAuto: false,
+                compactionPrune: false,
+                dcpPlugin: true,
+                ...noOmoConflicts,
+            });
+
+            expect(readFileSync(configPath, "utf-8")).toBe(expected);
+        });
+
+        it("leaves an already conflict-free config byte-identical", () => {
+            const configPath = join(projectDir, "opencode.jsonc");
+            const original = '// preserve every byte\r\n{\r\n\t"plugin": ["@keep/one",],\r\n}\r\n';
+            writeFileSync(configPath, original);
+
+            const actions = fixConflicts(projectDir, {
+                compactionAuto: false,
+                compactionPrune: false,
+                dcpPlugin: true,
+                ...noOmoConflicts,
+            });
+
+            expect(actions).toEqual([]);
+            expect(readFileSync(configPath, "utf-8")).toBe(original);
+        });
+
+        it("appends OMO hooks without reformatting the existing JSONC", () => {
+            const omoDir = join(homeDir, ".omo");
+            mkdirSync(omoDir, { recursive: true });
+            const configPath = join(omoDir, "omo.jsonc");
+            const original = `{
+    // preserve this leading comment
+    "[opencode]": {
+        "disabled_hooks": [
+            // custom hook comment
+            "custom-hook",
+        ], // preserve this array comment
+    },
+}
+`;
+            const expected = `{
+    // preserve this leading comment
+    "[opencode]": {
+        "disabled_hooks": [
+            // custom hook comment
+            "custom-hook",
+            "context-window-monitor",
+        ], // preserve this array comment
+    },
+}
+`;
+            writeFileSync(configPath, original);
+
+            const actions = fixConflicts(projectDir, {
+                compactionAuto: false,
+                compactionPrune: false,
+                dcpPlugin: false,
+                omoPreemptiveCompaction: false,
+                omoContextWindowMonitor: true,
+                omoAnthropicRecovery: false,
+            });
+
+            expect(actions).toEqual(["Disabled conflicting oh-my-opencode hooks"]);
+            expect(readFileSync(configPath, "utf-8")).toBe(expected);
+        });
+    });
 });

package/src/shared/conflict-fixer.ts

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { parse, stringify } from "comment-json";
+import { parse } from "comment-json";
 
 import {
     type ConflictResult,
@@ -9,6 +9,7 @@ import {
     extractPluginName,
     matchesPackageName,
 } from "./conflict-detector";
+import { appendJsoncArrayValues, removeJsoncArrayEntries, setJsoncValue } from "./jsonc-edit";
 import { getOpenCodeConfigPaths } from "./opencode-config-dir";
 
 type JsonObject = Record<string, unknown>;
@@ -39,21 +40,27 @@ function asStringArray(value: unknown): string[] {
         : [];
 }
 
-function readConfig(filePath: string): JsonObject | null {
+interface JsonConfigDocument {
+    config: JsonObject;
+    text: string;
+}
+
+function readConfig(filePath: string): JsonConfigDocument | null {
     if (!existsSync(filePath)) {
         return null;
     }
 
     try {
-        const parsed = parse(readFileSync(filePath, "utf-8"));
-        return isRecord(parsed) ? parsed : null;
+        const text = readFileSync(filePath, "utf-8");
+        const parsed = parse(text);
+        return isRecord(parsed) ? { config: parsed, text } : null;
     } catch {
         return null;
     }
 }
 
-function writeConfig(filePath: string, config: JsonObject): void {
-    writeFileSync(filePath, `${stringify(config, null, 2)}\n`);
+function writeConfig(filePath: string, text: string): void {
+    writeFileSync(filePath, text);
 }
 
 function resolveUserOpenCodeConfigPath(): string {
@@ -130,26 +137,28 @@ function isUnifiedOmoPath(configPath: string): boolean {
     return basename === "omo.jsonc" || basename === "omo.json";
 }
 
-/**
- * Get or create the `[opencode]` block inside a unified omo.json(c) config.
- * Returns the block itself so callers can read/write `disabled_hooks` on it.
- */
-function getOrCreateOmoV2Block(config: JsonObject): JsonObject {
-    const block = config["[opencode]"];
-    if (isRecord(block)) {
-        return block;
+function disableCompactionFlags(
+    text: string,
+    config: JsonObject,
+): { text: string; changed: boolean } {
+    if (!isRecord(config.compaction)) {
+        return {
+            text: setJsoncValue(text, ["compaction"], { auto: false, prune: false }),
+            changed: true,
+        };
     }
-    const newBlock: JsonObject = {};
-    config["[opencode]"] = newBlock;
-    return newBlock;
-}
 
-function filterDcpPluginEntries(entries: unknown[]): { plugins: unknown[]; removed: boolean } {
-    const plugins = entries.filter((entry) => {
-        const name = extractPluginName(entry);
-        return name ? !matchesPackageName(name, DCP_PACKAGE_NAMES) : true;
-    });
-    return { plugins, removed: plugins.length !== entries.length };
+    let updated = text;
+    let changed = false;
+    if (config.compaction.auto !== false) {
+        updated = setJsoncValue(updated, ["compaction", "auto"], false);
+        changed = true;
+    }
+    if (config.compaction.prune !== false) {
+        updated = setJsoncValue(updated, ["compaction", "prune"], false);
+        changed = true;
+    }
+    return { text: updated, changed };
 }
 
 /**
@@ -190,44 +199,37 @@ export function fixConflicts(
 
     if (repairCompaction || conflicts.dcpPlugin) {
         for (const configPath of collectOpenCodeConfigPaths(directory)) {
-            const config = readConfig(configPath);
-            if (!config) {
+            const document = readConfig(configPath);
+            if (!document) {
                 continue;
             }
 
+            let text = document.text;
             let changed = false;
 
             if (repairCompaction) {
-                const compaction = isRecord(config.compaction) ? config.compaction : {};
-
-                if (compaction.auto !== false) {
-                    compaction.auto = false;
-                    changed = true;
-                    updatedCompaction = true;
-                }
-
-                if (compaction.prune !== false) {
-                    compaction.prune = false;
+                const result = disableCompactionFlags(text, document.config);
+                if (result.changed) {
+                    text = result.text;
                     changed = true;
                     updatedCompaction = true;
                 }
-
-                config.compaction = compaction;
             }
 
             if (conflicts.dcpPlugin) {
-                const plugins = Array.isArray(config.plugin) ? config.plugin : [];
-                const filtered = filterDcpPluginEntries(plugins);
-
-                if (filtered.removed) {
-                    config.plugin = filtered.plugins;
+                const result = removeJsoncArrayEntries(text, ["plugin"], (entry) => {
+                    const name = extractPluginName(entry);
+                    return name ? matchesPackageName(name, DCP_PACKAGE_NAMES) : false;
+                });
+                if (result.removed) {
+                    text = result.text;
                     changed = true;
                     removedDcpPlugin = true;
                 }
             }
 
             if (changed) {
-                writeConfig(configPath, config);
+                writeConfig(configPath, text);
             }
         }
     }
@@ -249,36 +251,30 @@ export function fixConflicts(
         }
 
         for (const configPath of collectOmoConfigPaths(directory)) {
-            const config = readConfig(configPath);
-            if (!config) {
+            const document = readConfig(configPath);
+            if (!document) {
                 continue;
             }
 
-            // Unified paths nest hooks under the [opencode] block; legacy paths use top-level
-            const target = isUnifiedOmoPath(configPath) ? getOrCreateOmoV2Block(config) : config;
-
+            const unifiedPath = isUnifiedOmoPath(configPath);
+            const target =
+                unifiedPath && isRecord(document.config["[opencode]"])
+                    ? document.config["[opencode]"]
+                    : unifiedPath
+                      ? {}
+                      : document.config;
             const disabledHooks = new Set(asStringArray(target.disabled_hooks));
-            let changed = false;
-
-            for (const hook of hooksToDisable) {
-                if (!disabledHooks.has(hook)) {
-                    disabledHooks.add(hook);
-                    changed = true;
-                    disabledOmoHooks = true;
-                }
-            }
-
-            if (changed) {
-                target.disabled_hooks = [
-                    ...CONFLICTING_OMO_HOOKS.filter((hook) => disabledHooks.has(hook)),
-                    ...[...disabledHooks].filter(
-                        (hook) =>
-                            !CONFLICTING_OMO_HOOKS.includes(
-                                hook as (typeof CONFLICTING_OMO_HOOKS)[number],
-                            ),
-                    ),
-                ];
-                writeConfig(configPath, config);
+            const hooksToAdd = CONFLICTING_OMO_HOOKS.filter(
+                (hook) => hooksToDisable.has(hook) && !disabledHooks.has(hook),
+            );
+
+            if (hooksToAdd.length > 0) {
+                const path = unifiedPath ? ["[opencode]", "disabled_hooks"] : ["disabled_hooks"];
+                const text = Array.isArray(target.disabled_hooks)
+                    ? appendJsoncArrayValues(document.text, path, hooksToAdd)
+                    : setJsoncValue(document.text, path, hooksToAdd);
+                writeConfig(configPath, text);
+                disabledOmoHooks = true;
             }
         }
     }

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);