soloforge 1.2.19 → 1.3.0

package/dist/engine/release_gate.js

@@ -0,0 +1,675 @@
+/**
+ * 发布门禁 — 统一入口。
+ *
+ * validate-release (npm/CLI) 的运行时检查逻辑。
+ * 旧 validate-batch* gate 仅代表历史施工检查，不代表正式发布通过。
+ */
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import matter from "gray-matter";
+export async function runReleaseGate(cwd) {
+    const failures = [];
+    function hardFail(m) { failures.push(m); }
+    function pass(_m) { }
+    // ═══ 1: 源文件存在 ═══
+    const SRCS = [
+        "src/engine/plan_proposal_gate.ts", "src/engine/core_experience_principle.ts",
+        "src/engine/knowledge_asset_schema.ts", "src/engine/knowledge_asset_audit.ts",
+        "src/engine/knowledge_consumption_snapshot.ts", "src/engine/knowledge_asset_generation_gate.ts",
+        "src/engine/knowledge_asset_migration.ts", "src/engine/knowledge_asset_consumer.ts",
+        "src/engine/consumption_trace_store.ts", "src/engine/release_gate_scenario_registry.ts",
+        "tests/engine/release_gate_scenario_matrix.test.ts",
+    ];
+    for (const f of SRCS) {
+        if (!fs.existsSync(path.join(cwd, f)))
+            hardFail("src: " + f);
+    }
+    pass(SRCS.length + " src files");
+    // ═══ 2: Registry 交叉引用 ═══
+    const MIDS = ["mc-plan-proposal-gate", "mc-core-experience-principle", "mc-knowledge-asset-governance"];
+    function chk(f, ps, label) {
+        const c = fs.readFileSync(path.join(cwd, f), "utf-8");
+        for (const p of ps) {
+            if (!c.includes(p)) {
+                hardFail(label + ": " + f + " missing " + p);
+                return;
+            }
+        }
+    }
+    chk("src/engine/mechanism_contract_registry.ts", MIDS.map(m => 'id: "' + m + '"'), "mcr");
+    chk("src/engine/dual_layer_mechanism_registry.ts", MIDS.map(m => 'mechanism_id: "' + m + '"'), "dlm");
+    chk("src/engine/consumable_asset_registry.ts", MIDS.map(m => 'owner_mechanism_id: "' + m + '"'), "car");
+    chk("src/engine/contract_registry.ts", ["plan_proposal_gate_contract", "core_experience_principle_contract", "knowledge_asset_governance_contract"], "cr");
+    const mc = (fs.readFileSync(path.join(cwd, "src/engine/mechanism_contract_registry.ts"), "utf-8").match(/id:\s*"mc-/g) || []).length;
+    if (mc < 31)
+        hardFail("mechanisms " + mc + " < 31");
+    else
+        pass("mechanisms: " + mc);
+    // ═══ 4: Plan Gate 活性测试 + 真实 TaskContext + 真实写工具 handler 拦截 ═══
+    let planGateActiveTestsPassed = false;
+    try {
+        const ppg = await import("./plan_proposal_gate.js");
+        // 基础活性
+        const noPlan = ppg.evaluatePlanProposalGate({ task_id: "x", task_type: "code_change", user_intent: "修改代码", plan_level: "none_with_reason", evidence_refs: [] });
+        if (noPlan.passed)
+            hardFail("Plan Gate: code_change no plan should be blocked");
+        const noConfirm = ppg.evaluatePlanProposalGate({ task_id: "x", task_type: "high_risk_operation", user_intent: "删除数据库", plan_level: "execution_plan", plan_summary_zh: "x", proposed_steps: ["x"], verification_plan: ["x"], risks: ["x"], evidence_refs: ["x"] });
+        if (noConfirm.passed)
+            hardFail("Plan Gate: high_risk no confirm should manual_required");
+        const validPlan = ppg.evaluatePlanProposalGate({ task_id: "x", task_type: "code_change", user_intent: "修改代码", plan_level: "execution_plan", plan_summary_zh: "修改计划", proposed_steps: ["修改"], verification_plan: ["测试"], risks: ["风险"], evidence_refs: ["ev"] });
+        if (!validPlan.passed)
+            hardFail("Plan Gate: valid execution_plan should pass");
+        // R3: 真实 TaskContext — 创建完整生命周期的任务（classification + expansion + executing），不设 plan_proposal_gate
+        const ticr = await import("./tool_invocation_contract_registry.js");
+        const allContracts = ticr.listToolInvocationContracts();
+        const writeTools = allContracts.filter((c) => ticr.hasWriteSideEffect(c.side_effects));
+        const writeToolNames = new Set(writeTools.map((t) => t.tool_name));
+        // 枚举 side effect 类型覆盖
+        const sideEffectTypes = new Set();
+        for (const t of writeTools) {
+            for (const s of t.side_effects)
+                sideEffectTypes.add(s);
+        }
+        if (!sideEffectTypes.has("external_write")) {
+            pass("Plan Gate: external_write 无实际工具 (N/A)");
+        }
+        // 通过 registerTools 捕获真实 handler
+        const capturedHandlers = new Map();
+        const mockServer = {
+            tool: (name, _desc, _schema, handler) => {
+                capturedHandlers.set(name, handler);
+            },
+        };
+        const { TaskContextManager: TCM } = await import("./task_context.js");
+        const gateTcm = new TCM(path.join(os.tmpdir(), `.sf-gate-plan-test-${Date.now()}`));
+        const gateConfig = { name: "gate-test", tech_stack: { backend: { lang: "ts", framework: "express", version: "5" }, frontend: { lang: "ts", framework: "react", version: "18" } }, product_profile: "test", repos: [], build_commands: { backend: { build: "", test: "", full: "" }, frontend: { build: "", test: "", full: "" } }, scope: { backend: [], frontend: [] }, _projectPath: cwd };
+        const KiManager = (await import("../knowledge/index_manager.js")).KnowledgeIndexManager;
+        const gateKi = new KiManager(gateConfig, { watch: false });
+        await gateKi.build();
+        const toolsModule = await import("../adapters/claude_code/tools.js");
+        await toolsModule.registerTools(mockServer, { config: gateConfig, knowledgeIndex: gateKi, taskContext: gateTcm });
+        await gateKi.close();
+        // 创建真实 TaskContext，走完整 classifying → expanding → executing 生命周期
+        const gateTask = await gateTcm.create("gate plan test intent", "gate-test");
+        await gateTcm.setClassification(gateTask.task_id, {
+            task_type: "feature", strategy: "full_pipeline",
+            risk: "low", complexity: "medium", ambiguity: "low",
+            affected_repos: [], mode: "autonomous",
+        });
+        await gateTcm.updateStatus(gateTask.task_id, "expanding");
+        await gateTcm.setExpansion(gateTask.task_id, {
+            task_id: gateTask.task_id, prompt: "gate test prompt",
+            scope: { allowed_paths: ["src/"], readonly_paths: [], new_files_allowed: true },
+            acceptance: { automated: [], manual: [] },
+            matched_patterns: [], matched_knowledge: [], is_legacy_code: false, degraded: false,
+            workflow_trace: { workflow_id: "code_change-code_execution", route: "code_change", execution_shape: "code_execution", mutation_allowed: true, required_mechanisms: [], governance_findings: [], degraded: false, state_transition_target: "executing" },
+            contract: { goal: "gate test", scope: [], constraints: [], verification: [], stop_conditions: [] },
+            output_artifact_record: undefined,
+        });
+        await gateTcm.updateStatus(gateTask.task_id, "executing");
+        // 故意不设 plan_proposal_gate — 写工具必须被拦截
+        // 验证 TaskContext 状态: classification + expansion + executing 已设置，plan_proposal_gate 未设置
+        const gateCtx = await gateTcm.load(gateTask.task_id);
+        if (!gateCtx) {
+            hardFail("Plan Gate: 真实 TaskContext 创建失败");
+            throw new Error("abort");
+        }
+        if (!gateCtx.classification)
+            hardFail("Plan Gate: TaskContext 缺少 classification");
+        if (!gateCtx.expansion)
+            hardFail("Plan Gate: TaskContext 缺少 expansion");
+        if (gateCtx.status !== "executing")
+            hardFail("Plan Gate: TaskContext 状态应为 executing (got " + gateCtx.status + ")");
+        if (gateCtx.plan_proposal_gate)
+            hardFail("Plan Gate: TaskContext 不应有 plan_proposal_gate");
+        // 对每个写工具调用真实 handler — 验证 Plan Gate 通过真实 TaskContext 拦截
+        const handlerResults = {};
+        for (const tool of writeTools) {
+            const handler = capturedHandlers.get(tool.tool_name);
+            if (!handler) {
+                hardFail(`Plan Gate: ${tool.tool_name} 未在 registerTools 中注册`);
+                continue;
+            }
+            // 调用真实 handler 中间件 — 传入真实 task_id + confirm=true 绕过授权检查
+            const result = await handler({ task_id: gateTask.task_id, confirm: true });
+            const jsonStr = typeof result?.content?.[0]?.text === "string" ? result.content[0].text : JSON.stringify(result?.result ?? result);
+            let parsed = {};
+            try {
+                parsed = JSON.parse(jsonStr);
+            }
+            catch { /* 非 JSON 响应 */ }
+            const isErr = result?.isError === true || !!parsed.error;
+            const diag = parsed.diagnostic_code ?? parsed.violation?.diagnostic_code;
+            const violType = parsed.violation?.violation_type;
+            handlerResults[tool.tool_name] = {
+                reached_plan_gate: diag === "SF-PLAN-5001" && violType === "guard_blocked",
+                is_error: isErr,
+                diagnostic_code: diag,
+                violation_type: violType,
+                blocked_reason: parsed.error ?? parsed.violation?.reason,
+            };
+            if (!isErr) {
+                hardFail(`Plan Gate: ${tool.tool_name} 有完整 TaskContext 但无 plan_proposal_gate 应返回 isError=true`);
+            }
+            if (diag !== "SF-PLAN-5001") {
+                hardFail(`Plan Gate: ${tool.tool_name} 缺 SF-PLAN-5001 (got ${diag}, error=${parsed.error ?? "none"})`);
+            }
+            if (violType !== "guard_blocked") {
+                hardFail(`Plan Gate: ${tool.tool_name} 缺 guard_blocked (got ${violType})`);
+            }
+        }
+        pass("Plan Gate: " + writeTools.length + " write tool handlers 通过真实 TaskContext (classification+expansion+executing) 全部返回 guard_blocked/SF-PLAN-5001");
+        planGateActiveTestsPassed = true;
+    }
+    catch (e) {
+        hardFail("Plan Gate: " + e.message);
+        planGateActiveTestsPassed = false;
+    }
+    // ═══ 5: 场景矩阵 ═══
+    try {
+        const { runAllReleaseGateScenarios, validateReleaseGateScenarioMatrix } = await import("./release_gate_scenario_registry.js");
+        const scenarioResults = runAllReleaseGateScenarios();
+        const matrixResult = validateReleaseGateScenarioMatrix();
+        const failedScenarios = scenarioResults.filter(r => !r.passed);
+        if (!matrixResult.passed || failedScenarios.length > 0) {
+            for (const r of failedScenarios)
+                hardFail("Scenario: " + r.scenario_id + " — " + r.failures.join("; "));
+        }
+        else {
+            pass("Scenario matrix: " + scenarioResults.length + " scenarios passed");
+        }
+    }
+    catch (e) {
+        hardFail("Scenario matrix: " + e.message);
+    }
+    // ═══ 6: 知识审计 ═══
+    function scanDir(dir) {
+        const r = [];
+        const dp = path.join(cwd, dir);
+        if (!fs.existsSync(dp))
+            return r;
+        for (const f of fs.readdirSync(dp)) {
+            if (!f.endsWith(".md"))
+                continue;
+            const fp = path.join(dp, f);
+            const raw = fs.readFileSync(fp, "utf-8");
+            try {
+                const parsed = matter(raw);
+                r.push({ frontmatter: parsed.data || {}, file_path: fp, body: parsed.content || "" });
+            }
+            catch (e) {
+                r.push({ frontmatter: {}, file_path: fp, body: raw });
+                hardFail("YAML parse: " + fp + " — " + e.message);
+            }
+        }
+        return r;
+    }
+    const p0p1 = [...scanDir("templates/knowledge/rules"), ...scanDir("templates/knowledge/procedures"), ...scanDir("templates/knowledge/review_rules"), ...scanDir("templates/knowledge/checklists")];
+    let p2p3c = 0;
+    for (const d of ["templates/knowledge/acceptance_templates", "templates/knowledge/domain", "templates/knowledge/patterns/core", "templates/knowledge/templates", "templates/patterns"]) {
+        const dp = path.join(cwd, d);
+        if (!fs.existsSync(dp))
+            continue;
+        p2p3c += fs.readdirSync(dp).filter(f => f.endsWith(".md")).length;
+    }
+    try {
+        const { auditKnowledgeAssets } = await import("./knowledge_asset_audit.js");
+        const rpt = auditKnowledgeAssets(p0p1);
+        const hf = rpt.findings.filter((f) => f.severity === "hard_fail");
+        if (hf.length > 0) {
+            for (const f of hf)
+                hardFail("P0/P1: " + f.asset_id + " — " + f.detail);
+        }
+        else
+            pass("P0/P1: 0 hard_fail");
+        if (p0p1.length <= 3)
+            hardFail("assets_migrated=" + p0p1.length + " <= 3");
+        else
+            pass("assets_migrated=" + p0p1.length);
+    }
+    catch (e) {
+        hardFail("Audit: " + e.message);
+    }
+    // ═══ 7: 真实消费 trace（5 个路径） ═══
+    let realConsumptionTracePassed = false;
+    let rLen = 0, eLen = 0, vLen = 0, aLen = 0, sLen = 0;
+    const sampleTraces = {};
+    const cts = await import("./consumption_trace_store.js");
+    cts.clearConsumptionTraces();
+    // 1) 真实 router 路径
+    try {
+        const ir = await import("./intent_router.js");
+        ir.routeIntent({ intent: "修改代码实现新功能" });
+        ir.routeIntent({ intent: "分析现有系统架构" });
+    }
+    catch (e) {
+        hardFail("router 路径失败: " + e.message);
+    }
+    // 2) 真实 verifier 路径
+    try {
+        const vr = await import("./verifier.js");
+        const gateConfig = { name: "gate-test", tech_stack: { backend: { lang: "ts", framework: "express", version: "5" }, frontend: { lang: "ts", framework: "react", version: "18" } }, product_profile: "test", repos: [], build_commands: { backend: { build: "npm run build", test: "npm test", full: "npm run build && npm test" }, frontend: { build: "npm run build", test: "npm test", full: "npm run build && npm test" } }, scope: { backend: ["src/"], frontend: ["src/"] }, _projectPath: cwd };
+        vr.generateVerifyCommands(gateConfig, ["src/engine/verifier.ts"], [{ id: "gate-v1", description: "验证构建通过", type: "automated", check_command: "npm run build" }], "code_change", "code_execution");
+    }
+    catch (e) {
+        hardFail("verifier 路径失败: " + e.message);
+    }
+    // 3) 真实 expander 路径
+    try {
+        const KiManager = (await import("../knowledge/index_manager.js")).KnowledgeIndexManager;
+        const kiConfig = { name: "gate-test", tech_stack: { backend: { lang: "ts", framework: "express", version: "5" }, frontend: { lang: "ts", framework: "react", version: "18" } }, product_profile: "test", repos: [], build_commands: { backend: { build: "", test: "", full: "" }, frontend: { build: "", test: "", full: "" } }, scope: { backend: ["src/"], frontend: ["src/"] }, _projectPath: cwd };
+        const ki = new KiManager(kiConfig, { watch: false });
+        await ki.build();
+        const ir = await import("./intent_router.js");
+        const routeDec = ir.routeIntent({ intent: "修改代码实现新功能" });
+        const expander = await import("./intent_expander.js");
+        await expander.expand({
+            intent: "修改代码实现新功能",
+            classification: { task_type: "feature", strategy: "full_pipeline", risk: "low", complexity: "medium", ambiguity: "low", affected_repos: [], mode: "autonomous" },
+            projectPath: cwd,
+            config: kiConfig,
+            knowledgeIndex: ki,
+            route_decision: routeDec,
+        });
+        await ki.close();
+    }
+    catch (e) {
+        hardFail("expander 路径失败: " + e.message);
+    }
+    // 4) 真实 adapter prompt 路径 + 内容检查
+    let claudeMdContent = "";
+    const claudeMdChecks = {};
+    try {
+        const cmd = await import("../adapters/claude_code/claude_md.js");
+        const testConfig = { name: "test", tech_stack: { backend: { lang: "ts", framework: "express", version: "5" }, frontend: { lang: "ts", framework: "react", version: "18" } }, product_profile: "test", repos: [], build_commands: { backend: { build: "", test: "", full: "" }, frontend: { build: "", test: "", full: "" } }, scope: { backend: [], frontend: [] } };
+        claudeMdContent = cmd.generateClaudeMd(testConfig);
+        // R5: 断言 CLAUDE.md 包含真实内容
+        claudeMdChecks["中文语义"] = claudeMdContent.includes("强制工作流") || claudeMdContent.includes("步骤");
+        claudeMdChecks["模板变量"] = claudeMdContent.includes("@sf-hard-rule");
+        claudeMdChecks["输出格式"] = claudeMdContent.includes("## ");
+        claudeMdChecks["消费快照摘要"] = claudeMdContent.includes("SoloForge 集成规则");
+        for (const [k, v] of Object.entries(claudeMdChecks)) {
+            if (!v)
+                hardFail("CLAUDE.md 缺少: " + k);
+        }
+        // 断言 adapter_prompt trace 的 matched_reason 包含 content_verified
+        pass("adapter_prompt content checks: " + Object.values(claudeMdChecks).filter(Boolean).length + "/" + Object.keys(claudeMdChecks).length);
+    }
+    catch (e) {
+        hardFail("adapter_prompt 路径失败: " + e.message);
+    }
+    // 5) 真实 sync_migration 路径 — 包含完整 5 字段
+    try {
+        const { planKnowledgeAssetMigration, checkUserModificationProtection } = await import("./knowledge_asset_migration.js");
+        const testAssets = [
+            { frontmatter: { id: "dl-rule-知识资产治理规则", asset_kind: "hard_rule", version: "1.0", schema: "1.0", hash: "sha256:abc123", user_modified: false, migration_note: "发布门禁测试迁移" }, file_path: "templates/knowledge/rules/知识资产治理规则.md" },
+        ];
+        const plan = planKnowledgeAssetMigration({
+            source_version: "1.0",
+            target_version: "2.0",
+            assets: testAssets,
+            schema_changes: [{ field: "required_evidence", change_type: "added_required" }],
+        });
+        // 验证 user_modified 保护
+        const prot = checkUserModificationProtection("dl-rule-知识资产治理规则", ["dl-rule-知识资产治理规则"], plan);
+        if (!prot.protected)
+            hardFail("sync_migration: user_modified 资产未被保护");
+        // R3 正向: plan 不含 hard_fail_findings
+        if (plan.hard_fail_findings.length > 0)
+            hardFail("sync_migration 正向: 完整五字段不应有 hard_fail_findings (got " + plan.hard_fail_findings.length + ")");
+        // R3 负向测试: 五字段硬契约 — 每个字段缺/空/类型错误必须返回 hard_fail_finding 且不产生 trace
+        const negCases = [
+            { label: "缺 hash", fm: { id: "neg-no-hash", asset_kind: "hard_rule", version: "1.0", schema: "1.0", user_modified: false, migration_note: "test" } },
+            { label: "缺 schema", fm: { id: "neg-no-schema", asset_kind: "hard_rule", version: "1.0", hash: "sha256:abc", user_modified: false, migration_note: "test" } },
+            { label: "缺 version", fm: { id: "neg-no-version", asset_kind: "hard_rule", schema: "1.0", hash: "sha256:abc", user_modified: false, migration_note: "test" } },
+            { label: "缺 user_modified", fm: { id: "neg-no-um", asset_kind: "hard_rule", version: "1.0", schema: "1.0", hash: "sha256:abc", migration_note: "test" } },
+            { label: "缺 migration_note", fm: { id: "neg-no-note", asset_kind: "hard_rule", version: "1.0", schema: "1.0", hash: "sha256:abc", user_modified: false } },
+            { label: "migration_note 空字符串", fm: { id: "neg-empty-note", asset_kind: "hard_rule", version: "1.0", schema: "1.0", hash: "sha256:abc", user_modified: false, migration_note: "" } },
+            { label: "user_modified 类型错误", fm: { id: "neg-um-type", asset_kind: "hard_rule", version: "1.0", schema: "1.0", hash: "sha256:abc", user_modified: "yes", migration_note: "test" } },
+            { label: "hash 空字符串", fm: { id: "neg-empty-hash", asset_kind: "hard_rule", version: "1.0", schema: "1.0", hash: "", user_modified: false, migration_note: "test" } },
+        ];
+        for (const nc of negCases) {
+            const before = cts.getTraceCounts().sync_migration;
+            const negPlan = planKnowledgeAssetMigration({
+                source_version: "1.0", target_version: "2.0",
+                assets: [{ frontmatter: nc.fm, file_path: "neg.md" }],
+                schema_changes: [{ field: "required_evidence", change_type: "added_required" }],
+            });
+            const after = cts.getTraceCounts().sync_migration;
+            if (after > before) {
+                hardFail(`sync_migration 负向 ${nc.label}: 不应产生 trace，但增加了`);
+            }
+            // 硬断言: 必须返回 hard_fail_finding
+            if (negPlan.hard_fail_findings.length === 0) {
+                hardFail(`sync_migration 负向 ${nc.label}: 缺字段必须返回 hard_fail_finding`);
+            }
+            if (!negPlan.hard_fail_findings[0].reason_zh.includes(nc.fm.id ?? "")) {
+                hardFail(`sync_migration 负向 ${nc.label}: hard_fail_finding 缺少资产 ID`);
+            }
+        }
+        pass("sync_migration 负向: 8 个缺/错字段 fixture 全部返回 hard_fail_finding 且无 trace");
+        // R2 负向: 6 个 affected assets，第 6 个缺 migration_note → 必须在 hard_fail_findings 中
+        // 使用真实 registry 中存在的 asset_id 避免不可解析 trace 失败
+        const realIds = ["dl-rule-知识资产治理规则", "dl-rule-知识注入边界规则", "dl-rule-验证契约规则", "dl-rule-意图路由规则", "dl-rule-工作流契约规则"];
+        const sixAssets = [];
+        for (let i = 0; i < 5; i++) {
+            sixAssets.push({ frontmatter: { id: realIds[i], asset_kind: "hard_rule", version: "1.0", schema: "1.0", hash: `sha256:abc${i}`, user_modified: false, migration_note: `asset ${i}` }, file_path: `six-${i}.md` });
+        }
+        // 第 6 个缺 migration_note
+        sixAssets.push({ frontmatter: { id: "dl-rule-核心体验原则", asset_kind: "hard_rule", version: "1.0", schema: "1.0", hash: "sha256:bad6", user_modified: false }, file_path: "six-6.md" });
+        const sixPlan = planKnowledgeAssetMigration({
+            source_version: "1.0", target_version: "2.0",
+            assets: sixAssets,
+            schema_changes: [{ field: "required_evidence", change_type: "added_required" }],
+        });
+        if (sixPlan.hard_fail_findings.length === 0)
+            hardFail("sync_migration 6 资产: 第 6 个缺 migration_note 必须产生 hard_fail_finding");
+        if (!sixPlan.hard_fail_findings.some(f => f.asset_id === "dl-rule-核心体验原则"))
+            hardFail("sync_migration 6 资产: hard_fail_finding 必须包含第 6 个缺字段资产");
+        if (!sixPlan.hard_fail_findings[0].invalid_fields.includes("migration_note"))
+            hardFail("sync_migration 6 资产: hard_fail_finding 必须标记 migration_note 缺失");
+    }
+    catch (e) {
+        hardFail("sync_migration 路径失败: " + e.message);
+    }
+    // 读取 trace 计数
+    const counts = cts.getTraceCounts();
+    rLen = counts.router;
+    eLen = counts.expander;
+    vLen = counts.verifier;
+    aLen = counts.adapter_prompt;
+    sLen = counts.sync_migration;
+    if (rLen === 0)
+        hardFail("router trace = 0 — 真实消费链路断裂");
+    if (vLen === 0)
+        hardFail("verifier trace = 0 — 真实消费链路断裂");
+    if (eLen === 0)
+        hardFail("expander trace = 0 — 消费链路断裂");
+    if (aLen === 0)
+        hardFail("adapter_prompt trace = 0 — 真实消费链路断裂");
+    if (sLen === 0)
+        hardFail("sync_migration trace = 0 — 真实消费链路断裂");
+    // Trace 完整性 + 合成 ID 检测 + 必须解析到真实 registry 资产
+    const car = await import("./consumable_asset_registry.js");
+    const allTraces = cts.getConsumptionTraces();
+    const SYNTHETIC_PREFIXES = ["route-rule:", "verify-rule:", "expander-route:", "verification:", "route-decision:"];
+    for (const t of allTraces) {
+        if (!t.asset_id || !t.fields_consumed?.length || !t.matched_reason || !t.task_id_or_route) {
+            hardFail("trace incomplete: consumer=" + t.consumer + " asset_id=" + t.asset_id);
+        }
+        for (const prefix of SYNTHETIC_PREFIXES) {
+            if (t.asset_id.startsWith(prefix)) {
+                hardFail("synthetic asset_id: consumer=" + t.consumer + " asset_id=" + t.asset_id);
+            }
+        }
+        const resolved = car.getConsumableAssetById(t.asset_id);
+        if (!resolved) {
+            hardFail("trace asset_id 不可解析: consumer=" + t.consumer + " asset_id=" + t.asset_id);
+        }
+    }
+    // R6: Route 语义断言 — code_change 不应消费 prototype_spec 模板
+    const expanderTraces = allTraces.filter(t => t.consumer === "expander");
+    const prototypeTrace = expanderTraces.find(t => t.asset_id === "acc-原型说明模版");
+    if (prototypeTrace) {
+        hardFail("Route 语义: acc-原型说明模版 (trigger: output_artifact.kind=prototype_spec) 不应在 code_change route 下被消费");
+    }
+    else {
+        pass("Route 语义: acc-原型说明模版 正确排除 (code_change route)");
+    }
+    // R5+R4: adapter_prompt trace 必须包含 content_verified + 章节 hash 证明
+    const adapterTraces = allTraces.filter(t => t.consumer === "adapter_prompt");
+    for (const t of adapterTraces) {
+        if (!t.matched_reason.includes("content_verified")) {
+            hardFail("adapter_prompt trace 未验证内容: asset_id=" + t.asset_id);
+        }
+        if (!t.matched_reason.includes("hash=")) {
+            hardFail("adapter_prompt trace 缺少章节 hash 证明: asset_id=" + t.asset_id);
+        }
+        if (t.matched_reason.includes("hash=missing")) {
+            hardFail("adapter_prompt trace 章节未找到: asset_id=" + t.asset_id);
+        }
+        if (!t.matched_reason.includes("section=")) {
+            hardFail("adapter_prompt trace 缺少 section 标识: asset_id=" + t.asset_id);
+        }
+    }
+    // R3: sync_migration trace 必须包含五字段值（不含默认补丁）
+    const syncTraces = allTraces.filter(t => t.consumer === "sync_migration");
+    for (const t of syncTraces) {
+        if (!t.matched_reason.includes("schema="))
+            hardFail("sync_migration trace 缺 schema: " + t.matched_reason);
+        if (!t.matched_reason.includes("hash="))
+            hardFail("sync_migration trace 缺 hash: " + t.matched_reason);
+        if (!t.matched_reason.includes("user_modified="))
+            hardFail("sync_migration trace 缺 user_modified: " + t.matched_reason);
+        if (!t.matched_reason.includes("note="))
+            hardFail("sync_migration trace 缺 migration_note: " + t.matched_reason);
+        if (t.matched_reason.includes("hash=none")) {
+            hardFail("sync_migration trace 含疑似默认值: " + t.matched_reason);
+        }
+    }
+    // 字段契约校验
+    const fieldContractResult = cts.validateTraceFieldContracts();
+    if (!fieldContractResult.valid) {
+        for (const issue of fieldContractResult.issues)
+            hardFail("字段契约: " + issue);
+    }
+    // 采集样例 trace
+    for (const t of allTraces) {
+        if (!sampleTraces[t.consumer]) {
+            sampleTraces[t.consumer] = { asset_id: t.asset_id, fields_consumed: t.fields_consumed, matched_reason: t.matched_reason };
+        }
+    }
+    // Snapshot 维度
+    try {
+        const { generateKnowledgeConsumptionReport } = await import("./knowledge_asset_consumer.js");
+        const cr = generateKnowledgeConsumptionReport(cwd);
+        const s = cr.snapshot;
+        if (s.total_indexed === 0)
+            hardFail("indexed=0");
+        if (!s.indexed_assets?.length || !s.injected_assets?.length || !Array.isArray(s.filtered_assets) || !Array.isArray(s.degraded_assets) || !Array.isArray(s.conflict_resolutions))
+            hardFail("snapshot missing 5 dims");
+    }
+    catch (e) {
+        hardFail("Snapshot: " + e.message);
+    }
+    realConsumptionTracePassed = rLen > 0 && eLen > 0 && vLen > 0 && aLen > 0 && sLen > 0;
+    // ═══ 8: CEP 真实主链路 — 六入口全闭环（通过真实代码路径验证）═══
+    let cepMainlinePassed = false;
+    try {
+        const cepModule = await import("./core_experience_principle.js");
+        cepModule.clearCepIntegrations();
+        const toolsCep = await import("../adapters/claude_code/tools.js");
+        // ── 1. VERIFY 入口 + 2. DELIVER 入口: 通过提取函数直接测试 ──
+        const verifyPos = await toolsCep.assessCepAfterVerification({ task_id: "cep-pos-1", has_verification_evidence: true });
+        if (!verifyPos.passed)
+            hardFail("CEP-POS-1: 有证据的验证应通过");
+        const verifyNeg1 = await toolsCep.assessCepAfterVerification({ task_id: "cep-neg-v1", has_verification_evidence: false, has_failures: true });
+        if (verifyNeg1.passed)
+            hardFail("CEP-NEG-VERIFY-1: 无证据+有失败 应不通过");
+        const deliverPos = await toolsCep.assessCepBeforeDelivery({ task_id: "cep-pos-2", verification_passed: true, build_passed: true, browser_acceptance_passed: true, guard_passed: true, evidence_sufficient: true, current_status: "completed" });
+        if (deliverPos.decision !== "completed")
+            hardFail("CEP-POS-2: 全部通过应 completed");
+        const deliverNeg1 = await toolsCep.assessCepBeforeDelivery({ task_id: "cep-neg-d1", verification_passed: false, build_passed: true, browser_acceptance_passed: true, guard_passed: true, evidence_sufficient: true, current_status: "completed" });
+        if (deliverNeg1.decision !== "blocked")
+            hardFail("CEP-NEG-DELIVER-1: verification_failed + completed 应 blocked");
+        // ── 3. WORKFLOW RESOLVE 入口: 通过真实 expand → resolveWorkflow 路径 ──
+        cepModule.clearCepIntegrations();
+        {
+            const KiManager = (await import("../knowledge/index_manager.js")).KnowledgeIndexManager;
+            const kiConfig = { name: "cep-wf-test", tech_stack: { backend: { lang: "ts", framework: "express", version: "5" }, frontend: { lang: "ts", framework: "react", version: "18" } }, product_profile: "test", repos: [], build_commands: { backend: { build: "", test: "", full: "" }, frontend: { build: "", test: "", full: "" } }, scope: { backend: ["src/"], frontend: ["src/"] }, _projectPath: cwd };
+            const ki = new KiManager(kiConfig, { watch: false });
+            await ki.build();
+            const ir = await import("./intent_router.js");
+            const routeDec = ir.routeIntent({ intent: "CEP workflow resolve gate test" });
+            const expander = await import("./intent_expander.js");
+            await expander.expand({
+                intent: "CEP workflow resolve gate test",
+                classification: { task_type: "feature", strategy: "full_pipeline", risk: "low", complexity: "medium", ambiguity: "low", affected_repos: [], mode: "autonomous" },
+                projectPath: cwd, config: kiConfig, knowledgeIndex: ki, route_decision: routeDec,
+            });
+            await ki.close();
+        }
+        const wfIntegrations = cepModule.getCepIntegrations();
+        if (!wfIntegrations["workflow_resolve"])
+            hardFail("CEP-WF: expand→resolveWorkflow 未记录 CEP integration");
+        if (!wfIntegrations["workflow_resolve"].passed)
+            hardFail("CEP-WF: 正向 expand 的 workflow_resolve CEP 应 passed");
+        // 负向: 无匹配 route 时 CEP 不记录（route_decision=undefined 不触发 resolveWorkflow）
+        cepModule.clearCepIntegrations();
+        {
+            const KiManager = (await import("../knowledge/index_manager.js")).KnowledgeIndexManager;
+            const kiConfig2 = { name: "cep-wf-neg", tech_stack: { backend: { lang: "ts", framework: "express", version: "5" }, frontend: { lang: "ts", framework: "react", version: "18" } }, product_profile: "test", repos: [], build_commands: { backend: { build: "", test: "", full: "" }, frontend: { build: "", test: "", full: "" } }, scope: { backend: [], frontend: [] }, _projectPath: cwd };
+            const ki2 = new KiManager(kiConfig2, { watch: false });
+            await ki2.build();
+            const expander = await import("./intent_expander.js");
+            await expander.expand({
+                intent: "CEP negative test",
+                classification: { task_type: "feature", strategy: "full_pipeline", risk: "low", complexity: "medium", ambiguity: "low", affected_repos: [], mode: "autonomous" },
+                projectPath: cwd, config: kiConfig2, knowledgeIndex: ki2, route_decision: undefined,
+            });
+            await ki2.close();
+        }
+        // route_decision=undefined 时 expand 不调用 resolveWorkflow，CEP 不记录
+        // ── 4. GUARD EVALUATION 入口: 通过真实 evaluateWriteGuard 路径 ──
+        cepModule.clearCepIntegrations();
+        {
+            const guardModule = await import("./enforcement_guard.js");
+            // 正向: 正常路由写入合法路径 → 不阻断
+            guardModule.evaluateWriteGuard("code_change", "src/foo.ts", ["src/"], "test_contract");
+            // 阻断: 只读路由写入
+            guardModule.evaluateWriteGuard("read_only_analysis", "src/foo.ts", [], "test_contract");
+        }
+        const guardIntegrations = cepModule.getCepIntegrations();
+        if (!guardIntegrations["guard_evaluation"])
+            hardFail("CEP-GUARD: evaluateWriteGuard 未记录 CEP integration");
+        // ── 5. REPAIR REVERIFY 入口: 通过真实 computePhaseDirective 路径 ──
+        cepModule.clearCepIntegrations();
+        {
+            const { computePhaseDirective } = await import("./task_context.js");
+            // 正向: 有 critical findings → repair_reverify
+            const repairCtx = {
+                task_id: "cep-repair-test", created_at: new Date().toISOString(), intent: "test", product_profile: "test", status: "verifying",
+                code_review: { findings: [{ severity: "critical", category: "bug", description: "test critical", file_path: "test.ts", line: 1 }], quality_score: 50, security_score: 50, performance_score: 50, architecture_score: 50, tech_debt_score: 50, task_id: "cep-repair-test" },
+            };
+            const directive = computePhaseDirective(repairCtx);
+            if (directive !== "repair_reverify")
+                hardFail("CEP-REPAIR: 有 critical findings 应返回 repair_reverify (got " + directive + ")");
+        }
+        const repairIntegrations = cepModule.getCepIntegrations();
+        if (!repairIntegrations["repair_reverify"])
+            hardFail("CEP-REPAIR: computePhaseDirective repair_reverify 未记录 CEP integration");
+        if (!repairIntegrations["repair_reverify"].passed)
+            hardFail("CEP-REPAIR: repair_reverify CEP 应 passed (repair_reverify 路径正确)");
+        // ── 6. USER FEEDBACK 入口: findings + integration 双闭环 ──
+        {
+            const ufc = await import("./user_feedback_contract.js");
+            // 正向: 合法中文 completed 反馈 → 无 gc-cep-* findings + integration.passed=true
+            cepModule.clearCepIntegrations();
+            const posFindings = ufc.validateUserFeedbackContract([{
+                    kind: "completed", severity: "success", title: "任务完成", summary: "所有验证通过",
+                    verified: ["构建", "测试"], unverified: [], risks: [],
+                    requires_user_action: false, references: [],
+                }]);
+            const posIntegrations = cepModule.getCepIntegrations();
+            if (!posIntegrations["user_feedback"])
+                hardFail("CEP-FB-POS: validateUserFeedbackContract 未记录 CEP integration");
+            const posCepFindings = posFindings.filter((f) => (f.rule ?? "").startsWith("gc-cep-"));
+            if (posCepFindings.length > 0)
+                hardFail("CEP-FB-POS: 正向中文 completed 反馈不应有 gc-cep-* findings，实际有: " + posCepFindings.map((f) => f.rule).join(","));
+            if (!posIntegrations["user_feedback"].passed)
+                hardFail("CEP-FB-POS: 正向反馈 CEP integration 应 passed");
+            // 负向: 英文无结论无摘要无 next step → gc-cep-not-chinese/gc-cep-no-conclusion/gc-cep-no-summary findings + !passed
+            cepModule.clearCepIntegrations();
+            const negFindings = ufc.validateUserFeedbackContract([{
+                    kind: "progress", severity: "info", title: "", summary: "",
+                    verified: [], unverified: [], risks: [],
+                    requires_user_action: false, references: [],
+                }]);
+            const negIntegrations = cepModule.getCepIntegrations();
+            if (!negIntegrations["user_feedback"])
+                hardFail("CEP-FB-NEG: 即使负向也应有 integration 记录");
+            if (negIntegrations["user_feedback"].passed)
+                hardFail("CEP-FB-NEG: 英文无结论反馈不应 passed");
+            const negCepFindings = negFindings.filter((f) => (f.rule ?? "").startsWith("gc-cep-"));
+            if (negCepFindings.length === 0)
+                hardFail("CEP-FB-NEG: 英文无结论反馈必须有 gc-cep-* findings（不允许 CEP failed 但 findings 为空）");
+            const negRules = negCepFindings.map((f) => f.rule);
+            if (!negRules.includes("gc-cep-not-chinese"))
+                hardFail("CEP-FB-NEG: 英文反馈必须触发 gc-cep-not-chinese");
+            if (!negRules.includes("gc-cep-no-conclusion"))
+                hardFail("CEP-FB-NEG: 无结论反馈必须触发 gc-cep-no-conclusion");
+            // 负向: completed/success 无 verification path → gc-cep-completed-no-verification-path
+            cepModule.clearCepIntegrations();
+            const noPathFindings = ufc.validateUserFeedbackContract([{
+                    kind: "completed", severity: "success", title: "完成", summary: "已结束",
+                    verified: [], unverified: [], risks: [],
+                    requires_user_action: false, references: [],
+                }]);
+            const noPathCepFindings = noPathFindings.filter((f) => f.rule === "gc-cep-completed-no-verification-path");
+            if (noPathCepFindings.length === 0)
+                hardFail("CEP-FB-NOPATH: completed/success 无 verified/references/default_recommendation 必须触发 gc-cep-completed-no-verification-path");
+            // 负向: verification_summary 掩盖未验证项 + 风险 → gc-cep-hidden-critical-failure
+            cepModule.clearCepIntegrations();
+            const maskFindings = ufc.validateUserFeedbackContract([{
+                    kind: "completed", severity: "blocking", title: "验证完成", summary: "部分通过",
+                    verified: ["构建"], unverified: ["集成测试"], risks: ["数据库迁移风险"],
+                    requires_user_action: false, references: [],
+                }]);
+            const maskCepFindings = maskFindings.filter((f) => f.rule === "gc-cep-hidden-critical-failure");
+            if (maskCepFindings.length === 0)
+                hardFail("CEP-FB-MASK: completed+blocking 掩盖失败必须触发 gc-cep-hidden-critical-failure");
+        }
+        // ── 负向: 源码完整性 — 四个接入点必须存在于真实代码中 ──
+        const requiredIntegrations = [
+            { file: "src/engine/intent_expander.ts", marker: "recordCepIntegration(\"workflow_resolve\"", label: "workflow_resolve" },
+            { file: "src/engine/enforcement_guard.ts", marker: "recordCepIntegration(\"guard_evaluation\"", label: "guard_evaluation" },
+            { file: "src/engine/task_context.ts", marker: "recordCepIntegration(\"repair_reverify\"", label: "repair_reverify" },
+            { file: "src/engine/user_feedback_contract.ts", marker: "recordCepIntegration(\"user_feedback\"", label: "user_feedback" },
+        ];
+        for (const ri of requiredIntegrations) {
+            const src = fs.readFileSync(path.join(cwd, ri.file), "utf-8");
+            if (!src.includes(ri.marker)) {
+                hardFail(`CEP 源码完整性: ${ri.file} 缺少 ${ri.marker} — 真实接入不存在`);
+            }
+        }
+        pass("CEP 主链路: 6 入口通过真实代码路径验证 + 4 处源码完整性检查");
+        cepMainlinePassed = true;
+    }
+    catch (e) {
+        hardFail("CEP 主链路测试: " + e.message);
+    }
+    // ═══ 9: 文档 & TaskContext ═══
+    // 注意: 发布门禁场景 (问题五十五/五十六/五十七) 的验证通过 release_gate_scenario_registry 完成，
+    // 不再依赖 Batch 问题集文档中的 implemented_verified 标记。
+    const tc = fs.readFileSync(path.join(cwd, "src/engine/task_context.ts"), "utf-8");
+    if (!tc.includes("setPlanProposalGate"))
+        hardFail("TaskContext missing setPlanProposalGate");
+    if (!tc.includes("checkPlanGateBeforeWrite"))
+        hardFail("TaskContext missing checkPlanGateBeforeWrite");
+    // ═══ 10: 仓库不污染自检 ═══
+    const gatePollution = path.join(cwd, ".sf-gate-plan-test");
+    if (fs.existsSync(gatePollution)) {
+        hardFail("仓库污染: .sf-gate-plan-test 残留在仓库根目录");
+    }
+    // ═══ 汇总 ═══
+    const finalPassed = failures.length === 0 && realConsumptionTracePassed && planGateActiveTestsPassed && cepMainlinePassed && fieldContractResult.valid;
+    return {
+        passed: finalPassed,
+        failures,
+        details: {
+            total_assets_scanned: p0p1.length + p2p3c,
+            assets_migrated: p0p1.length,
+            mechanism_count: mc,
+            trace_lengths: { router: rLen, expander: eLen, verifier: vLen, adapter_prompt: aLen, sync_migration: sLen },
+            runtime_trace_samples: sampleTraces,
+            real_consumption_trace_passed: realConsumptionTracePassed,
+            plan_gate_active_tests_passed: planGateActiveTestsPassed,
+            cep_mainline_passed: cepMainlinePassed,
+            field_contracts_passed: fieldContractResult.valid,
+            field_contract_issues: fieldContractResult.issues,
+            claude_md_content_checks: claudeMdChecks,
+        },
+    };
+}
+//# sourceMappingURL=release_gate.js.map