@retaw106/mmc-oc 0.0.0-stage → 1.2.2

package/src/config/index.test.ts

@@ -0,0 +1,1252 @@
+import { describe, expect, it } from "bun:test";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { resolveEpochFloorForPass } from "../features/magic-context/storage-meta-persisted";
+import { resolveHistorianModel } from "../shared/model-resolution";
+import { Database } from "../shared/sqlite";
+import { createTestTempDir, createTestTempDirFromPath } from "../shared/test-temp-dir";
+import {
+    getWindowOverlay,
+    reloadWindowOverlay,
+    setWindowOverlayPath,
+} from "../shared/window-geometry";
+import { loadPluginConfig, loadPluginConfigDetailed } from "./index";
+import { resolveConfigProfile } from "./profiles";
+import { getProtectedTokensTierOverrides } from "./project-security";
+import { REMOVED_AGENT_CONFIG_WARNING } from "./removed-agent-config";
+
+/**
+ * Writes a mmc.jsonc file inside a fresh temp XDG_CONFIG_HOME tree
+ * and runs loadPluginConfig against it. Returns warnings + parsed config.
+ *
+ * Scope directory is NOT set — we pass a unique directory that does not
+ * contain a project config so only the user config is loaded.
+ */
+function loadWithUserConfig(configText: string, extraEnv: Record<string, string> = {}) {
+    const xdg = createTestTempDirFromPath(join(tmpdir(), "mc-config-test-"));
+    // The loader reads user config from <XDG>/opencode/ ($OPENCODE_CONFIG_DIR would win, but is unset here).
+    const configDir = join(xdg, "opencode");
+    const fs = require("node:fs") as typeof import("node:fs");
+    fs.mkdirSync(configDir, { recursive: true });
+    writeFileSync(join(configDir, "mmc.jsonc"), configText, "utf-8");
+
+    const origXdg = process.env.XDG_CONFIG_HOME;
+    const savedEnv: Record<string, string | undefined> = {};
+    for (const [k, v] of Object.entries(extraEnv)) {
+        savedEnv[k] = process.env[k];
+        process.env[k] = v;
+    }
+    process.env.XDG_CONFIG_HOME = xdg;
+
+    // Use a directory that definitely has no project config so only the
+    // user config feeds the loader. We use a sibling temp directory.
+    const projectDir = createTestTempDirFromPath(join(tmpdir(), "mc-config-proj-"));
+    try {
+        return loadPluginConfig(projectDir);
+    } finally {
+        if (origXdg === undefined) {
+            delete process.env.XDG_CONFIG_HOME;
+        } else {
+            process.env.XDG_CONFIG_HOME = origXdg;
+        }
+        for (const [k, v] of Object.entries(savedEnv)) {
+            if (v === undefined) delete process.env[k];
+            else process.env[k] = v;
+        }
+        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 */
+        }
+    }
+}
+
+function loadWithUserAndProjectConfig(
+    userConfigText: string,
+    projectConfigText: string,
+    extraEnv: Record<string, 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");
+    // User config at <XDG>/opencode/, project at <root>/.mmc/.
+    const configDir = join(xdg, "opencode");
+    fs.mkdirSync(configDir, { recursive: true });
+    fs.mkdirSync(join(projectDir, ".mmc"), { recursive: true });
+    writeFileSync(join(configDir, "mmc.jsonc"), userConfigText, "utf-8");
+    writeFileSync(join(projectDir, ".mmc", "mmc.jsonc"), projectConfigText, "utf-8");
+
+    const origXdg = process.env.XDG_CONFIG_HOME;
+    const savedEnv: Record<string, string | undefined> = {};
+    for (const [k, v] of Object.entries(extraEnv)) {
+        savedEnv[k] = process.env[k];
+        process.env[k] = v;
+    }
+    process.env.XDG_CONFIG_HOME = xdg;
+
+    try {
+        return loadPluginConfig(projectDir);
+    } finally {
+        if (origXdg === undefined) {
+            delete process.env.XDG_CONFIG_HOME;
+        } else {
+            process.env.XDG_CONFIG_HOME = origXdg;
+        }
+        for (const [k, v] of Object.entries(savedEnv)) {
+            if (v === undefined) delete process.env[k];
+            else process.env[k] = v;
+        }
+        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-"));
+        const overlayPath = join(overlayDir, "window-overlay.json");
+        const configText = JSON.stringify({ models: { window_overlay_path: overlayPath } });
+        const writeOverlay = (modelId: string) =>
+            writeFileSync(
+                overlayPath,
+                JSON.stringify({
+                    schema: "fusiform-window-overlay/v1",
+                    generated_at: "2026-09-01T00:00:00Z",
+                    minted_provider_ids: [],
+                    cells: [{ provider_id: "hunt-provider", model_id: modelId, facts: {} }],
+                }),
+            );
+
+        try {
+            writeOverlay("before-rewrite");
+            loadWithUserConfig(configText);
+            expect(getWindowOverlay()?.cells[0]?.model_id).toBe("before-rewrite");
+
+            writeOverlay("after-rewrite");
+            expect(getWindowOverlay()?.cells[0]?.model_id).toBe("before-rewrite");
+
+            loadWithUserConfig(configText);
+            expect(getWindowOverlay()?.cells[0]?.model_id).toBe("before-rewrite");
+
+            reloadWindowOverlay(overlayPath);
+            expect(getWindowOverlay()?.cells[0]?.model_id).toBe("after-rewrite");
+        } finally {
+            setWindowOverlayPath(undefined);
+            rmSync(overlayDir, { recursive: true, force: true });
+        }
+    });
+});
+
+describe("loadPluginConfig — preload user-config isolation", () => {
+    it("resolves schema-default config for a fixture with no config (#388)", () => {
+        const projectDir = createTestTempDirFromPath(join(tmpdir(), "mc-config-preload-fixture-"));
+        try {
+            // The test preload owns this default. A per-test XDG_CONFIG_HOME assignment
+            // still overrides it through loadWithUserConfig below.
+            expect(process.env.XDG_CONFIG_HOME).toContain("mc-plugin-test-xdg-pid-");
+            expect(loadPluginConfig(projectDir).cache_ttl).toBe("5m");
+        } finally {
+            rmSync(projectDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+        }
+    });
+
+    it("allows a test-scoped XDG_CONFIG_HOME to override the preload default", () => {
+        const preloadConfigHome = process.env.XDG_CONFIG_HOME;
+        const result = loadWithUserConfig(
+            JSON.stringify({
+                memory: { enabled: false },
+            }),
+        );
+
+        expect(result.memory.enabled).toBe(false);
+        expect(process.env.XDG_CONFIG_HOME).toBe(preloadConfigHome);
+    });
+});
+
+describe("loadPluginConfig — parse failure diagnostics", () => {
+    it("recovers the reporter's stray leading character and keeps a loud location warning", () => {
+        const result = loadWithUserConfig('\\{\n  "cache_ttl": "1h"\n}');
+
+        expect(result.cache_ttl).toBe("1h");
+        expect(result.configParseFailures).toHaveLength(1);
+        expect(result.configParseFailures?.[0]).toMatchObject({
+            warningClass: "file-parse",
+            line: 1,
+            column: 1,
+            recovered: true,
+            message: "invalid symbol",
+        });
+        expect(result.configWarnings?.[0]).toContain(":1:1: invalid symbol");
+    });
+
+    it("keeps file parse and invalid-leaf warning classes distinct", () => {
+        const parseResult = loadWithUserConfig('\\{\n  "cache_ttl": "1h"\n}');
+        const leafResult = loadWithUserConfig('{"protected_tokens":"bogus"}');
+
+        expect(parseResult.configWarningDetails?.[0]?.warningClass).toBe("file-parse");
+        expect(
+            leafResult.configWarningDetails?.some(
+                (detail) => detail.warningClass === "invalid-leaf",
+            ),
+        ).toBe(true);
+    });
+});
+
+describe("loadPluginConfig — secret redaction", () => {
+    it("does NOT leak resolved env values through Zod validation warnings", () => {
+        const secret = "sk-live-CARDINAL-SIN-IF-THIS-APPEARS-IN-LOGS";
+        const config = JSON.stringify({
+            // `historian_timeout_ms` has a minimum of 60_000. Feeding the
+            // substituted secret string here causes Zod to reject the field
+            // and route through the warning path we care about.
+            historian_timeout_ms: "{env:MC_TEST_SECRET}",
+        });
+
+        const result = loadWithUserConfig(config, { MC_TEST_SECRET: secret });
+        const warnings = result.configWarnings ?? [];
+
+        // The plugin should still load (enabled: true kept by recovery path).
+        expect(result.enabled).toBe(true);
+
+        // No warning or config field may contain the resolved secret.
+        const allText = JSON.stringify({ config: result, warnings });
+        expect(allText).not.toContain(secret);
+        expect(allText).not.toContain("CARDINAL-SIN");
+
+        // But the warnings should still describe what failed. We expect a
+        // warning mentioning historian_timeout_ms and the safe type summary.
+        const relevantWarning = warnings.find((w) => w.includes("historian_timeout_ms"));
+        expect(relevantWarning).toBeDefined();
+        expect(relevantWarning).toContain("invalid value");
+        // Must show type + length, not the value itself.
+        expect(relevantWarning).toMatch(/string, \d+ chars?/);
+    });
+
+    it("redacts long string values of any source (not just env-substituted)", () => {
+        // Verifies the redaction applies to plain invalid values too — we
+        // don't want to special-case env vs non-env because we can't tell
+        // them apart at the Zod layer.
+        const config = JSON.stringify({
+            historian_timeout_ms: "super-secret-plain-literal-that-should-not-leak",
+        });
+
+        const result = loadWithUserConfig(config);
+        const warnings = result.configWarnings ?? [];
+        const combined = warnings.join("\n");
+
+        expect(combined).not.toContain("super-secret-plain-literal-that-should-not-leak");
+        expect(combined).toMatch(/string, \d+ chars?/);
+    });
+
+    it("redacts nested object values to structural shape only", () => {
+        const config = JSON.stringify({
+            historian_timeout_ms: { nested: "secret-xyz", apiKey: "also-secret" },
+        });
+
+        const result = loadWithUserConfig(config);
+        const warnings = result.configWarnings ?? [];
+        const combined = warnings.join("\n");
+
+        expect(combined).not.toContain("secret-xyz");
+        expect(combined).not.toContain("also-secret");
+        expect(combined).toContain("object with keys");
+        expect(combined).toContain("nested");
+        expect(combined).toContain("apiKey");
+    });
+
+    it("recovers an invalid NESTED field without wiping valid siblings in the same block", () => {
+        // Regression: one bad nested field (memory.injection_budget_tokens as a
+        // string) must NOT delete the whole `memory` block — which would silently
+        // drop valid siblings like memory.auto_search.enabled. Recovery
+        // should prune only the invalid leaf and keep the rest.
+        const config = JSON.stringify({
+            memory: {
+                injection_budget_tokens: "not-a-number", // invalid nested leaf
+                auto_search: { enabled: false }, // valid sibling — must survive
+            },
+        });
+
+        const result = loadWithUserConfig(config);
+        const warnings = result.configWarnings ?? [];
+
+        expect(result.enabled).toBe(true);
+        // The valid sibling the user explicitly set must be preserved, not reset
+        // to the schema default (true).
+        expect(result.memory.auto_search.enabled).toBe(false);
+        // The invalid leaf falls back to its schema default.
+        expect(typeof result.memory.injection_budget_tokens).toBe("number");
+        // A warning should name the pruned nested field.
+        const w = warnings.find(
+            (x) => x.includes("memory") && x.includes("injection_budget_tokens"),
+        );
+        expect(w).toBeDefined();
+    });
+
+    it("prunes an invalid expansion template without losing valid siblings", () => {
+        const result = loadWithUserConfig(
+            JSON.stringify({
+                historian: {
+                    expand_tools: {
+                        ask: "${input.x.nope()}",
+                        peer_send: false,
+                        read: "Read ${input.path}",
+                    },
+                },
+            }),
+        );
+        expect(result.historian?.expand_tools?.ask).toBeUndefined();
+        expect(result.historian?.expand_tools?.peer_send).toBe(false);
+        expect(result.historian?.expand_tools?.read).toBe("Read ${input.path}");
+        expect(result.configWarnings?.join("\n")).toContain("historian.expand_tools.ask");
+    });
+
+    it("allows project expansion overrides without changing historian model authority", () => {
+        const result = loadWithUserAndProjectConfig(
+            JSON.stringify({
+                historian: {
+                    opencode: { model: "trusted/historian" },
+                    expand_tools: { ask: "Question ${input.question}", peer_send: false },
+                },
+            }),
+            JSON.stringify({
+                historian: {
+                    opencode: { model: "untrusted/historian" },
+                    expand_tools: { ask: false, board: '${input.ops.each("${op}")}' },
+                },
+            }),
+        );
+        expect(result.historian?.expand_tools).toEqual({
+            ask: false,
+            peer_send: false,
+            board: '${input.ops.each("${op}")}',
+        });
+        expect(result.historian?.opencode?.model).toBe("trusted/historian");
+    });
+
+    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
+        // the user diagnose.
+        const config = JSON.stringify({
+            execute_threshold_percentage: 5, // below min (20)
+        });
+
+        const result = loadWithUserConfig(config);
+        const warnings = result.configWarnings ?? [];
+        const combined = warnings.join("\n");
+
+        expect(combined).toContain("execute_threshold_percentage");
+        // `number 5` is the human-friendly safe render.
+        expect(combined).toMatch(/number 5/);
+    });
+
+    it("rejects execute_threshold_percentage > 90 with the cache-safety explanation (issue #111)", () => {
+        const config = JSON.stringify({
+            execute_threshold_percentage: 91, // above cap (90)
+        });
+
+        const result = loadWithUserConfig(config);
+        const warnings = result.configWarnings ?? [];
+        const combined = warnings.join("\n");
+
+        expect(combined).toContain("execute_threshold_percentage");
+        // The custom message explains WHY, not just "too big".
+        expect(combined).toContain("capped at 90% for cache safety");
+    });
+
+    it("honors user storage permissions while ignoring a project-tier override", () => {
+        const result = loadWithUserAndProjectConfig(
+            JSON.stringify({ storage: { enforce_private_permissions: false } }),
+            JSON.stringify({ storage: { enforce_private_permissions: true, futureSibling: 1 } }),
+        );
+
+        expect(result.storage.enforce_private_permissions).toBe(false);
+        expect(result.configWarnings?.join("\n")).toContain("storage.enforce_private_permissions");
+    });
+
+    it("rejects prototype-pollution keys before project security filtering and merging", () => {
+        const projectConfig = `{
+            "__proto__": {
+                "fail_closed_blocking": false,
+                "storage": { "enforce_private_permissions": false }
+            }
+        }`;
+
+        const result = loadWithUserAndProjectConfig("{}", projectConfig);
+
+        expect(result.fail_closed_blocking).toBe(true);
+        expect(result.storage.enforce_private_permissions).toBe(true);
+        expect(result.configWarnings?.join("\n")).toContain("prototype-pollution");
+    });
+});
+
+describe("loadPluginConfig — experimental graduation migration", () => {
+    // These cover the experimental.* → top-level/memory.* graduation chain.
+    it("is a no-op when no experimental block exists", () => {
+        const config = JSON.stringify({ enabled: true });
+        const result = loadWithUserConfig(config);
+        // No warning, no disruption.
+        expect(result.configWarnings).toBeUndefined();
+    });
+
+    it("temporal_awareness and memory.auto_search default ON; caveman default OFF", () => {
+        const result = loadWithUserConfig(JSON.stringify({ enabled: true }));
+        expect(result.temporal_awareness).toBe(true);
+        expect(result.memory.auto_search.enabled).toBe(true);
+        expect(result.caveman_text_compression.enabled).toBe(false);
+    });
+
+    it("relocates legacy experimental.* graduated keys to top-level + memory.* (run-doctor warning)", () => {
+        const config = JSON.stringify({
+            experimental: {
+                temporal_awareness: false,
+                auto_search: { enabled: false },
+                caveman_text_compression: { enabled: true, min_chars: 800 },
+            },
+        });
+        const result = loadWithUserConfig(config);
+        // Explicit user values survive the relocation (opt-outs/opt-ins preserved).
+        expect(result.temporal_awareness).toBe(false);
+        expect(result.caveman_text_compression.enabled).toBe(true);
+        expect(result.caveman_text_compression.min_chars).toBe(800);
+        // auto_search lands under memory.*
+        expect(result.memory.auto_search.enabled).toBe(false);
+        const warnings = result.configWarnings?.join("\n") ?? "";
+        expect(warnings).toContain("experimental.temporal_awareness");
+        expect(warnings).toContain('"memory.auto_search"');
+    });
+});
+
+describe("loadPluginConfig — legacy agent enabled migration", () => {
+    it("ignores the removed agent block with one warning", () => {
+        const removedKey = ["side", "kick"].join("");
+        const result = loadWithUserConfig(
+            JSON.stringify({
+                profile: "work",
+                [removedKey]: { enabled: false, model: "example/model" },
+                profiles: {
+                    work: {
+                        [removedKey]: { model: "example/profile-model" },
+                        historian: { opencode: { model: "example/historian" } },
+                    },
+                },
+            }),
+        );
+
+        expect(removedKey in result).toBe(false);
+        expect(result.historian?.opencode?.model).toBe("example/historian");
+        expect(result.configWarnings?.filter((warning) => warning.includes(removedKey))).toEqual([
+            `[config] ${REMOVED_AGENT_CONFIG_WARNING}`,
+        ]);
+    });
+
+    it("removes invalid historian.enabled and applies conflict rules", () => {
+        const result = loadWithUserConfig(
+            JSON.stringify({
+                historian: { enabled: false },
+            }),
+        );
+
+        expect(result.historian).toEqual({ two_pass: false, disallowed_tools: [] });
+        expect(result.configWarnings?.join("\n")).toContain(
+            'Removed invalid "historian.enabled" in-memory (run doctor to persist).',
+        );
+    });
+});
+
+describe("loadPluginConfig — variable expansion scope", () => {
+    it("keeps {env:} and {file:} expansion enabled for user config", () => {
+        const { dir: secretDir, cleanup } = createTestTempDir("mc-config-secret-");
+        const secretFile = join(secretDir, "secret.txt");
+        writeFileSync(secretFile, "file-secret", "utf-8");
+
+        try {
+            const result = loadWithUserConfig(
+                JSON.stringify({
+                    system_prompt_injection: {
+                        skip_signatures: ["{env:MC_USER_ENDPOINT}", `{file:${secretFile}}`],
+                    },
+                }),
+                { MC_USER_ENDPOINT: "http://user-env.test/v1" },
+            );
+
+            expect(result.system_prompt_injection.skip_signatures[0]).toBe(
+                "http://user-env.test/v1",
+            );
+            expect(result.system_prompt_injection.skip_signatures[1]).toBe("file-secret");
+            expect(result.configWarnings).toBeUndefined();
+        } finally {
+            cleanup();
+        }
+    });
+
+    it("leaves {env:} and {file:} tokens literal in project config and warns", () => {
+        const { cleanup } = createTestTempDir("mc-config-secret-");
+        try {
+            const result = loadWithUserAndProjectConfig(
+                JSON.stringify({ enabled: true }),
+                JSON.stringify({
+                    system_prompt_injection: { skip_signatures: ["{env:MC_PROJECT_ENDPOINT}"] },
+                }),
+                { MC_PROJECT_ENDPOINT: "http://project-env.test/v1" },
+            );
+
+            expect(result.system_prompt_injection.skip_signatures[0]).toBe(
+                "{env:MC_PROJECT_ENDPOINT}",
+            );
+            const warnings = result.configWarnings?.join("\n") ?? "";
+            expect(warnings).toContain("Project-level config no longer supports");
+            expect(warnings).toContain("security reasons");
+        } finally {
+            cleanup();
+        }
+    });
+});
+
+describe("loadPluginConfig — user-only settings", () => {
+    it("allows user config to disable auto_update", () => {
+        const result = loadWithUserConfig(JSON.stringify({ auto_update: false }));
+
+        expect(result.auto_update).toBe(false);
+    });
+
+    it("allows user config to opt in to an exact home project", () => {
+        const result = loadWithUserConfig(JSON.stringify({ allow_home_project: true }));
+
+        expect(result.allow_home_project).toBe(true);
+    });
+
+    it("prevents project config from opting in to a home project", () => {
+        const result = loadWithUserAndProjectConfig(
+            JSON.stringify({ allow_home_project: false }),
+            JSON.stringify({ allow_home_project: true }),
+        );
+
+        expect(result.allow_home_project).toBe(false);
+        expect(result.configWarnings?.join("\n")).toContain("Ignoring allow_home_project");
+    });
+
+    it("prevents project config from overriding user auto_update", () => {
+        const result = loadWithUserAndProjectConfig(
+            JSON.stringify({ auto_update: true, enabled: true }),
+            JSON.stringify({ auto_update: false, enabled: false }),
+        );
+
+        expect(result.auto_update).toBe(true);
+        expect(result.enabled).toBe(false);
+        expect(result.configWarnings?.join("\n")).toContain("Ignoring auto_update");
+    });
+
+    it("keeps historian model selection user-owned when project config tries to override it", () => {
+        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"],
+                    },
+                },
+            }),
+            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"],
+                    },
+                    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?.temperature).toBe(0.2);
+        const warnings = result.configWarnings?.join("\n") ?? "";
+        expect(warnings).toContain("historian.opencode.model");
+        expect(warnings).toContain("historian.pi.model");
+    });
+});
+
+describe("loadPluginConfig — project compaction trust boundary", () => {
+    it("keeps protected_tokens scalar-only at both tiers and preserves the user scalar on an invalid project leaf", () => {
+        const vectors = [
+            {
+                name: "user scalar",
+                user: { protected_tokens: 20_000 },
+                project: {},
+                expected: 20_000,
+                warns: false,
+            },
+            {
+                name: "user object",
+                user: { protected_tokens: { default: 20_000 } },
+                project: {},
+                expected: undefined,
+                warns: true,
+            },
+            {
+                name: "project scalar",
+                user: {},
+                project: { protected_tokens: 20_000 },
+                expected: 20_000,
+                warns: false,
+            },
+            {
+                name: "project object",
+                user: {},
+                project: { protected_tokens: { default: 20_000 } },
+                expected: undefined,
+                warns: true,
+            },
+            {
+                name: "invalid project object over user scalar",
+                user: { protected_tokens: 25_000 },
+                project: { protected_tokens: { default: 30_000 } },
+                expected: 25_000,
+                warns: true,
+            },
+        ] as const;
+
+        for (const vector of vectors) {
+            const result = loadWithUserAndProjectConfig(
+                JSON.stringify(vector.user),
+                JSON.stringify(vector.project),
+            );
+            expect(result.protected_tokens, vector.name).toBe(vector.expected);
+            const warned = (result.configWarnings ?? []).some((warning) =>
+                warning.includes("protected_tokens"),
+            );
+            expect(warned, vector.name).toBe(vector.warns);
+        }
+    });
+
+    it("rejects a project protected_tokens floor below the derived floor once geometry is known", () => {
+        const result = loadWithUserAndProjectConfig(
+            JSON.stringify({}),
+            JSON.stringify({ protected_tokens: 4_000 }),
+        );
+        const db = new Database(":memory:");
+        db.exec(`
+            CREATE TABLE session_meta (
+                session_id TEXT PRIMARY KEY,
+                harness TEXT NOT NULL DEFAULT 'opencode',
+                last_response_time INTEGER NOT NULL DEFAULT 0,
+                cache_ttl TEXT NOT NULL DEFAULT '5m',
+                counter INTEGER NOT NULL DEFAULT 0,
+                last_nudge_tokens INTEGER NOT NULL DEFAULT 0,
+                last_nudge_band TEXT NOT NULL DEFAULT '',
+                last_transform_error TEXT NOT NULL DEFAULT '',
+                is_subagent INTEGER NOT NULL DEFAULT 0,
+                last_context_percentage REAL NOT NULL DEFAULT 0,
+                last_input_tokens INTEGER NOT NULL DEFAULT 0,
+                observed_safe_input_tokens INTEGER NOT NULL DEFAULT 0,
+                cache_alert_sent INTEGER NOT NULL DEFAULT 0,
+                times_execute_threshold_reached INTEGER NOT NULL DEFAULT 0,
+                compartment_in_progress INTEGER NOT NULL DEFAULT 0,
+                system_prompt_hash TEXT NOT NULL DEFAULT '',
+                cleared_reasoning_through_tag INTEGER NOT NULL DEFAULT 0,
+                protected_tokens_effective INTEGER,
+                protected_tokens_pre_snapshot TEXT
+            )
+        `);
+        const warnings: string[] = [];
+        const tierOverrides = getProtectedTokensTierOverrides(result);
+
+        const resolved = resolveEpochFloorForPass(db, "loader-derived-floor", {
+            tierOverrides,
+            usableSoft: 200_000,
+            isCacheBustingPass: true,
+            onRejectedProjectOverride: (warning) => warnings.push(warning),
+        });
+        resolveEpochFloorForPass(db, "loader-derived-floor-next", {
+            tierOverrides,
+            usableSoft: 200_000,
+            isCacheBustingPass: true,
+            onRejectedProjectOverride: (warning) => warnings.push(warning),
+        });
+
+        expect(resolved.floor).toBe(16_000);
+        expect(warnings).toHaveLength(1);
+        expect(warnings[0]).toContain("protected_tokens=4000");
+        db.close();
+    });
+
+    it("ignores a lower project execute_threshold_percentage with a warning", () => {
+        const result = loadWithUserAndProjectConfig(
+            JSON.stringify({ execute_threshold_percentage: 60 }),
+            JSON.stringify({ execute_threshold_percentage: 50 }),
+        );
+
+        expect(result.execute_threshold_percentage).toBe(60);
+        expect(result.configWarnings?.join("\n")).toContain(
+            "Ignoring execute_threshold_percentage",
+        );
+    });
+
+    it("applies a higher project execute_threshold_percentage", () => {
+        const result = loadWithUserAndProjectConfig(
+            JSON.stringify({ execute_threshold_percentage: 60 }),
+            JSON.stringify({ execute_threshold_percentage: 70 }),
+        );
+
+        expect(result.execute_threshold_percentage).toBe(70);
+        expect(result.configWarnings?.join("\n") ?? "").not.toContain(
+            "execute_threshold_percentage",
+        );
+    });
+
+    it("ignores a lower project execute_threshold_tokens.default with a warning", () => {
+        const result = loadWithUserAndProjectConfig(
+            JSON.stringify({ execute_threshold_tokens: { default: 12_000 } }),
+            JSON.stringify({ execute_threshold_tokens: { default: 9_000 } }),
+        );
+
+        expect(result.execute_threshold_tokens).toEqual({ default: 12_000 });
+        expect(result.configWarnings?.join("\n")).toContain(
+            "Ignoring execute_threshold_tokens.default",
+        );
+    });
+
+    it("applies a higher project execute_threshold_tokens.default", () => {
+        const result = loadWithUserAndProjectConfig(
+            JSON.stringify({ execute_threshold_tokens: { default: 12_000 } }),
+            JSON.stringify({ execute_threshold_tokens: { default: 18_000 } }),
+        );
+
+        expect(result.execute_threshold_tokens).toEqual({ default: 18_000 });
+    });
+});
+
+describe("loadPluginConfig — raw merge preserves user fields not set in project", () => {
+    // Regression for the 2026-05-12 embedding-wipe bug. Project configs that
+    // don't mention a defaulted field must inherit the user's explicit value
+    // instead of getting clobbered by the Zod default. Previously each source
+    // was parsed separately and Zod-filled defaults appeared as if they were
+    // explicit project overrides.
+
+    it("user object field survives when project config omits it", () => {
+        const userConfig = JSON.stringify({
+            memory: { enabled: false },
+        });
+        const projectConfig = JSON.stringify({ smart_drops: true });
+
+        const result = loadWithUserAndProjectConfig(userConfig, projectConfig);
+
+        expect(result.memory.enabled).toBe(false);
+        expect(result.smart_drops).toBe(true);
+    });
+
+    it("user scalar field survives when project omits it", () => {
+        // execute_threshold_percentage default is { default: 65, ... }. User
+        // sets a value, project doesn't mention it — user must win.
+        const result = loadWithUserAndProjectConfig(
+            JSON.stringify({ execute_threshold_percentage: 30, enabled: true }),
+            JSON.stringify({ smart_drops: false }),
+        );
+
+        // execute_threshold_percentage min is 20, so 30 is valid
+        expect(result.execute_threshold_percentage).toBe(30);
+    });
+
+    it("project boolean override beats user default", () => {
+        // User omits smart_drops (default false). Project turns it on.
+        const result = loadWithUserAndProjectConfig(
+            JSON.stringify({ enabled: true }),
+            JSON.stringify({ smart_drops: true }),
+        );
+
+        expect(result.smart_drops).toBe(true);
+    });
+
+    it("ignores the removed mmc_reduce_enabled key without failing parse", () => {
+        const result = loadWithUserAndProjectConfig(
+            JSON.stringify({ mmc_reduce_enabled: false, execute_threshold_percentage: 30 }),
+            JSON.stringify({}),
+        );
+
+        expect(result.execute_threshold_percentage).toBe(30);
+        expect("mmc_reduce_enabled" in result).toBe(false);
+    });
+
+    it("disabled_hooks union-merges across user and project", () => {
+        const result = loadWithUserAndProjectConfig(
+            JSON.stringify({ disabled_hooks: ["a", "b"] }),
+            JSON.stringify({ disabled_hooks: ["b", "c"] }),
+        );
+
+        expect(result.disabled_hooks?.sort()).toEqual(["a", "b", "c"]);
+    });
+});
+
+describe("loadPluginConfig — user-owned model profiles", () => {
+    it("merges user base, selected profile, then project config without losing profile fallback qualifiers", () => {
+        const result = loadWithUserAndProjectConfig(
+            JSON.stringify({
+                profile: "personal",
+                historian: {
+                    two_pass: true,
+                    opencode: {
+                        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" },
+                                ],
+                            },
+                        },
+                    },
+                    personal: {
+                        historian: { opencode: { model: "anthropic/personal-historian" } },
+                    },
+                },
+            }),
+            JSON.stringify({
+                profile: "work",
+                memory: { enabled: false },
+            }),
+        );
+
+        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" }],
+        });
+    });
+
+    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" } },
+            profiles: {
+                personal: { historian: { opencode: { model: "anthropic/personal" } } },
+                work: { historian: { opencode: { model: "anthropic/work" } } },
+            },
+        });
+
+        const userDefault = loadWithUserAndProjectConfig(userConfig, "{}");
+        const projectOverride = loadWithUserAndProjectConfig(userConfig, '{"profile":"work"}');
+        const unknownProject = loadWithUserAndProjectConfig(userConfig, '{"profile":"missing"}');
+
+        expect(userDefault.profile).toBe("personal");
+        expect(userDefault.historian?.opencode?.model).toBe("anthropic/personal");
+        expect(projectOverride.profile).toBe("work");
+        expect(projectOverride.historian?.opencode?.model).toBe("anthropic/work");
+        expect(unknownProject.profile).toBeUndefined();
+        expect(unknownProject.enabled).toBe(true);
+        expect(unknownProject.historian?.opencode?.model).toBe("anthropic/base");
+        expect(unknownProject.configWarnings?.join("\n")).toContain(
+            'Unknown profile "missing" selected by project config',
+        );
+    });
+
+    it("rejects invalid profile definitions with a warning instead of applying their fields", () => {
+        const result = loadWithUserConfig(
+            JSON.stringify({
+                profile: "unsafe",
+                historian: { opencode: { model: "anthropic/base" } },
+                profiles: {
+                    unsafe: {
+                        historian: { two_pass: true },
+                    },
+                },
+            }),
+        );
+
+        expect(result.profile).toBeUndefined();
+        expect(result.historian?.opencode?.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("strips hostile project profile definitions while allowing only user-owned definitions", () => {
+        const result = loadWithUserAndProjectConfig(
+            JSON.stringify({
+                historian: { opencode: { model: "anthropic/user-base" } },
+            }),
+            JSON.stringify({
+                profile: "work",
+                profiles: {
+                    work: {
+                        historian: { opencode: { model: "attacker/project-profile" } },
+                    },
+                },
+            }),
+        );
+
+        expect(result.profile).toBeUndefined();
+        expect(result.historian?.opencode?.model).toBe("anthropic/user-base");
+        expect(result.configWarnings?.join("\n")).toContain(
+            "Ignoring profiles from project config",
+        );
+    });
+
+    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" } } } },
+        });
+        const base = loadWithUserConfig(userConfig);
+        const { configWarnings: _baseWarnings, ...baseWithoutWarnings } = base;
+        const hostileNames = [
+            "__proto__",
+            "constructor",
+            "prototype",
+            "toString",
+            "hasOwnProperty",
+            "valueOf",
+        ];
+
+        for (const name of hostileNames) {
+            const resolved = loadWithUserAndProjectConfig(
+                userConfig,
+                JSON.stringify({ profile: name }),
+            );
+            const { configWarnings: _warnings, ...resolvedWithoutWarnings } = resolved;
+
+            expect(resolved.profile).toBeUndefined();
+            expect(resolved.configWarnings?.join("\n")).toContain(
+                `Unknown profile "${name}" selected by project config`,
+            );
+            expect(resolvedWithoutWarnings).toEqual(baseWithoutWarnings);
+        }
+    });
+
+    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" } } };
+        // 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,
+        });
+        const knownProfile = Object.assign(Object.create(null), {
+            historian: profileHistorian,
+        });
+        const profiles = Object.assign(Object.create(null), {
+            known: knownProfile,
+        }) as Record<string, unknown>;
+        Object.defineProperty(Object.prototype, profileName, {
+            value: { historian: { opencode: { model: "attacker/inherited-overlay" } } },
+            enumerable: true,
+            configurable: true,
+        });
+
+        try {
+            const resolution = resolveConfigProfile({
+                userRaw: {
+                    ...userBase,
+                    profiles,
+                },
+                projectRaw: { profile: profileName },
+            });
+
+            expect(resolution.activeProfile).toBeUndefined();
+            expect(resolution.overlay).toEqual({});
+            expect(resolution.userBase).toEqual(userBase);
+            expect(resolution.projectBase).toEqual({});
+            expect(resolution.warnings).toEqual([
+                `Unknown profile "${profileName}" selected by project config; using base config without a profile.`,
+            ]);
+        } finally {
+            if (previousDescriptor) {
+                Object.defineProperty(Object.prototype, profileName, previousDescriptor);
+            } else {
+                delete (Object.prototype as Record<string, unknown>)[profileName];
+            }
+        }
+    });
+
+    it("treats empty, null, and non-string project selectors as no selection", () => {
+        const userConfig = JSON.stringify({
+            profile: "personal",
+            historian: { opencode: { model: "anthropic/base" } },
+            profiles: {
+                personal: { historian: { opencode: { model: "anthropic/personal" } } },
+            },
+        });
+        const invalidProjectSelectors = ["", null, { name: "work" }];
+
+        for (const profile of invalidProjectSelectors) {
+            const result = loadWithUserAndProjectConfig(userConfig, JSON.stringify({ profile }));
+
+            expect(result.profile).toBe("personal");
+            expect(result.historian?.opencode?.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",
+        };
+        const result = loadWithUserConfig(
+            JSON.stringify({
+                profile: "work",
+                historian: {
+                    opencode: { model: "anthropic/base-opencode" },
+                    pi: piBase,
+                },
+                profiles: {
+                    work: {
+                        historian: { opencode: { model: "anthropic/work-opencode" } },
+                    },
+                },
+            }),
+        );
+
+        expect(result.historian?.opencode).toEqual({ model: "anthropic/work-opencode" });
+        expect(result.historian?.pi).toEqual(piBase);
+    });
+
+    it("replaces a base fallback_models array wholesale when a profile provides one", () => {
+        const result = loadWithUserConfig(
+            JSON.stringify({
+                profile: "work",
+                historian: {
+                    opencode: {
+                        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" }],
+                            },
+                        },
+                    },
+                },
+            }),
+        );
+
+        expect(result.historian?.opencode?.fallback_models).toEqual([
+            { model: "google/work-only", variant: "medium" },
+        ]);
+    });
+
+    it("resolves profiles independently for two projects in one process", () => {
+        const xdg = createTestTempDirFromPath(join(tmpdir(), "mc-profile-isolation-user-"));
+        const projectA = createTestTempDirFromPath(join(tmpdir(), "mc-profile-isolation-a-"));
+        const projectB = createTestTempDirFromPath(join(tmpdir(), "mc-profile-isolation-b-"));
+        const previousXdg = process.env.XDG_CONFIG_HOME;
+        mkdirSync(join(xdg, "opencode"), { recursive: true });
+        mkdirSync(join(projectA, ".mmc"), { recursive: true });
+        mkdirSync(join(projectB, ".mmc"), { recursive: true });
+        writeFileSync(
+            join(xdg, "opencode", "mmc.jsonc"),
+            JSON.stringify({
+                profiles: {
+                    work: { historian: { opencode: { model: "anthropic/work" } } },
+                    personal: {
+                        historian: { opencode: { model: "anthropic/personal" } },
+                    },
+                },
+            }),
+        );
+        writeFileSync(join(projectA, ".mmc", "mmc.jsonc"), '{"profile":"work"}');
+        writeFileSync(join(projectB, ".mmc", "mmc.jsonc"), '{"profile":"personal"}');
+        process.env.XDG_CONFIG_HOME = xdg;
+        try {
+            const work = loadPluginConfig(projectA);
+            const personal = loadPluginConfig(projectB);
+            const workAgain = loadPluginConfig(projectA);
+            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");
+        } finally {
+            if (previousXdg === undefined) delete process.env.XDG_CONFIG_HOME;
+            else process.env.XDG_CONFIG_HOME = previousXdg;
+            rmSync(xdg, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+            rmSync(projectA, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+            rmSync(projectB, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 });
+        }
+    });
+
+    it("feeds the selected profile through the existing historian model resolver", () => {
+        const config = loadWithUserAndProjectConfig(
+            JSON.stringify({
+                profiles: {
+                    work: {
+                        historian: {
+                            opencode: {
+                                model: { model: "anthropic/work", variant: "high" },
+                                fallback_models: [
+                                    { model: "openai/work-fallback", variant: "low" },
+                                ],
+                            },
+                        },
+                    },
+                },
+            }),
+            '{"profile":"work"}',
+        );
+
+        // Profile selection changes only the normal resolved model input. The
+        // existing model-switch identity path still sees canonical model IDs and
+        // qualifier-distinct fallback attempts; profiles add no separate cache-bust class.
+        expect(resolveHistorianModel(config, "opencode")).toEqual({
+            primary: { model: "anthropic/work", qualifier: "high" },
+            fallbacks: [{ model: "openai/work-fallback", qualifier: "low" }],
+        });
+    });
+});
+
+describe("loadPluginConfigDetailed — prompt-surface registration owner", () => {
+    it("captures the user default before project guidance routing is merged", () => {
+        const xdg = createTestTempDirFromPath(join(tmpdir(), "mc-config-prompt-surface-"));
+        const projectDir = createTestTempDirFromPath(join(tmpdir(), "mc-project-prompt-surface-"));
+        const fs = require("node:fs") as typeof import("node:fs");
+        const userDir = join(xdg, "opencode");
+        const projectConfigDir = join(projectDir, ".mmc");
+        fs.mkdirSync(userDir, { recursive: true });
+        fs.mkdirSync(projectConfigDir, { recursive: true });
+        writeFileSync(
+            join(userDir, "mmc.jsonc"),
+            JSON.stringify({
+                prompt_surface: {
+                    default: "light",
+                    guidance_override_path: "guidance.md",
+                    tool_descriptions: { mmc_search: "user text" },
+                },
+            }),
+        );
+        writeFileSync(
+            join(projectConfigDir, "mmc.jsonc"),
+            JSON.stringify({
+                prompt_surface: {
+                    default: "full",
+                    models: { "openai/*": "light" },
+                },
+            }),
+        );
+        const originalXdg = process.env.XDG_CONFIG_HOME;
+        process.env.XDG_CONFIG_HOME = xdg;
+
+        try {
+            const result = loadPluginConfigDetailed(projectDir);
+            expect(result.config.prompt_surface).toEqual({
+                default: "full",
+                models: { "openai/*": "light" },
+                guidance_override_path: "guidance.md",
+                tool_descriptions: { mmc_search: "user text" },
+            });
+            expect(result.registrationPromptSurface).toEqual({
+                default: "light",
+                guidance_override_path: "guidance.md",
+                tool_descriptions: { mmc_search: "user text" },
+            });
+        } finally {
+            if (originalXdg === undefined) delete process.env.XDG_CONFIG_HOME;
+            else process.env.XDG_CONFIG_HOME = originalXdg;
+            rmSync(xdg, { recursive: true, force: true });
+            rmSync(projectDir, { recursive: true, force: true });
+        }
+    });
+});
+
+describe("shared per-harness config loading", () => {
+    it("lets OpenCode load Pi agent blocks without schema recovery warnings", () => {
+        const config = loadWithUserConfig(
+            JSON.stringify({
+                historian: {
+                    opencode: { model: "anthropic/opencode-historian" },
+                    pi: { model: "anthropic/pi-historian", thinking_level: "high" },
+                },
+            }),
+        );
+
+        expect(config.configWarnings).toBeUndefined();
+        expect(resolveHistorianModel(config, "opencode").primary?.model).toBe(
+            "anthropic/opencode-historian",
+        );
+    });
+});