@retaw106/mmc-oc 1.2.2 → 2.0.0

package/src/config/index.test.ts

@@ -116,6 +116,46 @@ function loadWithUserAndProjectConfig(
     }
 }
 
+/**
+ * Like loadWithUserAndProjectConfig, but returns the full detailed load result
+ * so tests can assert loadOutcome / configParseFailures (config rejection).
+ * Omit projectConfigText to load only the user tier.
+ */
+function loadDetailedWithConfigs(userConfigText: string, projectConfigText?: string) {
+    const xdg = createTestTempDirFromPath(join(tmpdir(), "mc-config-test-"));
+    const projectDir = createTestTempDirFromPath(join(tmpdir(), "mc-config-proj-"));
+    const fs = require("node:fs") as typeof import("node:fs");
+    const configDir = join(xdg, "opencode");
+    fs.mkdirSync(configDir, { recursive: true });
+    writeFileSync(join(configDir, "mmc.jsonc"), userConfigText, "utf-8");
+    if (projectConfigText !== undefined) {
+        fs.mkdirSync(join(projectDir, ".mmc"), { recursive: true });
+        writeFileSync(join(projectDir, ".mmc", "mmc.jsonc"), projectConfigText, "utf-8");
+    }
+
+    const origXdg = process.env.XDG_CONFIG_HOME;
+    process.env.XDG_CONFIG_HOME = xdg;
+    try {
+        return loadPluginConfigDetailed(projectDir);
+    } finally {
+        if (origXdg === undefined) {
+            delete process.env.XDG_CONFIG_HOME;
+        } else {
+            process.env.XDG_CONFIG_HOME = origXdg;
+        }
+        try {
+            rmSync(xdg, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+        } catch {
+            /* Ignore EBUSY on Windows */
+        }
+        try {
+            rmSync(projectDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+        } catch {
+            /* Ignore EBUSY on Windows */
+        }
+    }
+}
+
 describe("loadPluginConfig — Fusiform overlay reload", () => {
     it("does not invalidate a same-path overlay during routine config reads", () => {
         const overlayDir = createTestTempDirFromPath(join(tmpdir(), "mc-config-overlay-"));
@@ -319,13 +359,13 @@ describe("loadPluginConfig — secret redaction", () => {
         const result = loadWithUserAndProjectConfig(
             JSON.stringify({
                 historian: {
-                    opencode: { model: "trusted/historian" },
+                    model: "trusted/historian",
                     expand_tools: { ask: "Question ${input.question}", peer_send: false },
                 },
             }),
             JSON.stringify({
                 historian: {
-                    opencode: { model: "untrusted/historian" },
+                    model: "untrusted/historian",
                     expand_tools: { ask: false, board: '${input.ops.each("${op}")}' },
                 },
             }),
@@ -335,41 +375,137 @@ describe("loadPluginConfig — secret redaction", () => {
             peer_send: false,
             board: '${input.ops.each("${op}")}',
         });
-        expect(result.historian?.opencode?.model).toBe("trusted/historian");
+        expect(result.historian?.model).toBe("trusted/historian");
     });
 
-    it("prunes only cross-harness qualifier leaves and names their full paths", () => {
+    it("accepts the flat qualifiers without treating them as an agent-config error", () => {
         const result = loadWithUserConfig(
             JSON.stringify({
                 historian: {
                     two_pass: true,
-                    opencode: {
+                    model: {
                         model: "anthropic/claude-sonnet",
                         variant: "high",
-                        thinking_level: "minimal",
-                    },
-                    pi: {
-                        model: "github-copilot/gpt-5",
                         thinking_level: "medium",
-                        variant: "fast",
                     },
+                    variant: "fast",
                 },
             }),
         );
 
         expect(result.historian?.two_pass).toBe(true);
-        expect(result.historian?.opencode).toEqual({
+        expect(result.historian?.model).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");
+        expect(result.historian?.variant).toBe("fast");
+        expect(result.configWarnings?.join("\n") ?? "").not.toContain(
+            "invalid agent configuration, ignoring",
+        );
+    });
+
+    it("rejects a user config that still carries the removed per-harness historian blocks", () => {
+        const detailed = loadDetailedWithConfigs(
+            JSON.stringify({
+                historian: {
+                    two_pass: true,
+                    opencode: { model: "anthropic/claude-sonnet", variant: "high" },
+                    pi: { model: "github-copilot/gpt-5", thinking_level: "medium" },
+                },
+            }),
+        );
+
+        // The whole file is rejected: a parse-failure outcome (defaults at boot,
+        // last-known-good on live reload), not a silent strip of the block.
+        expect(detailed.loadOutcome).toBe("project-file-parse-error");
+        expect(detailed.sources.userConfig).toBe("project-file-parse-error");
+        expect(detailed.config.historian?.two_pass).toBeUndefined();
+        const failures = detailed.configParseFailures.map((f) => f.message).join("\n");
+        expect(failures).toContain("historian.opencode");
+        expect(failures).toContain("historian.pi");
+    });
+
+    it("rejects a project config that still carries the removed per-harness historian blocks", () => {
+        const detailed = loadDetailedWithConfigs(
+            JSON.stringify({ historian: { model: "anthropic/user-base" } }),
+            JSON.stringify({
+                historian: {
+                    opencode: { model: "attacker/project-historian" },
+                    pi: { model: "attacker/project-historian" },
+                },
+            }),
+        );
+
+        expect(detailed.loadOutcome).toBe("project-file-parse-error");
+        expect(detailed.sources.projectConfig).toBe("project-file-parse-error");
+        // The project file is rejected before tier hardening, so the block is
+        // reported (not pre-stripped and invisible); the user base still applies.
+        expect(detailed.config.historian?.model).toBe("anthropic/user-base");
+        const failures = detailed.configParseFailures.map((f) => f.message).join("\n");
+        expect(failures).toContain("historian.opencode");
+        expect(failures).toContain("historian.pi");
+    });
+
+    it("still strips the legal flat model fields from a project config with a warning", () => {
+        const result = loadWithUserAndProjectConfig(
+            JSON.stringify({ historian: { model: "anthropic/user-base" } }),
+            JSON.stringify({
+                historian: {
+                    model: "attacker/project-model",
+                    fallback_models: ["attacker/project-fallback"],
+                    variant: "high",
+                    thinking_level: "high",
+                },
+            }),
+        );
+
+        expect(result.historian?.model).toBe("anthropic/user-base");
+        expect(result.configWarnings?.join("\n")).toContain("Ignoring historian.model");
+    });
+
+    it("rejects a user config whose legacy block survives JSONC partial recovery (no crash)", () => {
+        // A JSONC syntax error (`tru`) must not hide the removed block: recovery
+        // still yields historian.opencode, which must be rejected at load rather
+        // than handed to the parser (which would throw uncaught).
+        const detailed = loadDetailedWithConfigs(
+            '{"historian":{"opencode":{"model":"vendor/old"}},"enabled":tru}',
+        );
+
+        expect(detailed.loadOutcome).toBe("project-file-parse-error");
+        expect(detailed.sources.userConfig).toBe("project-file-parse-error");
+        expect(detailed.config.historian?.model).toBeUndefined();
+        expect(detailed.configParseFailures.every((f) => f.recovered === false)).toBe(true);
+        expect(detailed.configParseFailures.map((f) => f.message).join("\n")).toContain(
+            "historian.opencode",
+        );
+    });
+
+    it("rejects a user config whose UNSELECTED profile legacy block survives partial recovery", () => {
+        const detailed = loadDetailedWithConfigs(
+            '{"profiles":{"work":{"historian":{"pi":{"model":"x/y"}}}},"enabled":tru}',
+        );
+
+        expect(detailed.loadOutcome).toBe("project-file-parse-error");
+        expect(detailed.configParseFailures.every((f) => f.recovered === false)).toBe(true);
+        expect(detailed.configParseFailures.map((f) => f.message).join("\n")).toContain(
+            "profiles.work.historian.pi",
+        );
+    });
+
+    it("rejects a project config whose legacy block survives partial recovery while the user tier stays", () => {
+        const detailed = loadDetailedWithConfigs(
+            JSON.stringify({ historian: { model: "anthropic/user-base" } }),
+            '{"historian":{"opencode":{"model":"attacker/project"}},"enabled":tru}',
+        );
+
+        expect(detailed.loadOutcome).toBe("project-file-parse-error");
+        expect(detailed.sources.projectConfig).toBe("project-file-parse-error");
+        expect(detailed.config.historian?.model).toBe("anthropic/user-base");
+        expect(detailed.configParseFailures.every((f) => f.recovered === false)).toBe(true);
+        expect(detailed.configParseFailures.map((f) => f.message).join("\n")).toContain(
+            "historian.opencode",
+        );
     });
 
     it("still shows numeric and boolean invalid values (not secrets by nature)", () => {
@@ -476,14 +612,14 @@ describe("loadPluginConfig — legacy agent enabled migration", () => {
                 profiles: {
                     work: {
                         [removedKey]: { model: "example/profile-model" },
-                        historian: { opencode: { model: "example/historian" } },
+                        historian: { model: "example/historian" },
                     },
                 },
             }),
         );
 
         expect(removedKey in result).toBe(false);
-        expect(result.historian?.opencode?.model).toBe("example/historian");
+        expect(result.historian?.model).toBe("example/historian");
         expect(result.configWarnings?.filter((warning) => warning.includes(removedKey))).toEqual([
             `[config] ${REMOVED_AGENT_CONFIG_WARNING}`,
         ]);
@@ -590,43 +726,25 @@ describe("loadPluginConfig — user-only settings", () => {
         const result = loadWithUserAndProjectConfig(
             JSON.stringify({
                 historian: {
-                    opencode: {
-                        model: "anthropic/user-historian",
-                        fallback_models: ["anthropic/user-fallback"],
-                    },
-                    pi: {
-                        model: "github-copilot/user-historian",
-                        fallback_models: ["github-copilot/user-fallback"],
-                    },
+                    model: "anthropic/user-historian",
+                    fallback_models: ["anthropic/user-fallback"],
                 },
             }),
             JSON.stringify({
                 historian: {
-                    opencode: {
-                        model: "anthropic/project-historian",
-                        fallback_models: ["anthropic/project-fallback"],
-                    },
-                    pi: {
-                        model: "github-copilot/project-historian",
-                        fallback_models: ["github-copilot/project-fallback"],
-                    },
+                    model: "anthropic/project-historian",
+                    fallback_models: ["anthropic/project-fallback"],
                     temperature: 0.2,
                 },
             }),
         );
 
-        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?.model).toBe("anthropic/user-historian");
+        expect(result.historian?.fallback_models).toEqual(["anthropic/user-fallback"]);
         expect(result.historian?.temperature).toBe(0.2);
         const warnings = result.configWarnings?.join("\n") ?? "";
-        expect(warnings).toContain("historian.opencode.model");
-        expect(warnings).toContain("historian.pi.model");
+        expect(warnings).toContain("historian.model");
+        expect(warnings).toContain("historian.fallback_models");
     });
 });
 
@@ -796,6 +914,7 @@ describe("loadPluginConfig — raw merge preserves user fields not set in projec
         const result = loadWithUserAndProjectConfig(userConfig, projectConfig);
 
         expect(result.memory.enabled).toBe(false);
+        // Deprecated key still passes through the raw merge; runtime ignores it.
         expect(result.smart_drops).toBe(true);
     });
 
@@ -812,7 +931,7 @@ describe("loadPluginConfig — raw merge preserves user fields not set in projec
     });
 
     it("project boolean override beats user default", () => {
-        // User omits smart_drops (default false). Project turns it on.
+        // Deprecated smart_drops no longer gates supersession reclaim.
         const result = loadWithUserAndProjectConfig(
             JSON.stringify({ enabled: true }),
             JSON.stringify({ smart_drops: true }),
@@ -848,24 +967,18 @@ describe("loadPluginConfig — user-owned model profiles", () => {
                 profile: "personal",
                 historian: {
                     two_pass: true,
-                    opencode: {
-                        model: "anthropic/base-historian",
-                        fallback_models: ["anthropic/base-fallback"],
-                    },
+                    model: "anthropic/base-historian",
+                    fallback_models: ["anthropic/base-fallback"],
                 },
                 profiles: {
                     work: {
                         historian: {
-                            opencode: {
-                                model: { model: "anthropic/work-historian", variant: "high" },
-                                fallback_models: [
-                                    { model: "openai/work-fallback", variant: "low" },
-                                ],
-                            },
+                            model: { model: "anthropic/work-historian", variant: "high" },
+                            fallback_models: [{ model: "openai/work-fallback", variant: "low" }],
                         },
                     },
                     personal: {
-                        historian: { opencode: { model: "anthropic/personal-historian" } },
+                        historian: { model: "anthropic/personal-historian" },
                     },
                 },
             }),
@@ -878,19 +991,22 @@ describe("loadPluginConfig — user-owned model profiles", () => {
         expect(result.profile).toBe("work");
         expect(result.memory.enabled).toBe(false);
         expect(result.historian?.two_pass).toBe(true);
-        expect(result.historian?.opencode).toEqual({
-            model: { model: "anthropic/work-historian", variant: "high" },
-            fallback_models: [{ model: "openai/work-fallback", variant: "low" }],
+        expect(result.historian?.model).toEqual({
+            model: "anthropic/work-historian",
+            variant: "high",
         });
+        expect(result.historian?.fallback_models).toEqual([
+            { model: "openai/work-fallback", variant: "low" },
+        ]);
     });
 
     it("uses project selection over user selection and falls back to the base on an unknown name", () => {
         const userConfig = JSON.stringify({
             profile: "personal",
-            historian: { opencode: { model: "anthropic/base" } },
+            historian: { model: "anthropic/base" },
             profiles: {
-                personal: { historian: { opencode: { model: "anthropic/personal" } } },
-                work: { historian: { opencode: { model: "anthropic/work" } } },
+                personal: { historian: { model: "anthropic/personal" } },
+                work: { historian: { model: "anthropic/work" } },
             },
         });
 
@@ -899,12 +1015,12 @@ describe("loadPluginConfig — user-owned model profiles", () => {
         const unknownProject = loadWithUserAndProjectConfig(userConfig, '{"profile":"missing"}');
 
         expect(userDefault.profile).toBe("personal");
-        expect(userDefault.historian?.opencode?.model).toBe("anthropic/personal");
+        expect(userDefault.historian?.model).toBe("anthropic/personal");
         expect(projectOverride.profile).toBe("work");
-        expect(projectOverride.historian?.opencode?.model).toBe("anthropic/work");
+        expect(projectOverride.historian?.model).toBe("anthropic/work");
         expect(unknownProject.profile).toBeUndefined();
         expect(unknownProject.enabled).toBe(true);
-        expect(unknownProject.historian?.opencode?.model).toBe("anthropic/base");
+        expect(unknownProject.historian?.model).toBe("anthropic/base");
         expect(unknownProject.configWarnings?.join("\n")).toContain(
             'Unknown profile "missing" selected by project config',
         );
@@ -914,7 +1030,7 @@ describe("loadPluginConfig — user-owned model profiles", () => {
         const result = loadWithUserConfig(
             JSON.stringify({
                 profile: "unsafe",
-                historian: { opencode: { model: "anthropic/base" } },
+                historian: { model: "anthropic/base" },
                 profiles: {
                     unsafe: {
                         historian: { two_pass: true },
@@ -924,29 +1040,46 @@ describe("loadPluginConfig — user-owned model profiles", () => {
         );
 
         expect(result.profile).toBeUndefined();
-        expect(result.historian?.opencode?.model).toBe("anthropic/base");
+        expect(result.historian?.model).toBe("anthropic/base");
         // two_pass defaults to false; the profile's `true` must not leak through.
         expect(result.historian?.two_pass).toBe(false);
         expect(result.configWarnings?.join("\n")).toContain("Ignoring profiles from user config");
     });
 
+    it("rejects a user config whose profile still carries a removed per-harness block", () => {
+        const detailed = loadDetailedWithConfigs(
+            JSON.stringify({
+                profile: "work",
+                profiles: {
+                    work: { historian: { opencode: { model: "anthropic/x" } } },
+                },
+            }),
+        );
+
+        // No silent fallback to the base config: the whole file is rejected.
+        expect(detailed.loadOutcome).toBe("project-file-parse-error");
+        expect(detailed.config.profile).toBeUndefined();
+        const failures = detailed.configParseFailures.map((f) => f.message).join("\n");
+        expect(failures).toContain("profiles.work.historian.opencode");
+    });
+
     it("strips hostile project profile definitions while allowing only user-owned definitions", () => {
         const result = loadWithUserAndProjectConfig(
             JSON.stringify({
-                historian: { opencode: { model: "anthropic/user-base" } },
+                historian: { model: "anthropic/user-base" },
             }),
             JSON.stringify({
                 profile: "work",
                 profiles: {
                     work: {
-                        historian: { opencode: { model: "attacker/project-profile" } },
+                        historian: { model: "attacker/project-profile" },
                     },
                 },
             }),
         );
 
         expect(result.profile).toBeUndefined();
-        expect(result.historian?.opencode?.model).toBe("anthropic/user-base");
+        expect(result.historian?.model).toBe("anthropic/user-base");
         expect(result.configWarnings?.join("\n")).toContain(
             "Ignoring profiles from project config",
         );
@@ -954,8 +1087,8 @@ describe("loadPluginConfig — user-owned model profiles", () => {
 
     it("falls back loudly for inherited profile names without changing the resolved base config", () => {
         const userConfig = JSON.stringify({
-            historian: { opencode: { model: "anthropic/base", fallback_models: ["openai/base"] } },
-            profiles: { known: { historian: { opencode: { model: "anthropic/known" } } } },
+            historian: { model: "anthropic/base", fallback_models: ["openai/base"] },
+            profiles: { known: { historian: { model: "anthropic/known" } } },
         });
         const base = loadWithUserConfig(userConfig);
         const { configWarnings: _baseWarnings, ...baseWithoutWarnings } = base;
@@ -986,13 +1119,10 @@ describe("loadPluginConfig — user-owned model profiles", () => {
     it("ignores a profile inherited from a polluted Object prototype", () => {
         const profileName = "profile_overlay_pollution_canary";
         const previousDescriptor = Object.getOwnPropertyDescriptor(Object.prototype, profileName);
-        const userBase = { historian: { opencode: { model: "anthropic/base" } } };
+        const userBase = { historian: { model: "anthropic/base" } };
         // Null-prototype input isolates lookup behavior from strict schema validation of inherited data.
-        const profileOpenCode = Object.assign(Object.create(null), {
-            model: "anthropic/known",
-        });
         const profileHistorian = Object.assign(Object.create(null), {
-            opencode: profileOpenCode,
+            model: "anthropic/known",
         });
         const knownProfile = Object.assign(Object.create(null), {
             historian: profileHistorian,
@@ -1001,7 +1131,7 @@ describe("loadPluginConfig — user-owned model profiles", () => {
             known: knownProfile,
         }) as Record<string, unknown>;
         Object.defineProperty(Object.prototype, profileName, {
-            value: { historian: { opencode: { model: "attacker/inherited-overlay" } } },
+            value: { historian: { model: "attacker/inherited-overlay" } },
             enumerable: true,
             configurable: true,
         });
@@ -1034,9 +1164,9 @@ describe("loadPluginConfig — user-owned model profiles", () => {
     it("treats empty, null, and non-string project selectors as no selection", () => {
         const userConfig = JSON.stringify({
             profile: "personal",
-            historian: { opencode: { model: "anthropic/base" } },
+            historian: { model: "anthropic/base" },
             profiles: {
-                personal: { historian: { opencode: { model: "anthropic/personal" } } },
+                personal: { historian: { model: "anthropic/personal" } },
             },
         });
         const invalidProjectSelectors = ["", null, { name: "work" }];
@@ -1045,39 +1175,40 @@ describe("loadPluginConfig — user-owned model profiles", () => {
             const result = loadWithUserAndProjectConfig(userConfig, JSON.stringify({ profile }));
 
             expect(result.profile).toBe("personal");
-            expect(result.historian?.opencode?.model).toBe("anthropic/personal");
+            expect(result.historian?.model).toBe("anthropic/personal");
             expect(result.configWarnings?.join("\n")).toContain(
                 "Ignoring invalid profile selection from project config",
             );
         }
     });
 
-    it("preserves an untouched historian Pi block when a profile overlays OpenCode", () => {
-        const piBase = {
-            model: { model: "github-copilot/base", thinking_level: "high" },
-            fallback_models: [
-                { model: "openai/base-fallback", thinking_level: "minimal" },
-                { model: "github-copilot/second-base-fallback", thinking_level: "medium" },
-            ],
-            thinking_level: "high",
-        };
+    it("keeps base historian metadata when a profile overlays the model", () => {
         const result = loadWithUserConfig(
             JSON.stringify({
                 profile: "work",
                 historian: {
-                    opencode: { model: "anthropic/base-opencode" },
-                    pi: piBase,
+                    two_pass: true,
+                    model: "anthropic/base",
+                    expand_tools: { read: "Read ${input.path}" },
                 },
                 profiles: {
                     work: {
-                        historian: { opencode: { model: "anthropic/work-opencode" } },
+                        historian: {
+                            model: { model: "github-copilot/work", thinking_level: "high" },
+                            thinking_level: "medium",
+                        },
                     },
                 },
             }),
         );
 
-        expect(result.historian?.opencode).toEqual({ model: "anthropic/work-opencode" });
-        expect(result.historian?.pi).toEqual(piBase);
+        expect(result.historian?.two_pass).toBe(true);
+        expect(result.historian?.expand_tools).toEqual({ read: "Read ${input.path}" });
+        expect(result.historian?.model).toEqual({
+            model: "github-copilot/work",
+            thinking_level: "high",
+        });
+        expect(result.historian?.thinking_level).toBe("medium");
     });
 
     it("replaces a base fallback_models array wholesale when a profile provides one", () => {
@@ -1085,27 +1216,23 @@ describe("loadPluginConfig — user-owned model profiles", () => {
             JSON.stringify({
                 profile: "work",
                 historian: {
-                    opencode: {
-                        model: "anthropic/base",
-                        fallback_models: [
-                            { model: "openai/base-first", variant: "low" },
-                            { model: "anthropic/base-second", variant: "high" },
-                        ],
-                    },
+                    model: "anthropic/base",
+                    fallback_models: [
+                        { model: "openai/base-first", variant: "low" },
+                        { model: "anthropic/base-second", variant: "high" },
+                    ],
                 },
                 profiles: {
                     work: {
                         historian: {
-                            opencode: {
-                                fallback_models: [{ model: "google/work-only", variant: "medium" }],
-                            },
+                            fallback_models: [{ model: "google/work-only", variant: "medium" }],
                         },
                     },
                 },
             }),
         );
 
-        expect(result.historian?.opencode?.fallback_models).toEqual([
+        expect(result.historian?.fallback_models).toEqual([
             { model: "google/work-only", variant: "medium" },
         ]);
     });
@@ -1122,9 +1249,9 @@ describe("loadPluginConfig — user-owned model profiles", () => {
             join(xdg, "opencode", "mmc.jsonc"),
             JSON.stringify({
                 profiles: {
-                    work: { historian: { opencode: { model: "anthropic/work" } } },
+                    work: { historian: { model: "anthropic/work" } },
                     personal: {
-                        historian: { opencode: { model: "anthropic/personal" } },
+                        historian: { model: "anthropic/personal" },
                     },
                 },
             }),
@@ -1139,9 +1266,9 @@ describe("loadPluginConfig — user-owned model profiles", () => {
             expect(work.profile).toBe("work");
             expect(personal.profile).toBe("personal");
             expect(workAgain.profile).toBe("work");
-            expect(work.historian?.opencode?.model).toBe("anthropic/work");
-            expect(personal.historian?.opencode?.model).toBe("anthropic/personal");
-            expect(workAgain.historian?.opencode?.model).toBe("anthropic/work");
+            expect(work.historian?.model).toBe("anthropic/work");
+            expect(personal.historian?.model).toBe("anthropic/personal");
+            expect(workAgain.historian?.model).toBe("anthropic/work");
         } finally {
             if (previousXdg === undefined) delete process.env.XDG_CONFIG_HOME;
             else process.env.XDG_CONFIG_HOME = previousXdg;
@@ -1157,12 +1284,8 @@ describe("loadPluginConfig — user-owned model profiles", () => {
                 profiles: {
                     work: {
                         historian: {
-                            opencode: {
-                                model: { model: "anthropic/work", variant: "high" },
-                                fallback_models: [
-                                    { model: "openai/work-fallback", variant: "low" },
-                                ],
-                            },
+                            model: { model: "anthropic/work", variant: "high" },
+                            fallback_models: [{ model: "openai/work-fallback", variant: "low" }],
                         },
                     },
                 },
@@ -1233,20 +1356,28 @@ describe("loadPluginConfigDetailed — prompt-surface registration owner", () =>
     });
 });
 
-describe("shared per-harness config loading", () => {
-    it("lets OpenCode load Pi agent blocks without schema recovery warnings", () => {
+describe("shared flat historian config loading", () => {
+    it("resolves one flat entry for both harnesses without schema warnings", () => {
         const config = loadWithUserConfig(
             JSON.stringify({
                 historian: {
-                    opencode: { model: "anthropic/opencode-historian" },
-                    pi: { model: "anthropic/pi-historian", thinking_level: "high" },
+                    model: {
+                        model: "anthropic/shared-historian",
+                        variant: "high",
+                        thinking_level: "high",
+                    },
                 },
             }),
         );
 
         expect(config.configWarnings).toBeUndefined();
-        expect(resolveHistorianModel(config, "opencode").primary?.model).toBe(
-            "anthropic/opencode-historian",
-        );
+        expect(resolveHistorianModel(config, "opencode").primary).toEqual({
+            model: "anthropic/shared-historian",
+            qualifier: "high",
+        });
+        expect(resolveHistorianModel(config, "pi").primary).toEqual({
+            model: "anthropic/shared-historian",
+            qualifier: "high",
+        });
     });
 });