@retaw106/mmc-oc 1.2.3 → 2.0.0

package/src/config/project-security.ts

@@ -1,7 +1,7 @@
 import {
     DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE,
-    PER_HARNESS_MIGRATION_INVENTORY,
-    PER_HARNESS_MODEL_KEYS,
+    HISTORIAN_MODEL_RESOLUTION_FIELDS,
+    LEGACY_HARNESS_BLOCK_KEYS,
 } from "./schema/magic-context";
 
 /**
@@ -19,11 +19,13 @@ import {
 
 /** Hidden agents that run with elevated/autonomous capability. */
 const HIDDEN_AGENT_KEYS = ["historian"] as const;
-const HARNESS_KEYS = PER_HARNESS_MODEL_KEYS;
-/** Every historian model-resolution field, including per-harness qualifiers.
- *  Variant and thinking_level merge onto the user's historian model at resolve
- *  time, so leaving them would let a cloned repo force extra spend. */
-const HISTORIAN_USER_ONLY_FIELDS = PER_HARNESS_MIGRATION_INVENTORY.historian.migrated_execution;
+/** Removed per-harness historian blocks; iterated only to keep stripping
+ *  escalation fields out of a legacy block a cloned repo might still supply. */
+const HARNESS_KEYS = LEGACY_HARNESS_BLOCK_KEYS;
+/** Every flat historian model-resolution field, including the per-harness
+ *  qualifiers. Variant and thinking_level merge onto the user's historian model
+ *  at resolve time, so leaving them would let a cloned repo force extra spend. */
+const HISTORIAN_USER_ONLY_FIELDS = HISTORIAN_MODEL_RESOLUTION_FIELDS;
 const PROMPT_SURFACE_USER_ONLY_FIELDS = ["guidance_override_path", "tool_descriptions"] as const;
 
 /**
@@ -316,11 +318,10 @@ function makeProjectThresholdWarning(field: string, reason: string): string {
  *    owner-private to group-readable changes every session and memory's local
  *    confidentiality. Only the machine operator's user config may opt into an
  *    externally managed trusted-group deployment.
- *  - historian model-resolution fields (model, fallback_models, variant,
- *    thinking_level), including both per-harness blocks — historian model
- *    spend is user-level only. Qualifiers merge onto the user's historian
- *    model at resolve time, so a cloned repo cannot force extra thinking or
- *    variant cost.
+ *  - historian flat model-resolution fields (model, fallback_models, variant,
+ *    thinking_level), plus any legacy per-harness block — historian model spend
+ *    is user-level only. Qualifiers merge onto the user's historian model at
+ *    resolve time, so a cloned repo cannot force extra thinking or variant cost.
  *  - `pi.subagent_extensions` — a cloned repo must not choose which extensions
  *    the user's Pi child processes load.
  *  - `prompt_surface.guidance_override_path` / `tool_descriptions` — a repository

package/src/config/protected-tokens.test.ts

@@ -177,7 +177,7 @@ describe("protected_tokens config and derivation", () => {
 
     describe("root configuration reference", () => {
         const reference = readFileSync(
-            resolve(import.meta.dir, "../../../../CONFIGURATION.md"),
+            resolve(import.meta.dir, "../../../../docs/guides/配置说明.md"),
             "utf8",
         );
 

package/src/config/raw-loader.test.ts

@@ -1,389 +1,66 @@
 import { afterEach, describe, expect, it } from "bun:test";
-import {
-    chmodSync,
-    lstatSync,
-    readdirSync,
-    readFileSync,
-    readlinkSync,
-    rmSync,
-    statSync,
-    symlinkSync,
-    writeFileSync,
-} from "node:fs";
+import { existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-import { parseJsonc } from "../shared/jsonc-parser";
 import { createTestTempDirFromPath } from "../shared/test-temp-dir";
-import { hasFlatKeys, loadRawConfigFile, migrateFlatDetailed } from "./raw-loader";
-import { PER_HARNESS_MIGRATION_INVENTORY } from "./schema/magic-context";
+import { loadRawConfigFile } from "./raw-loader";
 
 const temporaryDirectories: string[] = [];
 
 function temporaryDirectory(): string {
-    const directory = createTestTempDirFromPath(join(tmpdir(), "mc-per-harness-"));
+    const directory = createTestTempDirFromPath(join(tmpdir(), "mc-raw-loader-"));
     temporaryDirectories.push(directory);
     return directory;
 }
 
-function parse(text: string): Record<string, unknown> {
-    const withoutBom = text.startsWith("\uFEFF") ? text.slice(1) : text;
-    return parseJsonc<Record<string, unknown>>(withoutBom);
-}
-
 afterEach(() => {
     for (const directory of temporaryDirectories.splice(0)) {
         rmSync(directory, { recursive: true, force: true });
     }
 });
 
-describe("per-harness raw config migration", () => {
-    it("maps flat agent and task fields without moving scheduling fields", () => {
-        const input = `\uFEFF{\r
-  // preserve this comment\r
-  "historian": {\r
-    "model": { "model": "provider/historian", "variant": "fast", "thinking_level": "high" }, // historian model note\r
-    "fallback_models": [{ "model": "provider/fallback", "variant": "careful", "thinking_level": "low" }],\r
-    "variant": "block-variant",\r
-    "thinking_level": "medium"\r
-  },\r
-  "unrelated": { "keep": true }\r
-}\r
-`;
-
-        const migrated = migrateFlatDetailed(Buffer.from(input, "utf-8"));
-        const repeated = migrateFlatDetailed(Buffer.from(input, "utf-8"));
-        const idempotent = migrateFlatDetailed(migrated.bytes);
-        const output = migrated.bytes.toString("utf-8");
-        const config = parse(output);
-        const historian = config.historian as Record<string, unknown>;
-        const opencodeHistorian = historian.opencode as Record<string, unknown>;
-        const piHistorian = historian.pi as Record<string, unknown>;
-
-        expect(migrated.hasFlatKeys).toBe(true);
-        expect(repeated.bytes).toEqual(migrated.bytes);
-        expect(repeated.diagnostics).toEqual(migrated.diagnostics);
-        expect(idempotent.bytes).toEqual(migrated.bytes);
-        expect(idempotent.hasFlatKeys).toBe(false);
-        expect(idempotent.diagnostics).toEqual([]);
-        expect(hasFlatKeys(migrated.bytes)).toBe(false);
-        expect(output.startsWith("\uFEFF")).toBe(true);
-        expect(output).toContain("// preserve this comment");
-        expect(output).toContain("// historian model note");
-        expect(output).toContain("\r\n");
-        expect(config.unrelated).toEqual({ keep: true });
-        expect(historian.model).toBeUndefined();
-        expect(opencodeHistorian).toEqual({
-            model: { model: "provider/historian", variant: "fast" },
-            fallback_models: [{ model: "provider/fallback", variant: "careful" }],
-            variant: "block-variant",
-        });
-        expect(piHistorian).toEqual({
-            model: { model: "provider/historian", thinking_level: "high" },
-            fallback_models: [{ model: "provider/fallback", thinking_level: "low" }],
-            thinking_level: "medium",
-        });
-    });
-
-    it("turns a singleton fallback into one entry without changing its spelling", () => {
-        const migrated = migrateFlatDetailed(
-            Buffer.from(
-                JSON.stringify({
-                    historian: { fallback_models: "Vendor/Model:Exact-Spelling" },
-                }),
-            ),
-        );
-        const historian = parse(migrated.bytes.toString("utf-8")).historian as Record<
-            string,
-            Record<string, unknown>
-        >;
-
-        expect(historian.opencode.fallback_models).toEqual(["Vendor/Model:Exact-Spelling"]);
-        expect(historian.pi.fallback_models).toEqual(["Vendor/Model:Exact-Spelling"]);
-    });
-
-    it("preserves every schema-enumerated retained field at its original level", () => {
-        const historianRetained = {
-            temperature: 0.1,
-            top_p: 0.9,
-            prompt: "historian prompt",
-            tools: { read: true },
-            disable: false,
-            description: "historian description",
-            mode: "subagent",
-            color: "blue",
-            maxSteps: 11,
-            permission: { edit: "deny" },
-            maxTokens: 4096,
-            two_pass: true,
-            disallowed_tools: ["bash"],
-        };
-        expect(Object.keys(historianRetained)).toEqual(
-            PER_HARNESS_MIGRATION_INVENTORY.historian.retained,
-        );
-
-        const migrated = migrateFlatDetailed(
-            Buffer.from(
-                JSON.stringify({
-                    historian: { ...historianRetained, model: "provider/historian" },
-                }),
-            ),
-        );
-        const config = parse(migrated.bytes.toString("utf-8"));
-        const historian = config.historian as Record<string, unknown>;
-
-        for (const [field, value] of Object.entries(historianRetained)) {
-            expect(historian[field]).toEqual(value);
-        }
-    });
-
-    it("fills absent destinations and silently removes equal flat sources", () => {
-        const migrated = migrateFlatDetailed(
-            Buffer.from(`{
-  "historian": {
-    "model": "provider/same",
-    "opencode": { "model": "provider/same" },
-    "pi": {}
-  }
-}`),
-        );
-        const historian = parse(migrated.bytes.toString("utf-8")).historian as Record<
-            string,
-            unknown
-        >;
-
-        expect(historian.model).toBeUndefined();
-        expect(historian.opencode).toEqual({ model: "provider/same" });
-        expect(historian.pi).toEqual({ model: "provider/same" });
-        expect(migrated.diagnostics).toEqual([]);
-    });
-
-    it("keeps new-shape destinations on conflicts and names both paths in warnings", () => {
-        const input = `{
-  "historian": {
-    "model": "provider/flat",
-    "fallback_models": "provider/fallback",
-    "opencode": { "model": "provider/opencode", "fallback_models": ["provider/fallback"] },
-    "pi": { "model": "provider/pi", "fallback_models": ["provider/fallback"] }
-  }
-}`;
-
-        const migrated = migrateFlatDetailed(Buffer.from(input));
-        const config = parse(migrated.bytes.toString("utf-8"));
-        const historian = config.historian as Record<string, unknown>;
-
-        expect(historian.model).toBeUndefined();
-        expect(historian.fallback_models).toBeUndefined();
-        expect(historian.opencode).toEqual({
-            model: "provider/opencode",
-            fallback_models: ["provider/fallback"],
-        });
-        expect(historian.pi).toEqual({
-            model: "provider/pi",
-            fallback_models: ["provider/fallback"],
-        });
-        expect(migrated.diagnostics.map((diagnostic) => diagnostic.path)).toEqual([
-            "historian.model",
-            "historian.model",
-        ]);
-        expect(migrated.diagnostics[0]?.message).toContain("historian.opencode.model");
-        expect(migrated.diagnostics[1]?.message).toContain("historian.pi.model");
-    });
-
-    it("processes flat keys re-added after migration while existing blocks keep winning", () => {
-        const first = migrateFlatDetailed(
-            Buffer.from(JSON.stringify({ historian: { model: "provider/original" } })),
-        );
-        const reintroduced = parse(first.bytes.toString("utf-8"));
-        (reintroduced.historian as Record<string, unknown>).model = "provider/re-added";
-
-        const second = migrateFlatDetailed(Buffer.from(JSON.stringify(reintroduced)));
-        const historian = parse(second.bytes.toString("utf-8")).historian as Record<
-            string,
-            unknown
-        >;
-
-        expect(historian.model).toBeUndefined();
-        expect(historian.opencode).toEqual({ model: "provider/original" });
-        expect(historian.pi).toEqual({ model: "provider/original" });
-        expect(second.diagnostics.map((diagnostic) => diagnostic.message)).toEqual([
-            expect.stringContaining("historian.opencode.model"),
-            expect.stringContaining("historian.pi.model"),
-        ]);
-    });
-
-    it("rewrites user config atomically with one exact-byte restricted backup", () => {
+describe("loadRawConfigFile", () => {
+    it("returns the file byte-for-byte without rewriting it", () => {
         const directory = temporaryDirectory();
         const configPath = join(directory, "mmc.jsonc");
-        const original = Buffer.from('{\n  "historian": { "model": "provider/model" }\n}\n');
-        writeFileSync(configPath, original);
-        chmodSync(configPath, 0o600);
-        const expected = migrateFlatDetailed(original).bytes;
-        let temporaryNamesDuringWrite: string[] = [];
-
-        const first = loadRawConfigFile({
-            configPath,
-            tier: "user",
-            afterTemporaryWrite: () => {
-                expect(readFileSync(configPath)).toEqual(original);
-                temporaryNamesDuringWrite = readdirSync(directory).filter((name) =>
-                    name.endsWith(".tmp"),
-                );
-                expect(temporaryNamesDuringWrite).toHaveLength(1);
-                expect(
-                    readFileSync(join(directory, temporaryNamesDuringWrite[0] as string)),
-                ).toEqual(expected);
-            },
-        });
-        const second = loadRawConfigFile({ configPath, tier: "user" });
-        const backupPath = `${configPath}.pre-per-harness.bak`;
-
-        expect(first?.migrated).toBe(true);
-        expect(first?.warnings).toContain(
-            "Migrated flat historian model config to per-harness blocks.",
-        );
-        expect(readFileSync(backupPath)).toEqual(original);
-        expect(readFileSync(configPath)).toEqual(first?.bytes);
-        expect(temporaryNamesDuringWrite).toHaveLength(1);
-        expect(readdirSync(directory).filter((name) => name.endsWith(".tmp"))).toEqual([]);
-        expect(statSync(configPath).mode & 0o777).toBe(0o600);
-        expect(statSync(backupPath).mode & 0o777).toBe(0o600);
-        expect(second?.migrated).toBe(false);
-        expect(second?.warnings).toEqual([]);
-    });
-
-    it("repairs a truncated migration backup left by the direct-write protocol", () => {
-        const directory = temporaryDirectory();
-        const configPath = join(directory, "mmc.jsonc");
-        const backupPath = `${configPath}.pre-per-harness.bak`;
-        const original = Buffer.from('{ "historian": { "model": "provider/model" } }\n');
-        writeFileSync(configPath, original);
-        writeFileSync(backupPath, original.subarray(0, 17));
+        const original = `{\n  // keep this comment\n  "historian": { "model": "provider/model" }\n}\n`;
+        writeFileSync(configPath, original, "utf-8");
+        const before = readFileSync(configPath);
 
         const loaded = loadRawConfigFile({ configPath, tier: "user" });
 
-        expect(loaded?.migrated).toBe(true);
-        expect(readFileSync(backupPath)).toEqual(original);
-    });
-
-    it("leaves a completed migration backup with different bytes untouched", () => {
-        const directory = temporaryDirectory();
-        const configPath = join(directory, "mmc.jsonc");
-        const backupPath = `${configPath}.pre-per-harness.bak`;
-        const sentinel = Buffer.from("not config: backup is opaque and permanent\n");
-        writeFileSync(configPath, '{ "historian": { "model": "provider/model" } }');
-        writeFileSync(backupPath, sentinel);
-
-        const first = loadRawConfigFile({ configPath, tier: "user" });
-        const second = loadRawConfigFile({ configPath, tier: "user" });
-
-        expect(first?.migrated).toBe(true);
-        expect(second?.migrated).toBe(false);
-        expect(readFileSync(backupPath)).toEqual(sentinel);
-    });
-
-    it("accepts a matching migration backup without rewriting it", () => {
-        const directory = temporaryDirectory();
-        const configPath = join(directory, "mmc.jsonc");
-        const backupPath = `${configPath}.pre-per-harness.bak`;
-        const original = Buffer.from('{ "historian": { "model": "provider/model" } }\n');
-        writeFileSync(configPath, original);
-        writeFileSync(backupPath, original);
-        const backupInode = statSync(backupPath).ino;
-
-        const loaded = loadRawConfigFile({ configPath, tier: "user" });
-
-        expect(loaded?.migrated).toBe(true);
-        expect(readFileSync(backupPath)).toEqual(original);
-        expect(statSync(backupPath).ino).toBe(backupInode);
-    });
-
-    it("creates user migration backups and replacement configs owner-only", () => {
-        if (process.platform === "win32") return;
-        const directory = temporaryDirectory();
-        const configPath = join(directory, "mmc.jsonc");
-        const original = Buffer.from('{ "historian": { "model": "provider/model" } }\n');
-        writeFileSync(configPath, original);
-        chmodSync(configPath, 0o644);
-
-        const loaded = loadRawConfigFile({ configPath, tier: "user" });
+        expect(loaded).not.toBeNull();
+        expect(loaded?.text).toBe(original);
+        expect(loaded?.bytes.equals(before)).toBe(true);
+        expect(loaded?.warnings).toEqual([]);
+        expect(loaded?.migrated).toBe(false);
 
-        expect(loaded?.migrated).toBe(true);
-        expect(statSync(configPath).mode & 0o777).toBe(0o600);
-        expect(statSync(`${configPath}.pre-per-harness.bak`).mode & 0o777).toBe(0o600);
+        // No rewrite, no `.pre-per-harness.bak` backup, no temp file left behind.
+        expect(readFileSync(configPath).equals(before)).toBe(true);
+        expect(existsSync(`${configPath}.pre-per-harness.bak`)).toBe(false);
+        expect(readdirSync(directory)).toEqual(["mmc.jsonc"]);
     });
 
-    // stow, chezmoi and home-manager link the user config into a dotfiles repo.
-    // Replacing the link with a regular file would silently stop later edits
-    // from reaching that repo, so the migration writes through to the target.
-    it("keeps a symlinked user config a symlink and migrates its target", () => {
+    it("does not rewrite a file that still uses the removed per-harness blocks", () => {
         const directory = temporaryDirectory();
-        const dotfiles = temporaryDirectory();
-        const targetPath = join(dotfiles, "mmc.jsonc");
         const configPath = join(directory, "mmc.jsonc");
-        const original = Buffer.from('{ "historian": { "model": "provider/model" } }\n');
-        writeFileSync(targetPath, original);
-        chmodSync(targetPath, 0o600);
-        symlinkSync(targetPath, configPath);
+        const original = `{\n  "historian": { "opencode": { "model": "provider/model" } }\n}\n`;
+        writeFileSync(configPath, original, "utf-8");
+        const before = readFileSync(configPath);
 
         const loaded = loadRawConfigFile({ configPath, tier: "user" });
 
-        expect(loaded?.migrated).toBe(true);
-        expect(lstatSync(configPath).isSymbolicLink()).toBe(true);
-        expect(readlinkSync(configPath)).toBe(targetPath);
-        expect(readFileSync(targetPath)).toEqual(loaded?.bytes);
-        expect(hasFlatKeys(readFileSync(targetPath))).toBe(false);
-        expect(statSync(targetPath).mode & 0o777).toBe(0o600);
-        expect(readFileSync(`${configPath}.pre-per-harness.bak`)).toEqual(original);
-        expect(readdirSync(dotfiles).filter((name) => name.endsWith(".tmp"))).toEqual([]);
-        expect(readdirSync(directory).filter((name) => name.endsWith(".tmp"))).toEqual([]);
-    });
-
-    it("reloads the winning candidate when a concurrent loader replaces the target", () => {
-        const directory = temporaryDirectory();
-        const configPath = join(directory, "mmc.jsonc");
-        const original = Buffer.from('{\n  "historian": { "model": "provider/model" }\n}\n');
-        writeFileSync(configPath, original);
-
-        let competing: ReturnType<typeof loadRawConfigFile> | undefined;
-        const first = loadRawConfigFile({
-            configPath,
-            tier: "user",
-            afterTemporaryWrite: () => {
-                competing ??= loadRawConfigFile({ configPath, tier: "user" });
-            },
-        });
-
-        expect([first?.migrated, competing?.migrated].filter(Boolean)).toHaveLength(1);
-        expect(competing?.migrated).toBe(true);
-        expect(first?.migrated).toBe(false);
-        expect(first?.warnings).toEqual([]);
-        expect(competing?.warnings).toEqual([
-            "Migrated flat historian model config to per-harness blocks.",
-        ]);
-        expect(first?.bytes).toEqual(competing?.bytes);
-        expect(parse(first?.text ?? "{}")).toEqual(parse(competing?.text ?? "{}"));
-        expect(readFileSync(configPath)).toEqual(competing?.bytes);
-        expect(readFileSync(`${configPath}.pre-per-harness.bak`)).toEqual(original);
+        expect(loaded?.text).toBe(original);
+        expect(loaded?.migrated).toBe(false);
+        expect(readFileSync(configPath).equals(before)).toBe(true);
+        expect(readdirSync(directory)).toEqual(["mmc.jsonc"]);
     });
 
-    it("adapts project config in memory without changing bytes or mtime", () => {
+    it("returns null when the file does not exist", () => {
         const directory = temporaryDirectory();
-        const configPath = join(directory, "mmc.jsonc");
-        const original = Buffer.from('{\n  "historian": { "model": "provider/model" }\n}\n');
-        writeFileSync(configPath, original);
-        const before = statSync(configPath);
-
-        const loaded = loadRawConfigFile({ configPath, tier: "project" });
-        const after = statSync(configPath);
-        const config = parse(loaded?.text ?? "{}");
-
-        expect(loaded?.migrated).toBe(false);
-        expect(loaded?.warnings[0]).toContain("Adapted flat model config in memory");
-        expect(readFileSync(configPath)).toEqual(original);
-        expect(after.mtimeMs).toBe(before.mtimeMs);
-        expect((config.historian as Record<string, unknown>).opencode).toEqual({
-            model: "provider/model",
-        });
+        expect(
+            loadRawConfigFile({ configPath: join(directory, "absent.jsonc"), tier: "user" }),
+        ).toBeNull();
     });
 });