@retaw106/mmc-oc 1.2.3 → 2.1.0

package/src/config/raw-loader.ts

@@ -1,38 +1,10 @@
-import {
-    closeSync,
-    existsSync,
-    linkSync,
-    openSync,
-    readFileSync,
-    realpathSync,
-    renameSync,
-    statSync,
-    unlinkSync,
-    writeFileSync,
-} from "node:fs";
-import { basename, dirname, join } from "node:path";
-
-import { removeJsoncValue, setJsoncValue } from "../shared/jsonc-edit";
-import { parseJsonc } from "../shared/jsonc-parser";
+import { existsSync, readFileSync } from "node:fs";
 
 export type ConfigTier = "user" | "project";
 
-export interface FlatConfigDiagnostic {
-    path: string;
-    message: string;
-}
-
-export interface FlatConfigMigration {
-    bytes: Buffer;
-    hasFlatKeys: boolean;
-    diagnostics: FlatConfigDiagnostic[];
-}
-
 export interface RawConfigLoadOptions {
     configPath: string;
     tier: ConfigTier;
-    /** Test-only seam for making a competing loader replace the target before this loader re-checks it. */
-    afterTemporaryWrite?: () => void;
 }
 
 export interface RawConfigLoadResult {
@@ -43,393 +15,32 @@ export interface RawConfigLoadResult {
     migrated: boolean;
 }
 
-const MODEL_FIELDS = ["model", "fallback_models"] as const;
-const PRE_PER_HARNESS_BACKUP_SUFFIX = ".pre-per-harness.bak";
-let temporaryFileSequence = 0;
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function asDocument(text: string): Record<string, unknown> | null {
-    try {
-        // JSON.parse rejects a UTF-8 BOM, while JSONC files commonly retain one.
-        // Remove it only for inspection; every byte-writing path adds it back.
-        const document = parseJsonc<unknown>(text.startsWith("\uFEFF") ? text.slice(1) : text);
-        return isRecord(document) ? document : null;
-    } catch {
-        return null;
-    }
-}
-
-function getAtPath(document: Record<string, unknown>, path: readonly string[]): unknown {
-    let current: unknown = document;
-    for (const part of path) {
-        if (!isRecord(current) || !Object.hasOwn(current, part)) return undefined;
-        current = current[part];
-    }
-    return current;
-}
-
-function stableJson(value: unknown): string {
-    if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
-    if (!isRecord(value)) return JSON.stringify(value);
-    return `{${Object.keys(value)
-        .sort()
-        .map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`)
-        .join(",")}}`;
-}
-
-function valuesMatch(left: unknown, right: unknown): boolean {
-    return stableJson(left) === stableJson(right);
-}
-
-function valueForDiagnostic(value: unknown): string {
-    return stableJson(value);
-}
-
-function migrateEntryForHarness(value: unknown, harness: "opencode" | "pi"): unknown {
-    if (Array.isArray(value)) return value.map((entry) => migrateEntryForHarness(entry, harness));
-    if (!isRecord(value) || !Object.hasOwn(value, "model")) return value;
-
-    const entry: Record<string, unknown> = { model: value.model };
-    if (harness === "opencode" && Object.hasOwn(value, "variant")) {
-        entry.variant = value.variant;
-    }
-    if (harness === "pi" && Object.hasOwn(value, "thinking_level")) {
-        entry.thinking_level = value.thinking_level;
-    }
-    return entry;
-}
-
-function migrateFallbackForHarness(value: unknown, harness: "opencode" | "pi"): unknown {
-    if (typeof value === "string") return [value];
-    return migrateEntryForHarness(value, harness);
-}
-
-function canCreateAtPath(document: Record<string, unknown>, path: readonly string[]): boolean {
-    let current: unknown = document;
-    for (const part of path) {
-        if (current === undefined) return true;
-        if (!isRecord(current)) return false;
-        current = current[part];
-    }
-    return current === undefined || isRecord(current);
-}
-
-function flatFieldPath(parts: readonly string[]): string {
-    return parts.join(".");
-}
-
-function updateDocumentForFlatFields(text: string): {
-    text: string;
-    hasFlatKeys: boolean;
-    diagnostics: FlatConfigDiagnostic[];
-    flatPaths: string[];
-} {
-    const hasBom = text.startsWith("\uFEFF");
-    const editableText = hasBom ? text.slice(1) : text;
-    const document = asDocument(text);
-    if (!document) {
-        return { text, hasFlatKeys: false, diagnostics: [], flatPaths: [] };
-    }
-
-    let nextText = editableText;
-    let hasFlatKeys = false;
-    const diagnostics: FlatConfigDiagnostic[] = [];
-    const flatPaths: string[] = [];
-    const sourcePathsToRemove: string[][] = [];
-
-    const addDestination = (
-        sourcePath: string[],
-        destinationPath: string[],
-        destinationValue: unknown,
-    ): void => {
-        const sourceLabel = flatFieldPath(sourcePath);
-        const destinationLabel = flatFieldPath(destinationPath);
-        if (!canCreateAtPath(document, destinationPath.slice(0, -1))) {
-            diagnostics.push({
-                path: sourceLabel,
-                message: `Flat config field "${sourceLabel}" (${valueForDiagnostic(destinationValue)}) conflicts with non-object destination "${destinationLabel}" (${valueForDiagnostic(getAtPath(document, destinationPath.slice(0, -1)))}); kept the destination and ignored the flat field.`,
-            });
-            return;
-        }
-
-        const existing = getAtPath(document, destinationPath);
-        if (existing !== undefined) {
-            if (!valuesMatch(existing, destinationValue)) {
-                diagnostics.push({
-                    path: sourceLabel,
-                    message: `Flat config field "${sourceLabel}" (${valueForDiagnostic(destinationValue)}) conflicts with "${destinationLabel}" (${valueForDiagnostic(existing)}); kept "${destinationLabel}" and ignored the flat field.`,
-                });
-            }
-            return;
-        }
-
-        nextText = setJsoncValue(nextText, destinationPath, destinationValue);
-    };
-
-    const migrateAgentFields = (agentName: "historian"): void => {
-        const agent = document[agentName];
-        if (!isRecord(agent)) return;
-
-        for (const field of MODEL_FIELDS) {
-            if (!Object.hasOwn(agent, field)) continue;
-            const sourcePath = [agentName, field];
-            hasFlatKeys = true;
-            flatPaths.push(flatFieldPath(sourcePath));
-            sourcePathsToRemove.push(sourcePath);
-            const migrateValue =
-                field === "fallback_models" ? migrateFallbackForHarness : migrateEntryForHarness;
-            addDestination(
-                sourcePath,
-                [agentName, "opencode", field],
-                migrateValue(agent[field], "opencode"),
-            );
-            addDestination(sourcePath, [agentName, "pi", field], migrateValue(agent[field], "pi"));
-        }
-
-        if (Object.hasOwn(agent, "variant")) {
-            const sourcePath = [agentName, "variant"];
-            hasFlatKeys = true;
-            flatPaths.push(flatFieldPath(sourcePath));
-            sourcePathsToRemove.push(sourcePath);
-            addDestination(sourcePath, [agentName, "opencode", "variant"], agent.variant);
-        }
-
-        if (Object.hasOwn(agent, "thinking_level")) {
-            const sourcePath = [agentName, "thinking_level"];
-            hasFlatKeys = true;
-            flatPaths.push(flatFieldPath(sourcePath));
-            sourcePathsToRemove.push(sourcePath);
-            addDestination(sourcePath, [agentName, "pi", "thinking_level"], agent.thinking_level);
-        }
-    };
-
-    migrateAgentFields("historian");
-
-    for (const sourcePath of sourcePathsToRemove) {
-        nextText = removeJsoncValue(nextText, sourcePath);
-    }
-
-    return {
-        text: hasBom ? `\uFEFF${nextText}` : nextText,
-        hasFlatKeys,
-        diagnostics,
-        flatPaths,
-    };
-}
-
-/** True when historian fields still use the flat shape. */
-export function hasFlatKeys(input: Buffer | string): boolean {
-    const text = typeof input === "string" ? input : input.toString("utf-8");
-    return updateDocumentForFlatFields(text).hasFlatKeys;
-}
-
 /**
- * Deterministically maps flat model fields into per-harness blocks while leaving
- * unrelated JSONC regions untouched. The return type matches the caller's input
- * representation so callers that operate on file bytes retain BOM and line-ending
- * details exactly outside the surgical edits.
- */
-export function migrateFlat(input: string): string;
-export function migrateFlat(input: Buffer): Buffer;
-export function migrateFlat(input: Buffer | string): Buffer | string {
-    const text = typeof input === "string" ? input : input.toString("utf-8");
-    const migrated = updateDocumentForFlatFields(text).text;
-    return typeof input === "string" ? migrated : Buffer.from(migrated, "utf-8");
-}
-
-export function migrateFlatDetailed(input: Buffer | string): FlatConfigMigration {
-    const bytes = typeof input === "string" ? Buffer.from(input, "utf-8") : input;
-    const result = updateDocumentForFlatFields(bytes.toString("utf-8"));
-    return {
-        bytes: Buffer.from(result.text, "utf-8"),
-        hasFlatKeys: result.hasFlatKeys,
-        diagnostics: result.diagnostics,
-    };
-}
-
-function writeExclusiveBackup(backupPath: string, bytes: Buffer, mode: number): void {
-    const temporaryPath = writeTemporaryCandidate(backupPath, bytes, mode);
-    try {
-        try {
-            // A hard link publishes the fully written candidate without replacing a concurrent backup.
-            linkSync(temporaryPath, backupPath);
-            return;
-        } catch (error) {
-            if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
-        }
-
-        const existingBytes = readFileSync(backupPath);
-        if (existingBytes.equals(bytes)) return;
-
-        // A prefix may be a partial file left when the former direct-write approach crashed.
-        // Preserve any other content because it may be a complete backup from an earlier run.
-        if (bytes.subarray(0, existingBytes.length).equals(existingBytes)) {
-            renameSync(temporaryPath, backupPath);
-            return;
-        }
-    } finally {
-        try {
-            unlinkSync(temporaryPath);
-        } catch {
-            // The candidate may already be linked or renamed into place; cleanup failure must
-            // not obscure the result of creating or validating the permanent backup.
-        }
-    }
-}
-
-function writeTemporaryCandidate(configPath: string, bytes: Buffer, mode: number): string {
-    const directory = dirname(configPath);
-    const stem = basename(configPath);
-    for (let attempt = 0; attempt < 32; attempt++) {
-        temporaryFileSequence += 1;
-        const path = join(
-            directory,
-            `.${stem}.per-harness-${process.pid}-${temporaryFileSequence}.tmp`,
-        );
-        let descriptor: number | undefined;
-        try {
-            descriptor = openSync(path, "wx", mode);
-            writeFileSync(descriptor, bytes);
-            closeSync(descriptor);
-            return path;
-        } catch (error) {
-            if (descriptor !== undefined) {
-                try {
-                    closeSync(descriptor);
-                } catch {
-                    // The write error below remains the actionable error.
-                }
-            }
-            try {
-                unlinkSync(path);
-            } catch {
-                // A failed cleanup must not hide the original write error.
-            }
-            if ((error as NodeJS.ErrnoException).code !== "EEXIST") throw error;
-        }
-    }
-    throw new Error(`Could not allocate a temporary config file beside ${configPath}`);
-}
-
-function migrationWarning(diagnostic: FlatConfigDiagnostic): string {
-    return diagnostic.message;
-}
-
-/**
- * Reads the raw tier before substitution and schema validation. User files are
- * rewritten through an exact-byte backup and same-directory atomic replacement;
- * project files are adapted only in memory. This is the common seam used by both
- * harness loaders and their doctor paths.
+ * Reads the raw tier before substitution and schema validation. This is a PURE
+ * read: Magic Context never rewrites config files. The former per-harness
+ * historian migration (flat model fields -> historian.opencode / historian.pi
+ * blocks, with a `.pre-per-harness.bak` backup and same-directory rewrite) was
+ * removed in favour of the flat contract, so the file is returned byte-for-byte.
+ * Legacy per-harness blocks are detected and rejected as a config error by the
+ * loaders, never rewritten.
  */
 export function loadRawConfigFile(options: RawConfigLoadOptions): RawConfigLoadResult | null {
     if (!existsSync(options.configPath)) return null;
 
-    let observedBytes: Buffer;
+    let bytes: Buffer;
     try {
-        observedBytes = readFileSync(options.configPath);
+        bytes = readFileSync(options.configPath);
     } catch (error) {
         throw new Error(
             `failed to read config: ${error instanceof Error ? error.message : String(error)}`,
         );
     }
 
-    const initialMigration = migrateFlatDetailed(observedBytes);
-    if (!initialMigration.hasFlatKeys) {
-        return {
-            configPath: options.configPath,
-            bytes: observedBytes,
-            text: observedBytes.toString("utf-8"),
-            warnings: [],
-            migrated: false,
-        };
-    }
-
-    if (options.tier === "project") {
-        return {
-            configPath: options.configPath,
-            bytes: initialMigration.bytes,
-            text: initialMigration.bytes.toString("utf-8"),
-            warnings: [
-                "Adapted flat model config in memory; use historian.opencode/historian.pi instead. Project config files are never rewritten.",
-                ...initialMigration.diagnostics.map(migrationWarning),
-            ],
-            migrated: false,
-        };
-    }
-
-    const backupPath = `${options.configPath}${PRE_PER_HARNESS_BACKUP_SUFFIX}`;
-    for (;;) {
-        const migration = migrateFlatDetailed(observedBytes);
-        if (!migration.hasFlatKeys) {
-            return {
-                configPath: options.configPath,
-                bytes: observedBytes,
-                text: observedBytes.toString("utf-8"),
-                warnings: [],
-                migrated: false,
-            };
-        }
-
-        let temporaryPath: string | undefined;
-        try {
-            // Write through a symlinked config (stow, chezmoi, home-manager keep
-            // it in a dotfiles repo): the temporary file is created next to the
-            // real file and renamed onto it, so the link itself stays a link.
-            const writePath = realpathSync(options.configPath);
-            const mode = options.tier === "user" ? 0o600 : statSync(writePath).mode & 0o777;
-            writeExclusiveBackup(backupPath, observedBytes, mode);
-            temporaryPath = writeTemporaryCandidate(writePath, migration.bytes, mode);
-            options.afterTemporaryWrite?.();
-
-            const currentBytes = readFileSync(options.configPath);
-            if (!hasFlatKeys(currentBytes)) {
-                unlinkSync(temporaryPath);
-                return {
-                    configPath: options.configPath,
-                    bytes: currentBytes,
-                    text: currentBytes.toString("utf-8"),
-                    warnings: [],
-                    migrated: false,
-                };
-            }
-            if (!currentBytes.equals(observedBytes)) {
-                unlinkSync(temporaryPath);
-                observedBytes = currentBytes;
-                continue;
-            }
-
-            renameSync(temporaryPath, writePath);
-            return {
-                configPath: options.configPath,
-                bytes: migration.bytes,
-                text: migration.bytes.toString("utf-8"),
-                warnings: [
-                    "Migrated flat historian model config to per-harness blocks.",
-                    ...migration.diagnostics.map(migrationWarning),
-                ],
-                migrated: true,
-            };
-        } catch (error) {
-            if (temporaryPath) {
-                try {
-                    unlinkSync(temporaryPath);
-                } catch {
-                    // The migration error is more useful than a failed temp cleanup.
-                }
-            }
-            return {
-                configPath: options.configPath,
-                bytes: observedBytes,
-                text: observedBytes.toString("utf-8"),
-                warnings: [
-                    `Could not migrate flat model config: ${error instanceof Error ? error.message : String(error)}. Flat fields were not applied.`,
-                    ...migration.diagnostics.map(migrationWarning),
-                ],
-                migrated: false,
-            };
-        }
-    }
+    return {
+        configPath: options.configPath,
+        bytes,
+        text: bytes.toString("utf-8"),
+        warnings: [],
+        migrated: false,
+    };
 }

package/src/config/removed-config-keys.test.ts

@@ -97,7 +97,7 @@ describe("removed Phase 2 config keys", () => {
     // e2e suite is deleted with 01.A.)
     it("no docs / generated schema references the removed keys", () => {
         const docFiles = [
-            join(REPO_ROOT, "CONFIGURATION.md"),
+            join(REPO_ROOT, "docs", "guides", "配置说明.md"),
             join(REPO_ROOT, "README.md"),
             join(REPO_ROOT, "assets", "magic-context.schema.json"),
         ];

package/src/config/schema/magic-context.test.ts

@@ -2,9 +2,9 @@ import { describe, expect, it } from "bun:test";
 import {
     DEFAULT_HISTORIAN_TIMEOUT_MS,
     DEFAULT_HISTORY_BUDGET_PERCENTAGE,
+    HISTORIAN_MODEL_RESOLUTION_FIELDS,
     type MagicContextConfig,
     MagicContextConfigSchema,
-    PER_HARNESS_MIGRATION_INVENTORY,
 } from "./magic-context";
 
 describe("MagicContextConfigSchema", () => {
@@ -20,7 +20,6 @@ describe("MagicContextConfigSchema", () => {
                 cache_ttl: "5m",
                 prompt_surface: { default: "full" },
                 execute_threshold_percentage: 65,
-                clear_reasoning_age: 50,
                 history_budget_percentage: DEFAULT_HISTORY_BUDGET_PERCENTAGE,
                 historian_timeout_ms: DEFAULT_HISTORIAN_TIMEOUT_MS,
                 memory: {
@@ -90,7 +89,6 @@ describe("MagicContextConfigSchema", () => {
                 cache_ttl: "10m",
                 prompt_surface: { default: "full" },
                 execute_threshold_percentage: 75,
-                clear_reasoning_age: 60,
                 history_budget_percentage: 0.2,
                 historian_timeout_ms: 360_000,
                 commit_cluster_trigger: {
@@ -115,7 +113,7 @@ describe("MagicContextConfigSchema", () => {
                     enabled: false,
                     overlay: false,
                 },
-                smart_drops: false,
+                protected_tools: { mmc_reduce: 3, todowrite: 1 },
                 caveman_text_compression: {
                     enabled: false,
                     min_chars: 500,
@@ -236,32 +234,22 @@ describe("MagicContextConfigSchema", () => {
     });
 
     describe("config profiles", () => {
-        it("admits model-selection fields and preserves per-entry harness qualifiers", () => {
+        it("admits flat model-selection fields and preserves per-entry qualifiers", () => {
             const result = MagicContextConfigSchema.parse({
                 profile: "work",
                 profiles: {
                     work: {
                         historian: {
-                            opencode: {
-                                model: { model: "anthropic/work-historian", variant: "high" },
-                                fallback_models: [
-                                    { model: "openai/work-fallback", variant: "low" },
-                                ],
-                                variant: "high",
-                            },
-                            pi: {
-                                model: {
-                                    model: "github-copilot/work-historian",
-                                    thinking_level: "high",
-                                },
-                                thinking_level: "high",
-                            },
+                            model: { model: "anthropic/work-historian", variant: "high" },
+                            fallback_models: [{ model: "openai/work-fallback", variant: "low" }],
+                            variant: "high",
+                            thinking_level: "high",
                         },
                     },
                 },
             });
 
-            expect(result.profiles?.work?.historian?.opencode?.fallback_models).toEqual([
+            expect(result.profiles?.work?.historian?.fallback_models).toEqual([
                 { model: "openai/work-fallback", variant: "low" },
             ]);
         });
@@ -282,7 +270,8 @@ describe("MagicContextConfigSchema", () => {
             const profilesWithExcludedFields = [
                 { work: { embedding: { provider: "off" } } },
                 { work: { historian: { two_pass: true } } },
-                { work: { historian: { opencode: { prompt: "override" } } } },
+                { work: { historian: { prompt: "override" } } },
+                { work: { historian: { opencode: { model: "x/y" } } } },
             ];
 
             for (const profiles of profilesWithExcludedFields) {
@@ -291,60 +280,65 @@ describe("MagicContextConfigSchema", () => {
         });
     });
 
-    describe("per-harness model configuration", () => {
-        it("keeps the migration inventory exhaustive and field-specific", () => {
-            expect(PER_HARNESS_MIGRATION_INVENTORY).toEqual({
-                historian: {
-                    retained: [
-                        "temperature",
-                        "top_p",
-                        "prompt",
-                        "tools",
-                        "disable",
-                        "description",
-                        "mode",
-                        "color",
-                        "maxSteps",
-                        "permission",
-                        "maxTokens",
-                        "two_pass",
-                        "disallowed_tools",
-                    ],
-                    migrated_execution: ["model", "fallback_models", "variant", "thinking_level"],
-                },
-            });
+    describe("flat historian model configuration", () => {
+        it("declares exactly the flat model-resolution fields", () => {
+            expect(HISTORIAN_MODEL_RESOLUTION_FIELDS).toEqual([
+                "model",
+                "fallback_models",
+                "variant",
+                "thinking_level",
+            ]);
         });
 
-        it("keeps agent metadata separate from strict harness execution blocks", () => {
+        it("keeps agent metadata and flat model resolution in the same historian block", () => {
             const result = MagicContextConfigSchema.parse({
                 historian: {
                     disable: false,
                     two_pass: true,
                     disallowed_tools: ["read"],
-                    opencode: {
-                        model: { model: "anthropic/claude-sonnet-4-6", variant: "high" },
-                        fallback_models: ["openai/gpt-5.4"],
-                        variant: "medium",
-                    },
-                    pi: {
-                        model: {
-                            model: "github-copilot/gpt-5.4",
-                            thinking_level: "high",
-                        },
-                        fallback_models: ["openai/gpt-5.4"],
-                        thinking_level: "medium",
-                    },
+                    model: { model: "anthropic/claude-sonnet-4-6", variant: "high" },
+                    fallback_models: ["openai/gpt-5.4"],
+                    variant: "medium",
+                    thinking_level: "high",
                 },
             });
 
-            expect(result.historian?.opencode?.fallback_models).toEqual(["openai/gpt-5.4"]);
+            expect(result.historian?.fallback_models).toEqual(["openai/gpt-5.4"]);
+            expect(result.historian?.model).toEqual({
+                model: "anthropic/claude-sonnet-4-6",
+                variant: "high",
+            });
+            expect(result.historian?.variant).toBe("medium");
+            expect(result.historian?.thinking_level).toBe("high");
         });
 
-        it("rejects cross-harness vocabulary, non-array fallbacks, and execution fields at metadata depth", () => {
+        it("rejects the removed per-harness historian blocks instead of silently stripping them", () => {
+            const result = MagicContextConfigSchema.safeParse({
+                historian: {
+                    opencode: { model: "x/y" },
+                    pi: { model: "x/y" },
+                    two_pass: true,
+                },
+            });
+
+            expect(result.success).toBe(false);
+            if (!result.success) {
+                const issue = result.error.issues.find(
+                    (candidate) => candidate.code === "unrecognized_keys",
+                );
+                expect(issue?.path).toEqual(["historian"]);
+                const keys = issue && "keys" in issue ? issue.keys : [];
+                expect(keys).toContain("opencode");
+                expect(keys).toContain("pi");
+            }
+        });
+
+        it("rejects non-array fallbacks and malformed model entries", () => {
             const invalidConfigs = [
-                { historian: { opencode: { thinking_level: "high" } } },
-                { historian: { pi: { variant: "high" } } },
-                { historian: { opencode: { fallback_models: "anthropic/claude-sonnet-4-6" } } },
+                { historian: { fallback_models: "anthropic/claude-sonnet-4-6" } },
+                { historian: { model: 123 } },
+                { historian: { model: { variant: "high" } } },
+                { historian: { fallback_models: [{ thinking_level: "high" }] } },
             ];
 
             for (const config of invalidConfigs) {
@@ -414,8 +408,10 @@ describe("MagicContextConfigSchema", () => {
             ).toBe(30000);
         });
 
-        it("rejects clear_reasoning_age below minimum", () => {
-            expect(() => MagicContextConfigSchema.parse({ clear_reasoning_age: 9 })).toThrow();
+        it("accepts deprecated clear_reasoning_age without applying its old validation", () => {
+            expect(
+                MagicContextConfigSchema.parse({ clear_reasoning_age: 9 }).keep_reasoning_tokens,
+            ).toBeUndefined();
         });
 
         it("rejects historian_timeout_ms below minimum", () => {