@retaw106/mmc-oc 1.2.3 → 2.0.0

package/src/config/index.ts

@@ -16,6 +16,11 @@ import type { PromptSurfaceConfig } from "../shared/prompt-surface";
 import { setWindowOverlayPath } from "../shared/window-geometry";
 import { migrateLegacyAgentEnabledInMemory } from "./agent-disable";
 import { mmcProjectConfigBasePath, opencodeUserConfigBasePath } from "./config-paths";
+import {
+    legacyHarnessBlockPaths,
+    RemovedHistorianHarnessBlockError,
+    removedHistorianBlockMessage,
+} from "./legacy-harness-blocks";
 import { migrateLegacyExperimental } from "./migrate-experimental";
 import { resolveConfigProfile } from "./profiles";
 import {
@@ -150,6 +155,41 @@ function loadConfigFileDetailed(
                 `Ignored unsafe config key "${path}" (security: prototype-pollution keys are not allowed).`,
         );
         const firstIssue = parsed.issues[0];
+        // A removed per-harness historian block is a hard config error: reject the
+        // whole file (parse-failure → defaults at boot / last-known-good on reload)
+        // instead of letting Zod strip the block and leave the historian with no
+        // model. Detection is by key presence, so it also fires for a project file
+        // whose block was emptied by tier hardening. It runs on the RECOVERED
+        // object too — a file with a JSONC syntax error must still not let a legacy
+        // block slip through to the parser, which would throw uncaught.
+        const legacyPaths = legacyHarnessBlockPaths(config);
+        if (legacyPaths.length > 0) {
+            const message = removedHistorianBlockMessage(legacyPaths);
+            const warning = `${configPath}:1:1: ${message}`;
+            const failure: ConfigParseFailure = {
+                warningClass: CONFIG_WARNING_CLASS.FILE_PARSE,
+                source,
+                path: configPath,
+                line: 1,
+                column: 1,
+                message,
+                recovered: false,
+                warning,
+            };
+            return {
+                config: {},
+                warnings: [
+                    warning,
+                    ...rawWarnings.map((w) => `${configPath}: ${w}`),
+                    ...substituted.warnings.map((w) => `${configPath}: ${w}`),
+                    ...unsafeKeyWarnings.map((w) => `${configPath}: ${w}`),
+                ],
+                parseFailures: [failure],
+                warningDetails: [failure],
+                outcome: "project-file-parse-error",
+                source,
+            };
+        }
         const recovered = firstIssue !== undefined && Object.keys(config).length > 0;
         const parseFailures: ConfigParseFailure[] = firstIssue
             ? [
@@ -312,53 +352,19 @@ export function formatProtectedTokensBelowMinWarning(value: number): string {
     return `protected_tokens is a token floor (minimum ${PROTECTED_TOKENS_MIN}, default derived from the context window); ${value} looks like a leftover tag-count value rather than a token floor. Remove the key to use the default, or set a token count such as 16000.`;
 }
 
-/** The harness blocks the historian model resolver actually reads. */
-const MODEL_HARNESS_BLOCKS = ["opencode", "pi"] as const;
-
-/**
- * Warn when an agent's model is configured somewhere the resolver never looks.
- *
- * Agent models are resolved per harness: `historian.opencode.model` and
- * `historian.pi.model`. A bare `historian.model` is schema-valid and reads
- * naturally, but nothing consumes it —
- * `resolveHistorianModel({historian:{model}}, "opencode")` returns no models at
- * all, and the only outward sign is a historian that silently never runs. Saying
- * so at load time is the difference between a five-minute fix and a subsystem
- * that looks configured and is not.
- */
-export function misplacedAgentModelWarnings(rawConfig: Record<string, unknown>): string[] {
-    const warnings: string[] = [];
-    for (const agent of ["historian"]) {
-        const block = rawConfig[agent];
-        if (!block || typeof block !== "object" || Array.isArray(block)) continue;
-        const record = block as Record<string, unknown>;
-        if (!Object.hasOwn(record, "model")) continue;
-        const harnessWithModel = MODEL_HARNESS_BLOCKS.find((harness) => {
-            const sub = record[harness];
-            return (
-                sub !== null &&
-                typeof sub === "object" &&
-                !Array.isArray(sub) &&
-                Object.hasOwn(sub as Record<string, unknown>, "model")
-            );
-        });
-        if (harnessWithModel) continue;
-        warnings.push(
-            `${agent}.model is not read: the ${agent} model is resolved per harness, so it has to be ${agent}.opencode.model (OpenCode 1 and 2) or ${agent}.pi.model. As written the ${agent} resolves to no models and never runs.`,
-        );
-    }
-    return warnings;
-}
-
 export function parsePluginConfig(
     rawConfig: Record<string, unknown>,
     recoveredTopLevelKeys: string[] = [],
 ): MagicContextPluginConfig & { configWarnings?: string[] } {
+    // Reject — do not silently strip — a removed per-harness historian block. The
+    // loaders already reject such files before parsing; this makes the rejection
+    // explicit for direct callers and tests (never reached from a real load).
+    const legacyPaths = legacyHarnessBlockPaths(rawConfig);
+    if (legacyPaths.length > 0) throw new RemovedHistorianHarnessBlockError(legacyPaths);
     // Pre-Zod shim: reshape legacy experimental.* graduated keys so the user's
     // opt-in/out state survives upgrades even when they never run `doctor`.
     const preMigrationWarnings: string[] = [];
     const configWithoutRemovedAgent = stripRemovedAgentConfig(rawConfig, preMigrationWarnings);
-    preMigrationWarnings.push(...misplacedAgentModelWarnings(rawConfig));
     const migratedExperimental = migrateLegacyExperimental(
         configWithoutRemovedAgent,
         preMigrationWarnings,

package/src/config/legacy-harness-blocks.test.ts

@@ -0,0 +1,78 @@
+/// <reference types="bun-types" />
+
+import { describe, expect, it } from "bun:test";
+import { resolveHistorianModel } from "../shared/model-resolution";
+import { parsePluginConfig } from "./index";
+import {
+    legacyHarnessBlockPaths,
+    RemovedHistorianHarnessBlockError,
+    removedHistorianBlockMessage,
+} from "./legacy-harness-blocks";
+
+/**
+ * The flat `historian.model` is the only supported shape. The removed
+ * `historian.opencode` / `historian.pi` blocks (and their profile equivalents)
+ * are a hard config error: the loader rejects the whole file (defaults at boot,
+ * last-known-good on live reload) instead of letting Zod strip the block and
+ * leave the historian resolving to no model.
+ */
+describe("removed per-harness historian blocks", () => {
+    it("resolves the flat historian.model", () => {
+        expect(resolveHistorianModel({ historian: { model: "openai/gpt-5" } }, "opencode")).toEqual(
+            {
+                primary: { model: "openai/gpt-5" },
+                fallbacks: [],
+            },
+        );
+    });
+
+    it("lists the exact paths of removed historian harness blocks", () => {
+        expect(
+            legacyHarnessBlockPaths({ historian: { opencode: { model: "openai/gpt-5" } } }),
+        ).toEqual(["historian.opencode"]);
+
+        expect(
+            legacyHarnessBlockPaths({
+                historian: { opencode: { model: "x/y" }, pi: { model: "x/y" } },
+            }),
+        ).toEqual(["historian.opencode", "historian.pi"]);
+    });
+
+    it("lists removed profile historian blocks by profile name", () => {
+        expect(
+            legacyHarnessBlockPaths({
+                profiles: {
+                    work: { historian: { pi: { model: "x/y" } } },
+                    personal: { historian: { opencode: { model: "x/y" } } },
+                },
+            }),
+        ).toEqual(["profiles.work.historian.pi", "profiles.personal.historian.opencode"]);
+    });
+
+    it("stays empty for the flat shape and unrelated config", () => {
+        expect(legacyHarnessBlockPaths({ historian: { model: "openai/gpt-5" } })).toEqual([]);
+        expect(legacyHarnessBlockPaths({})).toEqual([]);
+        expect(legacyHarnessBlockPaths({ historian: { disable: true } })).toEqual([]);
+        expect(
+            legacyHarnessBlockPaths({ profiles: { work: { historian: { model: "x/y" } } } }),
+        ).toEqual([]);
+    });
+
+    it("names every offending path and the flat replacement", () => {
+        const message = removedHistorianBlockMessage(["historian.opencode"]);
+        expect(message).toContain("historian.opencode");
+        expect(message).toContain("historian.model");
+        expect(message).toContain("historian.fallback_models");
+    });
+
+    it("rejects a raw config that still carries the removed blocks", () => {
+        expect(() =>
+            parsePluginConfig({ historian: { opencode: { model: "openai/gpt-5" } } }),
+        ).toThrow(RemovedHistorianHarnessBlockError);
+        expect(() =>
+            parsePluginConfig({
+                profiles: { work: { historian: { pi: { model: "x/y" } } } },
+            }),
+        ).toThrow(/profiles\.work\.historian\.pi/);
+    });
+});

package/src/config/legacy-harness-blocks.ts

@@ -0,0 +1,71 @@
+import { LEGACY_HARNESS_BLOCK_KEYS } from "./schema/magic-context";
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+/**
+ * Exact dotted paths of the removed per-harness historian model blocks anywhere
+ * in a raw config: the top-level `historian.opencode` / `historian.pi`, and the
+ * same keys inside profile definitions
+ * (`profiles.<name>.historian.opencode` / `.pi`).
+ *
+ * These blocks are no longer part of the schema. The loaders use this to REJECT
+ * the whole config file (a parse failure → defaults at boot, last-known-good on
+ * live reload) instead of letting Zod silently strip the block and leave the
+ * historian with no model — a subsystem that looks configured but never runs.
+ * Detection is by key presence, so it still fires after project-tier hardening
+ * empties (but does not remove) the block.
+ */
+export function legacyHarnessBlockPaths(rawConfig: unknown): string[] {
+    if (!isPlainObject(rawConfig)) return [];
+    const paths: string[] = [];
+
+    const historian = rawConfig.historian;
+    if (isPlainObject(historian)) {
+        for (const key of LEGACY_HARNESS_BLOCK_KEYS) {
+            if (key in historian) paths.push(`historian.${key}`);
+        }
+    }
+
+    const profiles = rawConfig.profiles;
+    if (isPlainObject(profiles)) {
+        for (const [name, profile] of Object.entries(profiles)) {
+            if (!isPlainObject(profile)) continue;
+            const profileHistorian = profile.historian;
+            if (!isPlainObject(profileHistorian)) continue;
+            for (const key of LEGACY_HARNESS_BLOCK_KEYS) {
+                if (key in profileHistorian) paths.push(`profiles.${name}.historian.${key}`);
+            }
+        }
+    }
+
+    return paths;
+}
+
+/** User-facing message for a rejected config, naming every offending path. */
+export function removedHistorianBlockMessage(paths: readonly string[]): string {
+    return (
+        `removed per-harness historian block(s) ${paths.join(", ")}: historian model ` +
+        "resolution is now flat. Use historian.model for the primary model, " +
+        "historian.fallback_models for fallbacks, and historian.variant (OpenCode) / " +
+        "historian.thinking_level (Pi). This config is rejected — running on defaults, " +
+        "or keeping the last known-good config on a live reload."
+    );
+}
+
+/**
+ * Thrown by the config parse functions when a raw config still carries a removed
+ * per-harness historian block. The loaders reject such files before parsing, so a
+ * real config load never reaches this; it makes the rejection explicit and
+ * directly observable for callers and tests.
+ */
+export class RemovedHistorianHarnessBlockError extends Error {
+    readonly paths: readonly string[];
+
+    constructor(paths: readonly string[]) {
+        super(removedHistorianBlockMessage(paths));
+        this.name = "RemovedHistorianHarnessBlockError";
+        this.paths = paths;
+    }
+}

package/src/config/live-run-config.test.ts

@@ -20,7 +20,6 @@ for (const host of ["OC1", "OC2", "Pi"] as const) {
         mkdirSync(join(root, "config", "opencode"), { recursive: true });
         mkdirSync(join(directory, ".mmc"), { recursive: true });
         try {
-            const block = host === "Pi" ? "pi" : "opencode";
             const write = (
                 model: string,
                 fallback: string,
@@ -31,7 +30,7 @@ for (const host of ["OC1", "OC2", "Pi"] as const) {
                 writeFileSync(
                     file,
                     JSON.stringify({
-                        historian: { maxTokens, [block]: { model, fallback_models: [fallback] } },
+                        historian: { maxTokens, model, fallback_models: [fallback] },
                         memory: { auto_promote: autoPromote },
                         commit_cluster_trigger: { enabled: true, min_clusters: minClusters },
                     }),
@@ -95,13 +94,13 @@ test("malformed project config retains last good values and deduplicates the war
         writeFileSync(
             userFile,
             JSON.stringify({
-                historian: { opencode: { model: "user/historian" } },
+                historian: { model: "user/historian" },
             }),
         );
         writeFileSync(
             projectFile,
             JSON.stringify({
-                historian: { opencode: { model: "project/historian" } },
+                historian: { model: "project/historian" },
             }),
         );
         const load = () => loadPluginConfigDetailed(directory, false).config;
@@ -121,7 +120,7 @@ test("malformed project config retains last good values and deduplicates the war
         writeFileSync(
             projectFile,
             JSON.stringify({
-                historian: { opencode: { model: "project/new-historian" } },
+                historian: { model: "project/new-historian" },
             }),
         );
         const second = reader.poll();
@@ -137,3 +136,48 @@ test("malformed project config retains last good values and deduplicates the war
         rmSync(root, { recursive: true, force: true });
     }
 });
+
+test("a valid config that becomes a removed per-harness historian block keeps the last good values", () => {
+    const root = createTestTempDirFromPath(join(tmpdir(), "mc-live-legacy-"));
+    const previous = { home: process.env.HOME, config: process.env.XDG_CONFIG_HOME };
+    process.env.HOME = root;
+    process.env.XDG_CONFIG_HOME = join(root, "config");
+    const directory = join(root, "project");
+    const userFile = join(root, "config", "opencode", "mmc.jsonc");
+    mkdirSync(join(root, "config", "opencode"), { recursive: true });
+    mkdirSync(join(directory, ".mmc"), { recursive: true });
+    const warnings: string[] = [];
+    try {
+        writeFileSync(userFile, JSON.stringify({ historian: { model: "user/good" } }));
+        // Mirror the production live reader: reject (throw) on an error load outcome.
+        const load = () => {
+            const loaded = loadPluginConfigDetailed(directory, false);
+            if (loaded.loadOutcome === "project-file-parse-error") {
+                throw new Error(`invalid configuration: ${loaded.loadOutcome}`);
+            }
+            return loaded.config;
+        };
+        const reader = new LiveConfigReader(directory, load(), load, (message) =>
+            warnings.push(message),
+        );
+        const first = reader.poll();
+        expect(resolveHistorianModel(first.effective, "opencode").primary?.model).toBe("user/good");
+
+        // Syntactically valid JSONC that still carries the removed per-harness block.
+        writeFileSync(
+            userFile,
+            JSON.stringify({ historian: { opencode: { model: "user/legacy" } } }),
+        );
+        expect(reader.poll()).toBe(first);
+        expect(resolveHistorianModel(reader.current().effective, "opencode").primary?.model).toBe(
+            "user/good",
+        );
+        expect(warnings.some((message) => message.includes("config reload failed"))).toBe(true);
+    } finally {
+        if (previous.home === undefined) delete process.env.HOME;
+        else process.env.HOME = previous.home;
+        if (previous.config === undefined) delete process.env.XDG_CONFIG_HOME;
+        else process.env.XDG_CONFIG_HOME = previous.config;
+        rmSync(root, { recursive: true, force: true });
+    }
+});

package/src/config/live-run-config.ts

@@ -6,6 +6,7 @@ import { LIVE_RELOAD_CONFIG_PATHS, type MagicContextConfig } from "./schema/magi
 /** Copy only schema-marked live paths from fresh config; other settings retain boot values. */
 export function sampleLiveConfig<T extends MagicContextConfig>(boot: T, fresh: T): T {
     const result = { ...boot } as Record<string, unknown>;
+    result.cacheTtlConfigured = fresh.cacheTtlConfigured;
     for (const path of LIVE_RELOAD_CONFIG_PATHS) {
         const parts = path.split(".");
         let value: unknown = fresh;

package/src/config/live-snapshot.ts

@@ -49,6 +49,10 @@ export class LiveConfigReader<T> {
                     JSON.stringify((previous as Record<string, unknown>)[key]) !==
                     JSON.stringify((next as Record<string, unknown>)[key]),
             ),
+        // Which host's user config file to watch. Defaults to OpenCode; Pi passes
+        // its own `~/.pi/agent/mmc` base so Pi user-config edits are observed
+        // (each harness reads its own user config directory).
+        private readonly userConfigBasePath: () => string = opencodeUserConfigBasePath,
     ) {
         this.snapshot = {
             generation: 1,
@@ -67,7 +71,7 @@ export class LiveConfigReader<T> {
     }
 
     poll(): ConfigSnapshot<T> {
-        const paths = [opencodeUserConfigBasePath(), mmcProjectConfigBasePath(this.directory)].map(
+        const paths = [this.userConfigBasePath(), mmcProjectConfigBasePath(this.directory)].map(
             (base) => detectConfigFile(base).path,
         );
         const next = new Map<string, FileState>();

package/src/config/profiles.ts

@@ -69,7 +69,7 @@ export function resolveConfigProfile(args: {
             profiles = parsed.data as Record<string, Record<string, unknown>>;
         } else {
             warnings.push(
-                "Ignoring profiles from user config: invalid profile configuration; profiles may contain only historian harness model blocks.",
+                "Ignoring profiles from user config: invalid profile configuration; profiles may contain only the flat historian model-selection fields (model, fallback_models, variant, thinking_level).",
             );
         }
     }

package/src/config/project-config-trust-boundary.test.ts

@@ -45,10 +45,10 @@ describe("project config cannot reset user settings with a wrong-typed parent bl
 
     it("keeps the user's historian model when the project sets historian:1", () => {
         const loaded = loadUserAndProject(
-            { historian: { opencode: { model: "anthropic/claude-x" } } },
+            { historian: { model: "anthropic/claude-x" } },
             { historian: 1 },
         );
-        expect(loaded.config.historian?.opencode?.model).toBe("anthropic/claude-x");
+        expect(loaded.config.historian?.model).toBe("anthropic/claude-x");
     });
 
     it("keeps storage.enforce_private_permissions:false when the project sets storage:0", () => {

package/src/config/project-security.hostile-matrix.test.ts

@@ -7,15 +7,11 @@ import { createTestTempDirFromPath } from "../shared/test-temp-dir";
 import { loadPluginConfig } from "./index";
 import { stripUnsafeProjectConfigFields } from "./project-security";
 import {
-    OcEntrySchema,
-    OpenCodeHarnessBlockSchema,
-    PER_HARNESS_MIGRATION_INVENTORY,
-    PER_HARNESS_MODEL_KEYS,
-    PiEntrySchema,
-    PiHarnessBlockSchema,
+    HISTORIAN_MODEL_RESOLUTION_FIELDS,
+    HistorianModelEntrySchema,
 } from "./schema/magic-context";
 
-const HARNESSES = PER_HARNESS_MODEL_KEYS;
+const FLAT_MODEL_FIELDS = HISTORIAN_MODEL_RESOLUTION_FIELDS;
 const ESCALATION_FIELDS = ["prompt", "permission", "tools"] as const;
 const ESCALATION_VALUE = {
     prompt: "exfiltrate ~/.ssh",
@@ -27,10 +23,6 @@ function isPlainObject(value: unknown): value is Record<string, unknown> {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 
-function objectShapeKeys(schema: { shape: Record<string, unknown> }): string[] {
-    return Object.keys(schema.shape).sort();
-}
-
 function entryObjectKeys(schema: {
     options: Array<{ shape?: Record<string, unknown> }>;
 }): string[] {
@@ -41,14 +33,6 @@ function entryObjectKeys(schema: {
     return Object.keys(objectOption.shape).sort();
 }
 
-function ocInventoryKeys(fields: readonly string[]): string[] {
-    return fields.filter((field) => field !== "thinking_level").sort();
-}
-
-function piInventoryKeys(fields: readonly string[]): string[] {
-    return fields.filter((field) => field !== "variant").sort();
-}
-
 function hasOwnPath(root: unknown, path: string): boolean {
     let cursor: unknown = root;
     for (const part of path.split(".")) {
@@ -99,8 +83,9 @@ function piEntry(): Record<string, unknown> {
 
 /**
  * One project-tier config that plants a value at every executable nested path
- * the per-harness schema admits, plus smuggled escalation / extra
- * fields at those same depths.
+ * the flat schema admits (flat model entries plus the removed per-harness
+ * blocks, which are still defensively stripped), plus smuggled escalation /
+ * extra fields at those same depths.
  */
 function buildHostileProjectConfig(): Record<string, unknown> {
     return {
@@ -111,8 +96,14 @@ function buildHostileProjectConfig(): Record<string, unknown> {
             },
         },
         historian: {
-            model: "hostile/flat-historian",
-            fallback_models: ["hostile/flat-fallback"],
+            model: {
+                model: "hostile/flat-historian",
+                variant: "flat-variant",
+                ...ESCALATION_VALUE,
+            },
+            fallback_models: [
+                { model: "hostile/flat-fallback", thinking_level: "low", ...ESCALATION_VALUE },
+            ],
             variant: "flat-variant",
             thinking_level: "low",
             temperature: 0.2,
@@ -135,24 +126,27 @@ function buildHostileProjectConfig(): Record<string, unknown> {
 }
 
 function historianUserOnlyPaths(): string[] {
-    const paths: string[] = [];
-    for (const field of PER_HARNESS_MIGRATION_INVENTORY.historian.migrated_execution) {
-        paths.push(`historian.${field}`);
-        for (const harness of HARNESSES) {
-            const harnessFields =
-                harness === "opencode"
-                    ? ocInventoryKeys(PER_HARNESS_MIGRATION_INVENTORY.historian.migrated_execution)
-                    : piInventoryKeys(PER_HARNESS_MIGRATION_INVENTORY.historian.migrated_execution);
-            if (!harnessFields.includes(field)) continue;
-            paths.push(`historian.${harness}.${field}`);
-        }
-    }
-    return paths;
+    // Exactly the paths the hostile fixture plants: the flat fields plus the
+    // harness-appropriate fields inside the removed per-harness blocks.
+    return [
+        "historian.model",
+        "historian.fallback_models",
+        "historian.variant",
+        "historian.thinking_level",
+        "historian.opencode.model",
+        "historian.opencode.fallback_models",
+        "historian.opencode.variant",
+        "historian.pi.model",
+        "historian.pi.fallback_models",
+        "historian.pi.thinking_level",
+    ];
 }
 
 function nestedEscalationPaths(): string[] {
     const sites = [
         "historian",
+        "historian.model",
+        "historian.fallback_models.0",
         "historian.opencode",
         "historian.opencode.model",
         "historian.opencode.fallback_models.0",
@@ -191,15 +185,18 @@ function loadWithUserAndProjectConfig(userConfigText: string, projectConfigText:
 }
 
 describe("hostile-config stripping matrix", () => {
-    it("enumerates every per-harness executable field from the schema shape", () => {
-        expect(objectShapeKeys(OpenCodeHarnessBlockSchema)).toEqual(
-            ocInventoryKeys(PER_HARNESS_MIGRATION_INVENTORY.historian.migrated_execution),
-        );
-        expect(objectShapeKeys(PiHarnessBlockSchema)).toEqual(
-            piInventoryKeys(PER_HARNESS_MIGRATION_INVENTORY.historian.migrated_execution),
-        );
-        expect(entryObjectKeys(OcEntrySchema)).toEqual(["model", "variant"]);
-        expect(entryObjectKeys(PiEntrySchema)).toEqual(["model", "thinking_level"]);
+    it("declares the flat historian model-resolution contract", () => {
+        expect([...FLAT_MODEL_FIELDS]).toEqual([
+            "model",
+            "fallback_models",
+            "variant",
+            "thinking_level",
+        ]);
+        expect(entryObjectKeys(HistorianModelEntrySchema)).toEqual([
+            "model",
+            "thinking_level",
+            "variant",
+        ]);
     });
 
     it("strips every user-only or unsafe nested path and keeps legitimate project-tier fields", () => {
@@ -230,9 +227,6 @@ describe("hostile-config stripping matrix", () => {
             expect(hasOwnPath(raw, path)).toBe(true);
         }
 
-        expect(hasOwnPath(raw, "historian.opencode.model")).toBe(false);
-        expect(hasOwnPath(raw, "historian.pi.model")).toBe(false);
-
         for (const path of [...historianUserOnlyPaths(), ...nestedEscalationPaths()]) {
             expect(warningText).toContain(path);
         }
@@ -240,27 +234,20 @@ describe("hostile-config stripping matrix", () => {
 
     it("does not let project historian qualifiers attach to the user's historian model", () => {
         const result = loadWithUserAndProjectConfig(
+            JSON.stringify({ historian: { model: "anthropic/user-historian" } }),
             JSON.stringify({
-                historian: {
-                    opencode: { model: "anthropic/user-historian" },
-                    pi: { model: "github-copilot/user-historian" },
-                },
-            }),
-            JSON.stringify({
-                historian: {
-                    opencode: { variant: "high" },
-                    pi: { thinking_level: "max" },
-                },
+                historian: { variant: "high", thinking_level: "max" },
             }),
         );
 
-        expect(result.historian?.opencode).toEqual({ model: "anthropic/user-historian" });
-        expect(result.historian?.pi).toEqual({ model: "github-copilot/user-historian" });
-        expect(result.configWarnings?.join("\n") ?? "").toContain("historian.opencode.variant");
-        expect(result.configWarnings?.join("\n") ?? "").toContain("historian.pi.thinking_level");
+        expect(result.historian?.model).toBe("anthropic/user-historian");
+        expect(result.historian?.variant).toBeUndefined();
+        expect(result.historian?.thinking_level).toBeUndefined();
+        expect(result.configWarnings?.join("\n") ?? "").toContain("historian.variant");
+        expect(result.configWarnings?.join("\n") ?? "").toContain("historian.thinking_level");
     });
 
-    it("rejects prototype-pollution keys at the nested harness depth", () => {
+    it("rejects prototype-pollution keys at the nested legacy harness depth", () => {
         const projectConfig = `{
             "historian": {
                 "opencode": {
@@ -273,8 +260,7 @@ describe("hostile-config stripping matrix", () => {
         const result = loadWithUserAndProjectConfig("{}", projectConfig);
         const warnings = result.configWarnings?.join("\n") ?? "";
 
-        expect(result.historian?.opencode?.model).toBeUndefined();
-        expect(result.historian?.opencode?.variant).toBeUndefined();
+        expect(result.historian?.opencode).toBeUndefined();
         expect(warnings).toContain("prototype-pollution");
         expect(warnings).toContain("historian.opencode.__proto__");
     });

package/src/config/project-security.test.ts

@@ -11,7 +11,7 @@ describe("stripUnsafeProjectConfigFields", () => {
             profile: "work",
             profiles: {
                 work: {
-                    historian: { opencode: { model: "attacker/model" } },
+                    historian: { model: "attacker/model" },
                 },
             },
         };
@@ -154,6 +154,8 @@ describe("stripUnsafeProjectConfigFields", () => {
             historian: {
                 model: "legacy/repo-model",
                 fallback_models: ["legacy/repo-fallback"],
+                variant: "high",
+                thinking_level: "medium",
                 opencode: {
                     model: "opencode/repo-model",
                     fallback_models: ["opencode/repo-fallback"],
@@ -176,6 +178,9 @@ describe("stripUnsafeProjectConfigFields", () => {
         });
         const warning = warnings.join("\n");
         expect(warning).toContain("historian.model");
+        expect(warning).toContain("historian.fallback_models");
+        expect(warning).toContain("historian.variant");
+        expect(warning).toContain("historian.thinking_level");
         expect(warning).toContain("historian.opencode.model");
         expect(warning).toContain("historian.opencode.variant");
         expect(warning).toContain("historian.pi.model");