@cortexkit/opencode-magic-context 0.38.0 → 0.39.0

package/src/config/index.test.ts

@@ -342,6 +342,40 @@ describe("loadPluginConfig — secret redaction", () => {
         expect(w).toBeDefined();
     });
 
+    it("prunes only cross-harness qualifier leaves and names their full paths", () => {
+        const result = loadWithUserConfig(
+            JSON.stringify({
+                historian: {
+                    two_pass: true,
+                    opencode: {
+                        model: "anthropic/claude-sonnet",
+                        variant: "high",
+                        thinking_level: "minimal",
+                    },
+                    pi: {
+                        model: "github-copilot/gpt-5",
+                        thinking_level: "medium",
+                        variant: "fast",
+                    },
+                },
+            }),
+        );
+
+        expect(result.historian?.two_pass).toBe(true);
+        expect(result.historian?.opencode).toEqual({
+            model: "anthropic/claude-sonnet",
+            variant: "high",
+        });
+        expect(result.historian?.pi).toEqual({
+            model: "github-copilot/gpt-5",
+            thinking_level: "medium",
+        });
+        const warnings = result.configWarnings?.join("\n") ?? "";
+        expect(warnings).toContain("historian.opencode.thinking_level");
+        expect(warnings).toContain("historian.pi.variant");
+        expect(warnings).not.toContain("invalid agent configuration, ignoring");
+    });
+
     it("still shows numeric and boolean invalid values (not secrets by nature)", () => {
         // Numbers/booleans in config fields are never secrets — they're
         // plain validation mistakes — so we surface them fully to help
@@ -740,25 +774,43 @@ describe("loadPluginConfig — user-only settings", () => {
         const result = loadWithUserAndProjectConfig(
             JSON.stringify({
                 historian: {
-                    model: "anthropic/user-historian",
-                    fallback_models: ["anthropic/user-fallback"],
+                    opencode: {
+                        model: "anthropic/user-historian",
+                        fallback_models: ["anthropic/user-fallback"],
+                    },
+                    pi: {
+                        model: "github-copilot/user-historian",
+                        fallback_models: ["github-copilot/user-fallback"],
+                    },
                 },
             }),
             JSON.stringify({
                 historian: {
-                    model: "anthropic/project-historian",
-                    fallback_models: ["anthropic/project-fallback"],
+                    opencode: {
+                        model: "anthropic/project-historian",
+                        fallback_models: ["anthropic/project-fallback"],
+                    },
+                    pi: {
+                        model: "github-copilot/project-historian",
+                        fallback_models: ["github-copilot/project-fallback"],
+                    },
                     temperature: 0.2,
                 },
             }),
         );
 
-        expect(result.historian?.model).toBe("anthropic/user-historian");
-        expect(result.historian?.fallback_models).toEqual(["anthropic/user-fallback"]);
+        expect(result.historian?.opencode).toEqual({
+            model: "anthropic/user-historian",
+            fallback_models: ["anthropic/user-fallback"],
+        });
+        expect(result.historian?.pi).toEqual({
+            model: "github-copilot/user-historian",
+            fallback_models: ["github-copilot/user-fallback"],
+        });
         expect(result.historian?.temperature).toBe(0.2);
-        expect(result.configWarnings?.join("\n")).toContain(
-            "Ignoring historian.model/fallback_models",
-        );
+        const warnings = result.configWarnings?.join("\n") ?? "";
+        expect(warnings).toContain("historian.opencode.model");
+        expect(warnings).toContain("historian.pi.model");
     });
 });
 
@@ -877,21 +929,25 @@ describe("loadPluginConfig — raw merge preserves user fields not set in projec
             JSON.stringify({ language: "tr" }),
             JSON.stringify({
                 dreamer: {
-                    model: "anthropic/project-dreamer",
-                    tasks: {
-                        verify: {
-                            schedule: "0 3 * * *",
-                            model: "anthropic/project-verify",
-                        },
+                    tasks: { verify: { schedule: "0 3 * * *" } },
+                    opencode: {
+                        model: "anthropic/project-dreamer",
+                        tasks: { verify: { model: "anthropic/project-verify" } },
+                    },
+                    pi: {
+                        model: "github-copilot/project-dreamer",
+                        tasks: { verify: { model: "github-copilot/project-verify" } },
                     },
                 },
             }),
         );
 
         expect(result.language).toBe("tr");
-        expect(result.dreamer?.model).toBe("anthropic/project-dreamer");
+        expect(result.dreamer?.opencode?.model).toBe("anthropic/project-dreamer");
+        expect(result.dreamer?.pi?.model).toBe("github-copilot/project-dreamer");
         expect(result.dreamer?.tasks.verify.schedule).toBe("0 3 * * *");
-        expect(result.dreamer?.tasks.verify.model).toBe("anthropic/project-verify");
+        expect(result.dreamer?.opencode?.tasks?.verify?.model).toBe("anthropic/project-verify");
+        expect(result.dreamer?.pi?.tasks?.verify?.model).toBe("github-copilot/project-verify");
     });
 
     it("project boolean override beats user default", () => {

package/src/config/index.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync } from "node:fs";
 
 import { detectConfigFile, isPrototypePollutionKey, parseJsonc } from "../shared/jsonc-parser";
 import { setOutputReserveConfig } from "../shared/models-dev-cache";
@@ -20,6 +20,7 @@ import {
     stripUnsafeProjectConfigFields,
 } from "./project-security";
 import { pruneNestedConfigLeaf } from "./prune-config-leaf";
+import { loadRawConfigFile } from "./raw-loader";
 import { type MagicContextConfig, MagicContextConfigSchema } from "./schema/magic-context";
 import { resolveTransformMode } from "./transform-mode";
 import { substituteConfigVariables } from "./variable";
@@ -109,8 +110,12 @@ function loadConfigFileDetailed(
     }
 
     let rawText: string;
+    let rawWarnings: string[];
     try {
-        rawText = readFileSync(configPath, "utf-8");
+        const raw = loadRawConfigFile({ configPath, tier: source });
+        if (!raw) return null;
+        rawText = raw.text;
+        rawWarnings = raw.warnings;
     } catch (error) {
         return {
             config: {},
@@ -138,7 +143,7 @@ function loadConfigFileDetailed(
         );
         return {
             config,
-            warnings: [...substituted.warnings, ...unsafeKeyWarnings].map(
+            warnings: [...rawWarnings, ...substituted.warnings, ...unsafeKeyWarnings].map(
                 (warning) => `${configPath}: ${warning}`,
             ),
             outcome:
@@ -285,8 +290,9 @@ function parsePluginConfig(
     }
 
     // Full parse failed — recover field-by-field using defaults for invalid fields.
-    // Agent configs (historian, dreamer, sidekick) are dropped on error rather than defaulted
-    // because wrong model config could run expensive models or fail silently.
+    // Invalid nested leaves are pruned from agent blocks; only root-level or
+    // unreachable agent errors drop the block, because guessing a model config
+    // could run an expensive unintended model or fail silently.
     const defaults = MagicContextConfigSchema.parse({});
     const warnings: string[] = [];
 
@@ -309,7 +315,13 @@ function parsePluginConfig(
             const key = String(topKey);
             errorPaths.add(key);
             const paths = issuePathsByKey.get(key) ?? [];
-            paths.push([...issue.path]);
+            if (issue.code === "unrecognized_keys") {
+                for (const unrecognizedKey of issue.keys) {
+                    paths.push([...issue.path, unrecognizedKey]);
+                }
+            } else {
+                paths.push([...issue.path]);
+            }
             issuePathsByKey.set(key, paths);
             const msg = issue.message;
             if (msg && !GENERIC_ZOD_PREFIXES.some((p) => msg.startsWith(p))) {
@@ -324,21 +336,12 @@ function parsePluginConfig(
     for (const key of errorPaths) {
         recoveredTopLevelKeys.push(key);
         const isAgentConfig = key === "historian" || key === "dreamer" || key === "sidekick";
-        if (isAgentConfig) {
-            // Drop agent configs entirely on error — don't default them
-            delete patched[key];
-            warnings.push(
-                `"${key}": invalid agent configuration, ignoring. Check your magic-context.jsonc.`,
-            );
-            continue;
-        }
 
-        // For object-valued keys (e.g. `memory`), prune ONLY the invalid nested
-        // leaves and keep valid siblings, so one bad nested field doesn't wipe the
-        // whole block — which would silently drop already-migrated graduated keys
-        // like memory.auto_search / memory.git_commit_indexing. Falls back to
-        // whole-key deletion when the issue is at the key itself or the value
-        // isn't a prunable object.
+        // For object-valued keys (including agent harness blocks), prune only invalid
+        // nested leaves and keep valid siblings, so one bad field does not remove
+        // already-migrated keys such as memory.auto_search and
+        // memory.git_commit_indexing. Fall back to whole-key deletion when the issue
+        // is at the key itself or the value is not a prunable object.
         const issuePaths = issuePathsByKey.get(key) ?? [];
         const rawValue = rawConfig[key];
         const allNested =
@@ -364,10 +367,22 @@ function parsePluginConfig(
                     prunedLeaves.push(result.removed);
                 }
             }
-            patched[key] = prunedBlock;
-            const reason = customMessagesByKey.get(key);
+            if (prunedLeaves.length === issuePaths.length) {
+                patched[key] = prunedBlock;
+                const reason = customMessagesByKey.get(key);
+                warnings.push(
+                    `"${key}": invalid nested field(s) ${prunedLeaves.map((leaf) => `"${key}.${leaf}"`).join(", ")}, using defaults for those.${reason ? ` ${reason}` : ""}`,
+                );
+                continue;
+            }
+        }
+
+        // Root-level or unreachable agent errors cannot be repaired safely because
+        // guessing a model configuration could select an expensive unintended model.
+        if (isAgentConfig) {
+            delete patched[key];
             warnings.push(
-                `"${key}": invalid nested field(s) ${prunedLeaves.map((l) => `"${l}"`).join(", ")}, using defaults for those.${reason ? ` ${reason}` : ""}`,
+                `"${key}": invalid agent configuration, ignoring. Check your magic-context.jsonc.`,
             );
             continue;
         }