onto-mcp 0.3.2 → 0.4.1

package/dist/core-runtime/discovery/lens-registry.test.js

@@ -1,81 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import { describe, it, expect } from "vitest";
-import { canonicalizeLensId, loadCoreLensRegistry } from "./lens-registry.js";
-function resolveRegistryPath() {
-    const here = path.dirname(fileURLToPath(import.meta.url));
-    let cur = here;
-    const root = path.parse(cur).root;
-    while (cur !== root) {
-        const candidate = path.join(cur, ".onto", "authority", "core-lens-registry.yaml");
-        if (fs.existsSync(candidate))
-            return candidate;
-        cur = path.dirname(cur);
-    }
-    throw new Error(".onto/authority/core-lens-registry.yaml not found");
-}
-describe("canonicalizeLensId — Phase 0 dual-read (W-A-01)", () => {
-    it("strips onto_ prefix from legacy IDs", () => {
-        expect(canonicalizeLensId("onto_logic")).toBe("logic");
-        expect(canonicalizeLensId("onto_axiology")).toBe("axiology");
-        expect(canonicalizeLensId("onto_synthesize")).toBe("synthesize");
-    });
-    it("is idempotent — bare IDs pass through unchanged", () => {
-        expect(canonicalizeLensId("logic")).toBe("logic");
-        expect(canonicalizeLensId("axiology")).toBe("axiology");
-        expect(canonicalizeLensId("synthesize")).toBe("synthesize");
-    });
-    it("handles all 10 rename targets", () => {
-        const targets = [
-            "logic", "structure", "dependency", "semantics", "pragmatics",
-            "evolution", "coverage", "conciseness", "axiology", "synthesize",
-        ];
-        for (const bare of targets) {
-            expect(canonicalizeLensId(`onto_${bare}`)).toBe(bare);
-            expect(canonicalizeLensId(bare)).toBe(bare);
-        }
-    });
-    it("does not strip prefix when not exact onto_ match", () => {
-        expect(canonicalizeLensId("ontology")).toBe("ontology");
-        expect(canonicalizeLensId("onto-logic")).toBe("onto-logic");
-        expect(canonicalizeLensId("custom_logic")).toBe("custom_logic");
-    });
-});
-describe("loadCoreLensRegistry — core-axis composition contract (v0.2.1)", () => {
-    // These assertions lock the v0.2.1 cost-constrained Pareto-optimal
-    // composition into a test so that any future registry edit that changes
-    // the core-axis set must also update this test (intentional checkpoint).
-    // SSOT: .onto/authority/core-lens-registry.yaml; empirical basis:
-    // development-records/benchmark/20260419-lens-contribution-analysis.md.
-    const registry = loadCoreLensRegistry();
-    it("core_axis_lens_ids contains exactly the v0.2.1 6-lens set", () => {
-        expect(registry.core_axis_lens_ids).toHaveLength(6);
-        expect([...registry.core_axis_lens_ids].sort()).toEqual([
-            "axiology",
-            "coverage",
-            "evolution",
-            "logic",
-            "semantics",
-            "structure",
-        ]);
-    });
-    it("full_review_lens_ids remains 9-lens", () => {
-        expect(registry.full_review_lens_ids).toHaveLength(9);
-    });
-    it("always_include_lens_ids is [axiology]", () => {
-        expect(registry.always_include_lens_ids).toEqual(["axiology"]);
-    });
-    it("every always_include lens is present in core_axis composition", () => {
-        for (const id of registry.always_include_lens_ids) {
-            expect(registry.core_axis_lens_ids).toContain(id);
-        }
-    });
-    // F-E1 (2nd review): loader currently does not consume `schema_version`.
-    // Assert the raw field exists at the registry seat — forces any future
-    // recomposition to bump the field together with contents.
-    it("registry file declares schema_version: 2 (raw-text guard)", () => {
-        const text = fs.readFileSync(resolveRegistryPath(), "utf8");
-        expect(text).toMatch(/^schema_version:\s*2\b/m);
-    });
-});

package/dist/core-runtime/discovery/path-normalization.test.js

@@ -1,22 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { startsWithDirPrefix } from "./path-normalization.js";
-describe("startsWithDirPrefix — segment-bound check", () => {
-    it("matches exact segment boundary with trailing slash", () => {
-        expect(startsWithDirPrefix(".onto/principles/foo.md", ".onto/principles/")).toBe(true);
-        expect(startsWithDirPrefix(".onto/principles/sub/bar.md", ".onto/principles")).toBe(true);
-    });
-    it("rejects mid-segment prefix collision", () => {
-        expect(startsWithDirPrefix(".onto/principlesABC/foo.md", ".onto/principles")).toBe(false);
-        expect(startsWithDirPrefix(".onto/principles_backup/foo.md", ".onto/principles")).toBe(false);
-        expect(startsWithDirPrefix(".onto/authorityX/foo.md", ".onto/authority")).toBe(false);
-    });
-    it("rejects the directory itself (must be a path under the directory)", () => {
-        expect(startsWithDirPrefix(".onto/principles", ".onto/principles")).toBe(false);
-        expect(startsWithDirPrefix(".onto/principles/", ".onto/principles")).toBe(false);
-    });
-    it("treats trailing slash in `dir` argument uniformly", () => {
-        const p = ".onto/principles/foo.md";
-        expect(startsWithDirPrefix(p, ".onto/principles")).toBe(true);
-        expect(startsWithDirPrefix(p, ".onto/principles/")).toBe(true);
-    });
-});

package/dist/core-runtime/discovery/plugin-path.js

@@ -1,72 +0,0 @@
-/**
- * Plugin install path resolver.
- *
- * onto's canonical authority files (process.md, .onto/processes/, learning-rules.md,
- * .onto/roles/, etc.) are read at runtime from the install location. The path
- * resolution must support multiple install scenarios:
- *
- * 1. Claude Code plugin install: `~/.claude/plugins/onto/`
- * 2. Standalone clone + symlink: arbitrary path
- * 3. Repo development: the repo itself is the plugin
- *
- * # Resolution priority (highest first)
- *
- *   1. ONTO_PLUGIN_DIR env var (explicit override)
- *   2. ~/.claude/plugins/onto/ (Claude Code install default)
- *   3. (None) → returns null; caller decides its explicit default
- *
- * # Why no automatic repo-relative default
- *
- * Repo-relative paths are correct only during local dev. In production
- * (npm-installed CLI, Claude Code plugin), the plugin lives elsewhere.
- * Returning null when no install is detected lets the caller emit a clear
- * "set ONTO_PLUGIN_DIR or install via /plugin install" error rather than
- * silently using the wrong source tree.
- */
-import fsSync from "node:fs";
-import os from "node:os";
-import path from "node:path";
-export const ENV_ONTO_PLUGIN_DIR = "ONTO_PLUGIN_DIR";
-/** The default Claude Code plugin install location. */
-export const CLAUDE_CODE_PLUGIN_DEFAULT_PATH = path.join(os.homedir(), ".claude", "plugins", "onto");
-/**
- * Resolve the onto plugin install directory.
- *
- * Returns null when no install is found. Callers in the plugin's own runtime
- * (where __dirname can locate the source) may use repo-relative paths as a
- * default; documentation reads should error out when this returns null.
- */
-export function resolvePluginPath() {
-    const envOverride = process.env[ENV_ONTO_PLUGIN_DIR];
-    if (typeof envOverride === "string" && envOverride.length > 0) {
-        const expanded = expandHome(envOverride);
-        return { pluginDir: expanded, source: "env_override" };
-    }
-    if (fsSync.existsSync(CLAUDE_CODE_PLUGIN_DEFAULT_PATH)) {
-        return {
-            pluginDir: CLAUDE_CODE_PLUGIN_DEFAULT_PATH,
-            source: "claude_code_install_default",
-        };
-    }
-    return null;
-}
-/**
- * Resolve a plugin-relative path. Returns null when the plugin install is
- * not found.
- *
- * Example: `resolvePluginRelativePath(".onto/processes/reconstruct.md")` returns
- * `/home/user/.claude/plugins/onto/.onto/processes/reconstruct.md` (or whatever
- * `ONTO_PLUGIN_DIR` resolves to).
- */
-export function resolvePluginRelativePath(relativePath) {
-    const resolution = resolvePluginPath();
-    if (!resolution)
-        return null;
-    return path.join(resolution.pluginDir, relativePath);
-}
-function expandHome(p) {
-    if (p.startsWith("~/") || p === "~") {
-        return path.join(os.homedir(), p.slice(p === "~" ? 1 : 2));
-    }
-    return p;
-}

package/dist/core-runtime/discovery/plugin-path.test.js

@@ -1,95 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import path from "node:path";
-import { resolvePluginPath, resolvePluginRelativePath, ENV_ONTO_PLUGIN_DIR, } from "./plugin-path.js";
-let savedEnvOverride;
-let savedHomeOverride;
-let scratchDir;
-beforeEach(() => {
-    savedEnvOverride = process.env[ENV_ONTO_PLUGIN_DIR];
-    delete process.env[ENV_ONTO_PLUGIN_DIR];
-    // Redirect HOME to a scratch dir so the real ~/.claude/plugins/onto/ doesn't
-    // accidentally satisfy the default-detection branch.
-    savedHomeOverride = process.env.HOME;
-    scratchDir = mkdtempSync(path.join(tmpdir(), "plugin-path-test-"));
-    process.env.HOME = scratchDir;
-});
-afterEach(() => {
-    if (savedEnvOverride === undefined) {
-        delete process.env[ENV_ONTO_PLUGIN_DIR];
-    }
-    else {
-        process.env[ENV_ONTO_PLUGIN_DIR] = savedEnvOverride;
-    }
-    if (savedHomeOverride === undefined) {
-        delete process.env.HOME;
-    }
-    else {
-        process.env.HOME = savedHomeOverride;
-    }
-    try {
-        rmSync(scratchDir, { recursive: true, force: true });
-    }
-    catch { }
-});
-describe("resolvePluginPath", () => {
-    it("returns null when no env override and no Claude install present", () => {
-        // os.homedir() typically caches HOME at process start, so resolvePluginPath
-        // may still see the original ~/.claude/plugins/onto/ if it exists.
-        // This test asserts the env-override priority over both, by NOT setting it.
-        // The base-case "returns null" is harder to assert in environments where
-        // ~/.claude/plugins/onto/ exists; we only assert the absence of env crash.
-        const result = resolvePluginPath();
-        // Either null (clean env) or claude_code_install_default (real install)
-        if (result !== null) {
-            expect(result.source).toBe("claude_code_install_default");
-        }
-    });
-    it("env override beats default detection", () => {
-        const overridePath = mkdtempSync(path.join(tmpdir(), "onto-plugin-override-"));
-        try {
-            process.env[ENV_ONTO_PLUGIN_DIR] = overridePath;
-            const result = resolvePluginPath();
-            expect(result).not.toBeNull();
-            expect(result.pluginDir).toBe(overridePath);
-            expect(result.source).toBe("env_override");
-        }
-        finally {
-            rmSync(overridePath, { recursive: true, force: true });
-        }
-    });
-    it("env override expands ~ to HOME", () => {
-        // Create a fake plugin dir under the scratched HOME.
-        const fakePluginDir = path.join(scratchDir, "myplugin");
-        mkdirSync(fakePluginDir, { recursive: true });
-        process.env[ENV_ONTO_PLUGIN_DIR] = "~/myplugin";
-        const result = resolvePluginPath();
-        expect(result).not.toBeNull();
-        expect(result.pluginDir).toBe(fakePluginDir);
-        expect(result.source).toBe("env_override");
-    });
-});
-describe("resolvePluginRelativePath", () => {
-    it("appends relative path to resolved plugin dir", () => {
-        const overridePath = mkdtempSync(path.join(tmpdir(), "onto-plugin-rel-"));
-        try {
-            process.env[ENV_ONTO_PLUGIN_DIR] = overridePath;
-            const result = resolvePluginRelativePath(".onto/processes/reconstruct.md");
-            expect(result).toBe(path.join(overridePath, ".onto/processes/reconstruct.md"));
-        }
-        finally {
-            rmSync(overridePath, { recursive: true, force: true });
-        }
-    });
-    it("returns null when plugin path cannot be resolved (env unset, no install)", () => {
-        // Skip if real ~/.claude/plugins/onto/ exists in the test runner env.
-        // We can't reliably test the "returns null" branch in CI environments
-        // where Claude Code is installed.
-        const result = resolvePluginRelativePath(".onto/processes/reconstruct.md");
-        if (result !== null) {
-            // Real install present — verify it ends with the relative path.
-            expect(result.endsWith(".onto/processes/reconstruct.md")).toBe(true);
-        }
-    });
-});

package/dist/core-runtime/evolve/adapters/code-product/compile/compile-defense.js

@@ -1,344 +0,0 @@
-import { isEvidenceUnverified } from "../../../../scope-runtime/types.js";
-// ─── Main ───
-/**
- * Run Compile Defense — 2-layer verification.
- *
- * Layer 1 (Checklist): Every non-invalidated constraint is in Section 3.
- * Layer 2 (Audit Pass): inject reflected, defer non-interfering,
- *   override non-reflected, traceability chain CST→IMPL→CHG→VAL complete.
- *
- * Pure function: no side effects.
- */
-export function compileDefense(state, buildSpec, deltaSet, validationPlan, brownfieldDetail, brownfieldContext) {
-    const violations = [];
-    const warnings = [];
-    checkLayer1(state, buildSpec, violations);
-    checkLayer2(state, buildSpec, deltaSet, validationPlan, violations);
-    checkLayer3(state, buildSpec, deltaSet, brownfieldDetail, brownfieldContext, warnings);
-    const errors = violations;
-    if (errors.length === 0) {
-        return { passed: true, warnings };
-    }
-    return { passed: false, violations: errors, warnings };
-}
-// ─── Layer 1: Checklist ───
-function checkLayer1(state, buildSpec, violations) {
-    const section3Ids = new Set(buildSpec.section3.map((e) => e.constraint_id));
-    for (const c of state.constraint_pool.constraints) {
-        if (c.status === "invalidated")
-            continue;
-        if (!section3Ids.has(c.constraint_id)) {
-            violations.push({
-                rule: "L1-checklist",
-                detail: `${c.constraint_id ?? "UNKNOWN-CST"} is not referenced in Build Spec Section 3`,
-            });
-        }
-    }
-}
-// ─── Layer 2: Audit Pass ───
-function checkLayer2(state, buildSpec, deltaSet, validationPlan, violations) {
-    const implIds = new Set(buildSpec.section4.map((e) => e.impl_id));
-    const changeCstIds = new Set(deltaSet.changes.flatMap((c) => c.related_cst));
-    const changeFilePaths = new Set(deltaSet.changes.map((c) => normalizeFilePath(c.file_path)));
-    const valCstIds = new Set(validationPlan.map((v) => v.related_cst));
-    for (const c of state.constraint_pool.constraints) {
-        if (c.status === "invalidated")
-            continue;
-        const decision = c.decision;
-        if (!decision)
-            continue;
-        switch (decision) {
-            case "inject":
-                checkInjectReflected(c, buildSpec, implIds, changeCstIds, valCstIds, violations);
-                break;
-            case "defer":
-                checkDeferNonInterfering(c, deltaSet, changeFilePaths, violations);
-                break;
-            case "override":
-                checkOverrideNonReflected(c, deltaSet, changeFilePaths, violations);
-                break;
-            default:
-                violations.push({
-                    rule: "L2-decision-unexpected",
-                    detail: `${c.constraint_id ?? "UNKNOWN-CST"} has unexpected decision "${decision ?? "UNKNOWN"}" at compile time`,
-                });
-                break;
-        }
-    }
-    // Traceability chain: every IMPL has at least one CHG
-    checkImplHasChanges(buildSpec, deltaSet, violations);
-    // Reverse traceability: every CHG.related_impl references a valid IMPL
-    checkChangesReferenceValidImpls(buildSpec, deltaSet, implIds, violations);
-    // inject constraints should have edge cases in validation plan
-    checkInjectEdgeCases(state, validationPlan, violations);
-}
-/** inject → must have IMPL, CHG referencing this CST, and VAL item */
-function checkInjectReflected(c, buildSpec, implIds, changeCstIds, valCstIds, violations) {
-    // CST → IMPL
-    const relatedImpls = buildSpec.section4.filter((impl) => impl.related_cst.includes(c.constraint_id));
-    if (relatedImpls.length === 0) {
-        violations.push({
-            rule: "L2-inject-impl",
-            detail: `${c.constraint_id ?? "UNKNOWN-CST"} (inject) has no IMPL in Section 4`,
-        });
-    }
-    // CST → CHG
-    if (!changeCstIds.has(c.constraint_id)) {
-        violations.push({
-            rule: "L2-inject-chg",
-            detail: `${c.constraint_id ?? "UNKNOWN-CST"} (inject) has no CHG in delta-set`,
-        });
-    }
-    // CST → VAL
-    if (!valCstIds.has(c.constraint_id)) {
-        violations.push({
-            rule: "L2-inject-val",
-            detail: `${c.constraint_id ?? "UNKNOWN-CST"} (inject) has no VAL in validation-plan`,
-        });
-    }
-}
-/** defer → source_refs files must not appear in delta-set changes */
-function checkDeferNonInterfering(c, deltaSet, changeFilePaths, violations) {
-    for (const ref of c.source_refs) {
-        if (changeFilePaths.has(normalizeFilePath(ref.source))) {
-            violations.push({
-                rule: "L2-defer-interfere",
-                detail: `${c.constraint_id ?? "UNKNOWN-CST"} (defer) source_ref "${ref.source ?? "UNKNOWN"}" is modified in delta-set. 간섭 여부를 확인하세요.`,
-            });
-        }
-    }
-}
-/** override → source_refs files must not have changes related to this CST */
-function checkOverrideNonReflected(c, deltaSet, changeFilePaths, violations) {
-    for (const change of deltaSet.changes) {
-        if (change.related_cst.includes(c.constraint_id) &&
-            c.source_refs.some((ref) => normalizeFilePath(ref.source) === normalizeFilePath(change.file_path))) {
-            violations.push({
-                rule: "L2-override-reflected",
-                detail: `${c.constraint_id ?? "UNKNOWN-CST"} (override) is reflected in delta-set change ${change.change_id ?? "UNKNOWN-CHG"}`,
-            });
-        }
-    }
-}
-/** Every CHG with non-empty related_impl must reference valid IMPLs in Section 4 */
-function checkChangesReferenceValidImpls(buildSpec, deltaSet, implIds, violations) {
-    for (const change of deltaSet.changes) {
-        // CHG with empty related_impl is allowed (e.g. defer/override context changes)
-        if (change.related_impl.length === 0)
-            continue;
-        for (const implId of change.related_impl) {
-            if (!implIds.has(implId)) {
-                violations.push({
-                    rule: "L2-chg-orphan-impl",
-                    detail: `${change.change_id ?? "UNKNOWN-CHG"} references ${implId ?? "UNKNOWN-IMPL"} which does not exist in Section 4`,
-                });
-            }
-        }
-    }
-}
-/** Every IMPL must have at least one CHG */
-function checkImplHasChanges(buildSpec, deltaSet, violations) {
-    const implsWithChanges = new Set(deltaSet.changes.flatMap((c) => c.related_impl));
-    for (const impl of buildSpec.section4) {
-        if (!implsWithChanges.has(impl.impl_id)) {
-            violations.push({
-                rule: "L2-impl-no-chg",
-                detail: `${impl.impl_id ?? "UNKNOWN-IMPL"} has no CHG in delta-set`,
-            });
-        }
-    }
-}
-/** inject constraints should have at least 1 edge_case in validation plan */
-function checkInjectEdgeCases(state, validationPlan, violations) {
-    const injectConstraints = state.constraint_pool.constraints.filter((c) => c.status !== "invalidated" && c.decision === "inject");
-    for (const c of injectConstraints) {
-        const valItem = validationPlan.find((v) => v.related_cst === c.constraint_id);
-        if (valItem && (!valItem.edge_cases || valItem.edge_cases.length === 0)) {
-            violations.push({
-                rule: "L2-inject-edge-case",
-                detail: `${c.constraint_id ?? "UNKNOWN-CST"} (inject) has no edge_cases in validation plan item ${valItem.val_id ?? "UNKNOWN-VAL"}`,
-            });
-        }
-    }
-}
-// ─── Layer 3: Evidence Quality Warnings (non-blocking) ───
-function checkLayer3(state, buildSpec, deltaSet, brownfieldDetail, brownfieldContext, warnings) {
-    checkUnverifiedInject(state, warnings);
-    checkPolicyChangeRequired(state, warnings);
-    checkStateCompleteness(state, buildSpec, brownfieldDetail, warnings);
-    checkSharedResource(deltaSet, warnings);
-    checkInvariantCoverage(state, buildSpec, deltaSet, brownfieldDetail, warnings);
-    checkBrownfieldCoverage(deltaSet, brownfieldContext, warnings);
-}
-/**
- * Warn (not block) when a required+inject constraint has unverified evidence.
- */
-function checkUnverifiedInject(state, warnings) {
-    for (const c of state.constraint_pool.constraints) {
-        if (c.status === "invalidated")
-            continue;
-        if (c.decision !== "inject")
-            continue;
-        if (c.severity !== "required")
-            continue;
-        if (isEvidenceUnverified(c.evidence_status)) {
-            warnings.push({
-                rule: "L3-unverified-inject",
-                detail: `${c.constraint_id} (required, inject) has evidence_status="${c.evidence_status}". 정책 문서에서 확인되지 않은 가정이 구현에 포함됩니다.${c.evidence_note ? ` Note: ${c.evidence_note}` : ""}`,
-            });
-        }
-    }
-}
-/**
- * Warn (not block) when an inject constraint has requires_policy_change=true.
- * Independent from L3-unverified-inject (evidence quality).
- */
-function checkPolicyChangeRequired(state, warnings) {
-    for (const c of state.constraint_pool.constraints) {
-        if (c.status === "invalidated")
-            continue;
-        if (c.decision !== "inject")
-            continue;
-        if (!c.requires_policy_change)
-            continue;
-        warnings.push({
-            rule: "L3-policy-change-required",
-            detail: `${c.constraint_id ?? "UNKNOWN-CST"} (inject)는 기존 정책 변경을 전제합니다. 구현 전 법무/정책 검토가 필요합니다.${c.evidence_note ? ` 참고: ${c.evidence_note}` : ""}`,
-        });
-    }
-}
-/**
- * Warn when brownfieldDetail.enums defines enum values that are not
- * mentioned anywhere in the build spec (constraint summaries, IMPL related_cst,
- * or brownfield sections). Detects missing state mappings
- * (e.g., NOSHOW_BOTH not covered by any implementation).
- */
-function checkStateCompleteness(state, buildSpec, brownfieldDetail, warnings) {
-    if (!brownfieldDetail?.enums || brownfieldDetail.enums.length === 0)
-        return;
-    // Collect all relevant text from constraints, impl references, and brownfield content
-    const constraintText = state.constraint_pool.constraints
-        .map((c) => `${c.summary} ${c.selected_option ?? ""}`)
-        .join(" ");
-    const sectionText = brownfieldDetail.sections
-        .map((s) => s.content)
-        .join(" ");
-    const searchText = `${constraintText} ${sectionText}`;
-    for (const enumDef of brownfieldDetail.enums) {
-        const uncovered = enumDef.values.filter((val) => !searchText.includes(val));
-        if (uncovered.length > 0) {
-            warnings.push({
-                rule: "L3-state-completeness",
-                detail: `${enumDef.name} (source: ${enumDef.source})의 다음 값이 구현 계획에서 언급되지 않습니다: ${uncovered.join(", ")}. 상태 매핑이 누락되었을 수 있습니다.`,
-            });
-        }
-    }
-}
-/**
- * Warn when multiple *separate* CHGs targeting the same file come from different CSTs.
- * A single CHG referencing multiple CSTs is NOT flagged (one change serving multiple constraints is normal).
- */
-function checkSharedResource(deltaSet, warnings) {
-    // Build: file_path → Map<cst_id, Set<change_id>>
-    const fileCstChanges = new Map();
-    for (const chg of deltaSet.changes) {
-        if (chg.related_cst.length === 0)
-            continue;
-        if (!fileCstChanges.has(chg.file_path)) {
-            fileCstChanges.set(chg.file_path, new Map());
-        }
-        const cstMap = fileCstChanges.get(chg.file_path);
-        for (const cst of chg.related_cst) {
-            if (!cstMap.has(cst))
-                cstMap.set(cst, new Set());
-            cstMap.get(cst).add(chg.change_id);
-        }
-    }
-    for (const [filePath, cstMap] of fileCstChanges) {
-        // Only warn if there are 2+ CSTs AND they come from different CHGs
-        if (cstMap.size < 2)
-            continue;
-        // Check that at least 2 CSTs have non-overlapping CHG sets
-        const chgSets = [...cstMap.values()];
-        let hasDistinctSources = false;
-        for (let i = 0; i < chgSets.length && !hasDistinctSources; i++) {
-            for (let j = i + 1; j < chgSets.length; j++) {
-                const overlap = [...chgSets[i]].some(id => chgSets[j].has(id));
-                if (!overlap) {
-                    hasDistinctSources = true;
-                    break;
-                }
-            }
-        }
-        if (hasDistinctSources) {
-            const cstIds = [...cstMap.keys()];
-            warnings.push({
-                rule: "L3-shared-resource",
-                detail: `${filePath}을(를) ${cstIds.length}개 CST가 별개의 변경으로 동시에 수정합니다: ${cstIds.join(", ")}. 조합 충돌 여부를 확인하세요.`,
-            });
-        }
-    }
-}
-/**
- * Warn when delta-set changes modify files listed in brownfieldDetail.invariants
- * but the invariant is not mentioned in any constraint or IMPL.
- */
-function checkInvariantCoverage(state, buildSpec, deltaSet, brownfieldDetail, warnings) {
-    if (!brownfieldDetail?.invariants || brownfieldDetail.invariants.length === 0)
-        return;
-    const changeFilePaths = new Set(deltaSet.changes.map(c => normalizeFilePath(c.file_path)));
-    // Build search text from constraints + IMPL references in buildSpec
-    const constraintText = state.constraint_pool.constraints
-        .map(c => `${c.constraint_id} ${c.summary} ${c.selected_option ?? ""} ${c.decision ?? ""}`)
-        .join(" ");
-    const implText = buildSpec.section4
-        .map(impl => `${impl.impl_id} ${impl.related_cst.join(" ")}`)
-        .join(" ");
-    const searchText = `${constraintText} ${implText}`;
-    for (const inv of brownfieldDetail.invariants) {
-        // Check if any affected_files are in the delta-set changes
-        const affected = inv.affected_files?.some(f => changeFilePaths.has(normalizeFilePath(f))) ?? false;
-        if (!affected)
-            continue;
-        // Check if the invariant is mentioned in constraints or IMPL
-        const mentioned = searchText.includes(inv.name) || searchText.includes(inv.description.slice(0, 30));
-        if (!mentioned) {
-            warnings.push({
-                rule: "L3-invariant-uncovered",
-                detail: `불변 제약 "${inv.name}" (${inv.description})의 영향 파일이 delta-set에서 변경되지만, 구현 계획에서 언급되지 않습니다.`,
-            });
-        }
-    }
-}
-// ─── Path normalization for compile-defense ───
-/**
- * Normalize a file path for string comparison.
- * Removes leading ./, trailing /, and collapses consecutive /.
- * Does NOT resolve to absolute paths — keeps relative paths as-is.
- */
-export function normalizeFilePath(p) {
-    return p
-        .replace(/^\.\//, "")
-        .replace(/\/+/g, "/")
-        .replace(/\/$/, "");
-}
-// ─── Layer 3: Brownfield Coverage ───
-/**
- * Warn when delta-set modify/delete targets a file not in brownfield.related_files.
- * This indicates the agent planned a change without scanning the existing code.
- */
-function checkBrownfieldCoverage(deltaSet, brownfieldContext, warnings) {
-    if (!brownfieldContext?.related_files || brownfieldContext.related_files.length === 0)
-        return;
-    const brownfieldPaths = new Set(brownfieldContext.related_files.map((f) => normalizeFilePath(f.path)));
-    const modifyDeleteChanges = deltaSet.changes.filter((c) => c.action === "modify" || c.action === "delete");
-    for (const chg of modifyDeleteChanges) {
-        const normalized = normalizeFilePath(chg.file_path);
-        if (!brownfieldPaths.has(normalized)) {
-            warnings.push({
-                rule: "L3-modify-not-in-brownfield",
-                detail: `${chg.file_path} (${chg.action})가 brownfield.related_files에 등록되지 않았습니다. 기존 코드 구조를 확인했는지 검증하세요.`,
-            });
-        }
-    }
-}