soloforge 1.4.16 → 2.0.0

package/dist/engine/release_readiness_gate.js

@@ -1,3382 +0,0 @@
-/**
- * 发布就绪门禁 — CLI 和 npm 共用的正式发布检查逻辑。
- *
- * 本模块是 validate-release 的唯一正式入口。
- * 旧 validate-batch* gate 仅代表历史施工检查，不代表正式发布通过。
- *
- * 检查项：
- * 0. dist 旧产物风险
- * 1. Batch 施工痕迹泄漏
- * 2. 双层模型语义归位
- * 3. 主链路真实消费
- * 4. 模板/adapter 更新空洞
- * 5. 旧 gate 误导标记
- * 6. 测试污染初筛
- * 7. Batch 问题文档格式一致性
- * 8. 关键问题消费验证
- * 9. 机制身份一致性
- * 10. P0/P1 知识资产 schema
- * 11. engine console.log 检查
- * 12. 中文注释检查
- * 13. 第五批一致性校验
- * 14. 依赖漏洞扫描
- * 15. 发布问题架构决策与设计产物真实消费
- * 18. 代码可维护性与可观测性契约行为验证
- * 19. 历史问题长期机制化行为验证
- * 20. 诊断码集中治理检查
- * 21. 模板卫生与项目知识消费验证
- * 22. MCP 控制面可信与受控生成链路验证
- */
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { sourceContainsPattern, sourceContainsCall, sourceContainsIdentifier, sourceContainsZodSchema, sourceContainsPropertyAccess, sourceImportsModule, } from "./source_code_matcher.js";
-// ── 辅助函数 ──
-function safeRead(filePath) {
-    try {
-        return fs.readFileSync(filePath, "utf8");
-    }
-    catch {
-        return null;
-    }
-}
-function safeReadLines(filePath) {
-    const content = safeRead(filePath);
-    return content ? content.split("\n") : [];
-}
-// ── 0. dist 旧产物风险 ──
-function checkDistFreshness(rootDir, hardFail) {
-    const srcDir = path.join(rootDir, "src");
-    const distDir = path.join(rootDir, "dist");
-    if (!fs.existsSync(distDir)) {
-        hardFail("DIST_STALE", "dist/ 目录不存在，请先 npm run build", ["dist/"], "构建系统", "旧 gate 不检查 dist 是否存在", "构建");
-        return;
-    }
-    let latestSrc = new Date(0);
-    function findLatestSrc(dir) {
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const full = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                if (entry.name === "node_modules")
-                    continue;
-                findLatestSrc(full);
-            }
-            else if (entry.isFile() && entry.name.endsWith(".ts")) {
-                const stat = fs.statSync(full);
-                if (stat.mtime > latestSrc)
-                    latestSrc = stat.mtime;
-            }
-        }
-    }
-    findLatestSrc(srcDir);
-    let oldestDist = new Date(Infinity);
-    let distFileCount = 0;
-    function findOldestDist(dir) {
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const full = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                findOldestDist(full);
-            }
-            else if (entry.isFile() && entry.name.endsWith(".js")) {
-                distFileCount++;
-                const stat = fs.statSync(full);
-                if (stat.mtime < oldestDist)
-                    oldestDist = stat.mtime;
-            }
-        }
-    }
-    findOldestDist(distDir);
-    if (distFileCount === 0) {
-        hardFail("DIST_STALE", "dist/ 中无 .js 文件，请先 npm run build", ["dist/"], "构建系统", "旧 gate 不检查 dist 是否为空", "构建");
-    }
-    else if (oldestDist < latestSrc) {
-        hardFail("DIST_STALE", `dist/ 最旧文件 (${oldestDist.toISOString()}) 早于 src/ 最新文件 (${latestSrc.toISOString()})，存在过期风险`, ["dist/", "src/"], "构建系统", "旧 gate 不检查 dist 与 src 的时间一致性", "构建");
-    }
-}
-// ── 1. Batch 施工痕迹泄漏 ──
-function checkBatchTraceLeakage(rootDir, hardFail, _info) {
-    const srcDir = path.join(rootDir, "src");
-    const batchRegex = /\b(batch[1-5]|batch_[1-5])\b/i;
-    // 白名单: 仅允许 @deprecated 标记和类型中的迁移兼容字段
-    const allowedPatterns = [/deprecated/i, /@deprecated/, /迁移兼容/];
-    const findings = [];
-    function scanDir(dir) {
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const full = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                if (entry.name === "node_modules" || entry.name === "dist")
-                    continue;
-                scanDir(full);
-            }
-            else if (entry.isFile() && entry.name.endsWith(".ts")) {
-                const lines = safeReadLines(full);
-                const rel = path.relative(rootDir, full);
-                for (let i = 0; i < lines.length; i++) {
-                    const line = lines[i];
-                    if (!batchRegex.test(line))
-                        continue;
-                    if (allowedPatterns.some(p => p.test(line)))
-                        continue;
-                    findings.push({ file: rel, line: i + 1, content: line.trim() });
-                }
-            }
-        }
-    }
-    scanDir(srcDir);
-    if (findings.length > 0) {
-        const criticalFindings = findings.filter(f => {
-            if (f.file.startsWith("src/engine/") && !f.content.startsWith("//") && !f.content.startsWith("*"))
-                return true;
-            return false;
-        });
-        for (const f of criticalFindings) {
-            hardFail("BATCH_TRACE_LEAK", `正式代码中发现 batch 施工痕迹: ${f.content}`, [f.file], `${f.file}:${f.line}`, "旧 validate-batch* gate 只检查文件是否存在和测试是否通过，不检查 batch 命名是否泄漏到正式 runtime", "清理");
-        }
-        const nonCritical = findings.filter(f => !criticalFindings.includes(f));
-        for (const f of nonCritical) {
-            _info(`  [注意] batch 引用在: ${f.file}:${f.line} — ${f.content}`);
-        }
-    }
-}
-// ── 2. 双层模型语义归位 ──
-async function checkDualLayerSemantics(rootDir, hardFail, _info) {
-    const registryPath = path.join(rootDir, "dist", "engine", "dual_layer_mechanism_registry.js");
-    const consumablePath = path.join(rootDir, "dist", "engine", "consumable_asset_registry.js");
-    if (!fs.existsSync(registryPath)) {
-        hardFail("REGISTRY_NOT_BUILT", "dual_layer_mechanism_registry.js 未编译，请先 npm run build", ["dist/engine/dual_layer_mechanism_registry.js"], "构建系统", "旧 gate 只检查源文件存在，不检查是否可运行", "构建");
-        return;
-    }
-    let mechanisms = [];
-    let consumableAssets = [];
-    try {
-        const reg = await import(registryPath);
-        mechanisms = reg.listMechanismLayerMaps ? reg.listMechanismLayerMaps() : [];
-    }
-    catch (e) {
-        hardFail("REGISTRY_LOAD_FAIL", `无法加载 dual_layer_mechanism_registry: ${e.message}`, ["dist/engine/dual_layer_mechanism_registry.js"], "构建系统", "旧 gate 只检查源文件存在，不检查运行时可加载", "修复");
-        return;
-    }
-    try {
-        const con = await import(consumablePath);
-        consumableAssets = con.listBuiltinConsumableAssets ? con.listBuiltinConsumableAssets() : [];
-    }
-    catch (e) {
-        _info(`  [警告] 无法加载 consumable_asset_registry: ${e.message}`);
-    }
-    const enforced = mechanisms.filter((m) => m.status === "dual_layer_enforced");
-    for (const mech of enforced) {
-        const assets = mech.template_assets || [];
-        if (assets.length > 0 && assets.every((a) => a.consumption_mode === "supporting")) {
-            hardFail("ALL_SUPPORTING_ASSETS", `机制 ${mech.mechanism_id} 的所有模板资产都是 supporting 模式，无 required 资产: ${assets.map((a) => a.path).join(", ")}`, assets.map((a) => a.path), mech.mechanism_id, "旧 gate 用 template_assets.length > 0 判断模板层通过，不区分 required/supporting", "修复语义归位");
-            continue;
-        }
-        for (const asset of assets) {
-            const inConsumable = consumableAssets.find((ca) => ca.path === asset.path && ca.owner_mechanism_id === mech.mechanism_id);
-            if (!inConsumable) {
-                const assetBasename = path.basename(asset.path, ".md");
-                const mechanismIdShort = mech.mechanism_id.replace("mc-", "");
-                const nameCorresponds = assetBasename.includes(mechanismIdShort) || assetBasename.includes(mech.mechanism_name);
-                if (!nameCorresponds && asset.consumption_mode === "supporting") {
-                    hardFail("TEMPLATE_SEMANTIC_MISALIGN", `机制 ${mech.mechanism_id} 的模板 ${asset.path} 在 consumable_asset_registry 中未声明 owner_mechanism_id 为该机制，且文件名不对应机制名称`, [asset.path, "src/engine/consumable_asset_registry.ts"], mech.mechanism_id, "旧 gate 用 template_assets.length > 0 判断模板层通过，不检查资产是否语义归属该机制", "修复语义归位");
-                }
-            }
-        }
-    }
-    const firstPrinciples = enforced.find((m) => m.mechanism_id === "mc-first-principles");
-    if (firstPrinciples) {
-        const assets = firstPrinciples.template_assets || [];
-        if (assets.length === 1 && assets[0].path.includes("架构设计工作流") && assets[0].consumption_mode === "supporting") {
-            hardFail("FIRST_PRINCIPLES_MISALIGNED", "mc-first-principles 只挂了 架构设计工作流.md（supporting），无自有模板资产。第一性原理检查应有独立的推理框架模板或规则", ["templates/knowledge/procedures/架构设计工作流.md", "src/engine/dual_layer_mechanism_registry.ts"], "mc-first-principles", "旧 gate 用 template_assets.length > 0 判断通过，不检查资产内容是否匹配机制语义", "修复语义归位");
-        }
-    }
-    for (const sm of [{ id: "mc-brainstorm-contract", name: "脑暴与方案探索" }, { id: "mc-detail-discipline", name: "细节纪律" }, { id: "mc-decision-sovereignty", name: "技术决策主权" }]) {
-        const mech = enforced.find((m) => m.mechanism_id === sm.id);
-        if (!mech)
-            continue;
-        const assets = mech.template_assets || [];
-        if (assets.every((a) => a.path.includes("架构设计工作流") || a.path.includes("测试优先编码工作流")) && assets.every((a) => a.consumption_mode === "supporting")) {
-            hardFail("SHARED_SUPPORTING_ONLY", `${sm.id}(${sm.name}) 只挂了共享的 supporting 模板（架构设计工作流/测试优先编码工作流），无自有 required 模板资产`, assets.map((a) => a.path), sm.id, "旧 gate 用 template_assets.length > 0 判断通过，不检查模板是否专属", "修复语义归位");
-        }
-    }
-    // 检查 required template asset 是否在 ASSET_MANIFEST 中注册
-    try {
-        const manifestPath = path.join(rootDir, "dist/engine/asset_manifest.js");
-        const manifestMod = await import(manifestPath);
-        const manifestEntries = manifestMod.ASSET_MANIFEST || [];
-        for (const mech of enforced) {
-            const assets = mech.template_assets || [];
-            for (const asset of assets) {
-                if (asset.consumption_mode !== "required")
-                    continue;
-                const inManifest = manifestEntries.some((me) => me.path === asset.path && me.owner_mechanism_id === mech.mechanism_id && me.consumption_mode === "required");
-                if (!inManifest) {
-                    hardFail("ASSET_MANIFEST_GAP", `机制 ${mech.mechanism_id} 的 required 模板 ${asset.path} 未在 ASSET_MANIFEST 中注册`, [asset.path, "src/engine/asset_manifest.ts"], mech.mechanism_id, "旧 gate 不检查 required 模板是否同步进入 ASSET_MANIFEST", "修复语义归位");
-                }
-            }
-        }
-    }
-    catch (e) {
-        _info(`  [警告] 无法加载 asset_manifest 进行 required 模板检查: ${e.message}`);
-    }
-    _info(`  共检查 ${enforced.length} 个 dual_layer_enforced 机制`);
-}
-// ── 3. 主链路真实消费 ──
-/** 已知的消费者入口→文件映射 */
-const CONSUMER_ENTRY_FILES = {
-    "CLI validate": ["src/bin/soloforge.ts"],
-    "CLI sync-templates": ["src/bin/soloforge.ts"],
-    "CLI sync-adapters": ["src/bin/soloforge.ts"],
-    "CLI migrate": ["src/bin/soloforge.ts"],
-    "CLI validate-knowledge": ["src/engine/knowledge_scenario_registry.ts"],
-    "sf_verify": ["src/engine/verifier.ts"],
-    "sf_deliver": ["src/adapters/claude_code/tools.ts", "src/engine/delivery_readiness.ts"],
-    "sf_expand": ["src/adapters/claude_code/tools.ts", "src/engine/intent_expander.ts"],
-    "问题管理流程": [],
-};
-/** 模块名→文件路径映射 (用于模块间调用链如 "knowledge_evolution.validateCandidateTrust") */
-const MODULE_FILE_MAP = {
-    "knowledge_lifecycle": "src/engine/knowledge_lifecycle.ts",
-    "knowledge_evolution": "src/engine/knowledge_evolution.ts",
-    "chinese_semantic_priority": "src/engine/chinese_semantic_priority.ts",
-    "language_policy": "src/engine/language_policy.ts",
-    "documentation_governance": "src/engine/documentation_governance.ts",
-    "template_sync": "src/engine/template_sync.ts",
-    "user_promise": "src/engine/user_promise.ts",
-    "adapter_prompt_contract": "src/engine/adapter_prompt_contract.ts",
-    "release_compatibility": "src/engine/release_compatibility.ts",
-    "extension_contract": "src/engine/extension_contract.ts",
-    "platform_context": "src/engine/platform_context.ts",
-    "metric_governance": "src/engine/metric_governance.ts",
-    "technology_decision": "src/engine/technology_decision.ts",
-    "brainstorm_contract": "src/engine/brainstorm_contract.ts",
-    "detail_discipline": "src/engine/detail_discipline.ts",
-    "first_principles": "src/engine/first_principles.ts",
-    "architecture_design_contract": "src/engine/architecture_design_contract.ts",
-    "existing_system_analysis": "src/engine/existing_system_analysis.ts",
-    "coding_readiness_gate": "src/engine/coding_readiness_gate.ts",
-    "local_docker_acceptance": "src/engine/local_docker_acceptance.ts",
-    "workflow_template_pack": "src/engine/workflow_template_pack.ts",
-    "evolution_regression_gate": "src/engine/evolution_regression_gate.ts",
-    "delivery_readiness": "src/engine/delivery_readiness.ts",
-    "knowledge_scenario_registry": "src/engine/knowledge_scenario_registry.ts",
-    "intent_expander": "src/engine/intent_expander.ts",
-};
-/** 从调用链文本中解析出所有消费者文件 */
-function resolveConsumerFiles(chainText) {
-    const files = new Set();
-    const segments = chainText.split("→").map(s => s.trim()).filter(Boolean);
-    for (const seg of segments) {
-        // 检查是否匹配已知入口 (如 "CLI validate →" 或 "sf_verify →")
-        for (const [entry, paths] of Object.entries(CONSUMER_ENTRY_FILES)) {
-            if (seg.includes(entry) || seg.startsWith(entry)) {
-                for (const p of paths)
-                    files.add(p);
-            }
-        }
-        // 检查是否匹配 cmdXxx 命令 (如 "cmdValidate")
-        const cmdMatch = seg.match(/cmd([A-Z]\w+)/);
-        if (cmdMatch) {
-            // cmd* 函数通常在 src/bin/soloforge.ts
-            files.add("src/bin/soloforge.ts");
-        }
-        // 检查是否匹配 generateVerifyCommands
-        if (seg.includes("generateVerifyCommands")) {
-            files.add("src/engine/verifier.ts");
-        }
-        // 检查是否匹配 evaluateDeliveryReadiness
-        if (seg.includes("evaluateDeliveryReadiness")) {
-            files.add("src/engine/delivery_readiness.ts");
-            files.add("src/adapters/claude_code/tools.ts");
-        }
-        // 检查是否匹配 cmdSyncTemplates/cmdSyncAdapters/cmdMigrate
-        if (seg.includes("cmdSyncTemplates") || seg.includes("cmdSyncAdapters") || seg.includes("cmdMigrate") || seg.includes("cmdValidate")) {
-            files.add("src/bin/soloforge.ts");
-        }
-        // 检查模块.function 模式 (如 "knowledge_evolution.validateCandidateTrust")
-        for (const [modName, modPath] of Object.entries(MODULE_FILE_MAP)) {
-            if (seg.includes(`${modName}.`) || seg.includes(modName)) {
-                files.add(modPath);
-            }
-        }
-        // 检查 buildTemplateManifestFromSource
-        if (seg.includes("buildTemplateManifestFromSource")) {
-            files.add("src/bin/soloforge.ts");
-        }
-    }
-    return [...files];
-}
-/** 从字符串数组格式的字段中提取文件路径列表 */
-function extractStringArray(rawValue) {
-    // 处理 ["a", "b"] 格式
-    const items = rawValue.match(/["']([^"']+)["']/g) || [];
-    return items.map(s => s.replace(/["']/g, ""));
-}
-/** 从注册表文件内容中提取所有验收条目的结构化数据 */
-function parseAcceptanceEntries(content) {
-    const entries = [];
-    const lines = content.split("\n");
-    let currentEntry = null;
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        // 检测新条目开始 (issue_id 出现)
-        const issueMatch = line.match(/issue_id:\s*["']([^"']+)["']/);
-        if (issueMatch) {
-            if (currentEntry)
-                entries.push(currentEntry);
-            currentEntry = {
-                issue_id: issueMatch[1],
-                owner_files: [],
-                required_entrypoints: [],
-                mainline_consumption_check: "",
-                entryStartLine: i,
-            };
-            continue;
-        }
-        if (!currentEntry)
-            continue;
-        // 提取 owner_files
-        if (line.includes("owner_files:") && !line.includes("//")) {
-            // 可能是单行或多行
-            let raw = line;
-            if (!raw.includes("]")) {
-                let j = i + 1;
-                while (j < lines.length && !raw.includes("]")) {
-                    raw += lines[j];
-                    j++;
-                }
-            }
-            currentEntry.owner_files = extractStringArray(raw.replace(/^.*owner_files:\s*/, ""));
-        }
-        // 提取 required_entrypoints
-        if (line.includes("required_entrypoints:") && !line.includes("//")) {
-            let raw = line;
-            if (!raw.includes("]")) {
-                let j = i + 1;
-                while (j < lines.length && !raw.includes("]")) {
-                    raw += lines[j];
-                    j++;
-                }
-            }
-            currentEntry.required_entrypoints = extractStringArray(raw.replace(/^.*required_entrypoints:\s*/, ""));
-        }
-        // 提取 mainline_consumption_check
-        if (line.includes("mainline_consumption_check:") && !line.includes("//")) {
-            let raw = line;
-            if (!raw.includes("]")) {
-                let j = i + 1;
-                while (j < lines.length && !raw.includes("]")) {
-                    raw += lines[j];
-                    j++;
-                }
-            }
-            currentEntry.mainline_consumption_check = raw.replace(/^.*mainline_consumption_check:\s*/, "");
-        }
-    }
-    if (currentEntry)
-        entries.push(currentEntry);
-    return entries;
-}
-function checkMainlineConsumption(rootDir, hardFail, _info) {
-    const registryFiles = [
-        { filePath: "tests/engine/extension_acceptance_registry.ts", label: "Extension 验收" },
-        { filePath: "src/engine/knowledge_acceptance_registry.ts", label: "知识验收" },
-    ];
-    for (const reg of registryFiles) {
-        const content = safeRead(path.join(rootDir, reg.filePath));
-        if (!content) {
-            _info(`  [跳过] ${reg.filePath} 不存在`);
-            continue;
-        }
-        const entries = parseAcceptanceEntries(content);
-        for (const entry of entries) {
-            // ── 检查 1: owner_files 必须在磁盘上存在 ──
-            for (const ownerFile of entry.owner_files) {
-                const fullPath = path.join(rootDir, ownerFile);
-                if (!fs.existsSync(fullPath)) {
-                    hardFail("MAINLINE_OWNER_FILE_MISSING", `${reg.label}: ${entry.issue_id} 的 owner_file "${ownerFile}" 不存在`, [reg.filePath, ownerFile], entry.issue_id, "旧 gate 不校验 owner_files 是否真实存在", "创建缺失文件或修正 owner_files");
-                }
-            }
-            // ── 检查 2: required_entrypoints 必须在 owner_files 中真实 export ──
-            for (const ep of entry.required_entrypoints) {
-                let found = false;
-                for (const ownerFile of entry.owner_files) {
-                    const srcContent = safeRead(path.join(rootDir, ownerFile));
-                    if (!srcContent)
-                        continue;
-                    // 检查 export function 或 export const 或 export async function
-                    const exportPattern = new RegExp(`export\\s+(async\\s+)?function\\s+${ep}\\b|export\\s+const\\s+${ep}\\b`);
-                    if (exportPattern.test(srcContent)) {
-                        found = true;
-                        break;
-                    }
-                }
-                if (!found) {
-                    hardFail("MAINLINE_ENTRYPOINT_NOT_EXPORTED", `${reg.label}: ${entry.issue_id} 的 required_entrypoint "${ep}" 未在 owner_files 中找到 export`, [reg.filePath, ...entry.owner_files], entry.issue_id, "旧 gate 不校验 required_entrypoints 是否真实导出", "添加缺失的 export 或修正 required_entrypoints");
-                }
-            }
-            // ── 检查 3: 调用链格式 — pending_integration 或至少 2 级 (→ 分隔) ──
-            const chainText = entry.mainline_consumption_check.match(/\[([^\]]+)\]/)?.[1] || "";
-            const isPendingIntegration = chainText.includes("pending_integration");
-            const chainSegments = chainText.split("→").map(s => s.trim()).filter(Boolean);
-            if (isPendingIntegration) {
-                // 诚实标记: 入口已 export 但无生产消费者 — hard_fail 提醒集成未完成
-                hardFail("MAINLINE_PENDING_INTEGRATION", `${reg.label}: ${entry.issue_id} 标记为 pending_integration: ${chainText.replace("pending_integration: ", "")}`, [reg.filePath], entry.issue_id, "入口函数已实现但无真实生产消费路径", "补充消费者源码调用");
-                continue;
-            }
-            if (chainSegments.length < 2) {
-                hardFail("MAINLINE_CHAIN_TOO_SHORT", `${reg.label}: ${entry.issue_id} 的 mainline_consumption_check 调用链不足 2 级: "${chainText}"`, [reg.filePath], entry.issue_id, "调用链必须包含入口→调用→效果至少 2 级", "补充调用链");
-                continue;
-            }
-            // ── 检查 4: 调用链中声称的消费者必须真实 import/call required_entrypoints ──
-            const consumerFiles = resolveConsumerFiles(chainText);
-            if (consumerFiles.length === 0) {
-                // 调用链中的入口无法映射到任何消费者文件
-                hardFail("MAINLINE_CONSUMER_NOT_FOUND", `${reg.label}: ${entry.issue_id} 的调用链入口无法映射到已知消费者文件: "${chainSegments[0]}"`, [reg.filePath], entry.issue_id, "调用链声称的入口没有对应的消费者文件", "补充消费源码或修正调用链描述");
-                continue;
-            }
-            // 对每个 required_entrypoint，验证至少有一条真实消费路径
-            // 路径 A: 消费者文件直接 import + call 该 entrypoint
-            // 路径 B: entrypoint 在 owner_file 内部被同一模块的另一个已消费函数调用 (传递消费)
-            //         条件: 消费者 import 了 owner_file 的某个函数 + entrypoint 在 owner_file 内被调用
-            for (const ep of entry.required_entrypoints) {
-                let consumedByRealCode = false;
-                // 路径 A: 直接消费
-                for (const consumerFile of consumerFiles) {
-                    const consumerContent = safeRead(path.join(rootDir, consumerFile));
-                    if (!consumerContent)
-                        continue;
-                    const staticImportPattern = new RegExp(`import\\s+\\{[^}]*\\b${ep}\\b[^}]*\\}\\s+from`);
-                    const dynamicImportPattern = new RegExp(`\\{[^}]*\\b${ep}\\b[^}]*\\}\\s*=\\s*await\\s+import\\(`);
-                    const hasLazyModuleImport = entry.owner_files.some((ownerFile) => {
-                        const moduleName = path.basename(ownerFile, ".ts");
-                        return sourceImportsModule(consumerContent, `../../engine/${moduleName}.js`)
-                            || sourceImportsModule(consumerContent, `../engine/${moduleName}.js`)
-                            || sourceImportsModule(consumerContent, `./${moduleName}.js`);
-                    });
-                    const hasImport = staticImportPattern.test(consumerContent)
-                        || dynamicImportPattern.test(consumerContent)
-                        || hasLazyModuleImport;
-                    if (!hasImport)
-                        continue;
-                    const importLinePattern = new RegExp(`import\\s+\\{[^}]*\\b${ep}\\b|\\{[^}]*\\b${ep}\\b[^}]*\\}\\s*=\\s*await\\s+import`);
-                    const callLines = consumerContent.split("\n").filter(l => !importLinePattern.test(l) && l.includes(ep));
-                    if (callLines.length > 0) {
-                        consumedByRealCode = true;
-                        break;
-                    }
-                }
-                // 路径 B: 传递消费 — entrypoint 在 owner_file 内部被另一个函数调用
-                // 且消费者 import 了 owner_file 中的某个函数
-                if (!consumedByRealCode) {
-                    for (const ownerFile of entry.owner_files) {
-                        const ownerContent = safeRead(path.join(rootDir, ownerFile));
-                        if (!ownerContent)
-                            continue;
-                        // 检查 entrypoint 在 owner_file 内部被非 export 行调用
-                        const ownerLines = ownerContent.split("\n");
-                        const exportLinePattern = new RegExp(`export\\s+(async\\s+)?function\\s+${ep}\\b|export\\s+const\\s+${ep}\\b`);
-                        const internalCalls = ownerLines.filter(l => !exportLinePattern.test(l) && l.includes(ep));
-                        if (internalCalls.length === 0)
-                            continue; // entrypoint 在 owner_file 内部未被调用
-                        // entrypoint 在 owner_file 内部被调用 — 检查消费者是否 import 了 owner_file 的任何函数
-                        for (const consumerFile of consumerFiles) {
-                            const consumerContent = safeRead(path.join(rootDir, consumerFile));
-                            if (!consumerContent)
-                                continue;
-                            // 检查消费者是否从 owner_file import 了任何东西
-                            const ownerBasename = ownerFile.replace(/^src\/engine\//, "").replace(/\.ts$/, ".js");
-                            const ownerImportPattern = new RegExp(`from\\s+["']\\./${ownerBasename.replace(".js", "")}\\.js["']|from\\s+["']\\.\\./engine/${ownerBasename.replace(".js", "")}\\.js["']`);
-                            // 对于 CLI: from "../engine/xxx.js"
-                            const cliImportPattern = new RegExp(`\\bimport\\s*\\([^)]*${ownerBasename.replace(/\.js$/, "")}`);
-                            if (ownerImportPattern.test(consumerContent) || cliImportPattern.test(consumerContent)) {
-                                consumedByRealCode = true;
-                                break;
-                            }
-                        }
-                        if (consumedByRealCode)
-                            break;
-                    }
-                }
-                if (!consumedByRealCode) {
-                    hardFail("MAINLINE_ENTRYPOINT_NOT_CONSUMED", `${reg.label}: ${entry.issue_id} 的 required_entrypoint "${ep}" 无真实消费路径 (直接或传递)`, [reg.filePath, ...consumerFiles, ...entry.owner_files], entry.issue_id, "旧 gate 不校验消费者是否真实调用入口函数", "补充消费者源码调用或修正 required_entrypoints");
-                }
-            }
-            // ── 检查 5: owner_files 源码中必须包含调用链提到的函数名 ──
-            let funcInSource = false;
-            for (const ownerFile of entry.owner_files) {
-                const srcContent = safeRead(path.join(rootDir, ownerFile));
-                if (!srcContent)
-                    continue;
-                for (const seg of chainSegments) {
-                    const funcName = seg.match(/([a-z][a-zA-Z_]{4,})/)?.[1];
-                    if (funcName && sourceContainsIdentifier(srcContent, funcName)) {
-                        funcInSource = true;
-                        break;
-                    }
-                }
-                if (funcInSource)
-                    break;
-            }
-            if (!funcInSource) {
-                hardFail("MAINLINE_CHAIN_FUNC_NOT_IN_OWNER", `${reg.label}: ${entry.issue_id} 的调用链函数名未在 owner_files 源码中找到`, [reg.filePath, ...entry.owner_files], entry.issue_id, "旧 gate 对调用链与 owner_files 交叉引用失败时仅发 _info", "修正调用链或 owner_files");
-            }
-        }
-    }
-}
-// ── 4. 模板/adapter 更新空洞 ──
-function checkTemplateAdapterGaps(rootDir, hardFail) {
-    const registryFiles = [
-        { filePath: "tests/engine/extension_acceptance_registry.ts", label: "Extension 验收" },
-        { filePath: "src/engine/knowledge_acceptance_registry.ts", label: "知识验收" },
-    ];
-    for (const reg of registryFiles) {
-        const content = safeRead(path.join(rootDir, reg.filePath));
-        if (!content)
-            continue;
-        const lines = content.split("\n");
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            if (!line.includes("required_template_or_adapter_updates:"))
-                continue;
-            if (line.includes("[]") || line.includes("[ ]")) {
-                const contextBefore = lines.slice(Math.max(0, i - 20), i);
-                const issueMatch = contextBefore.find(l => l.includes("issue_id:"));
-                const issueId = issueMatch ? (issueMatch.match(/issue_id:\s*["']([^"']+)["']/)?.[1] ?? "未知") : "未知";
-                const contextAfter = lines.slice(i, Math.min(lines.length, i + 10));
-                const notApplicable = contextAfter.some(l => l.includes("not_applicable") || l.includes("N/A") || l.includes("不适用"));
-                if (!notApplicable) {
-                    hardFail("TEMPLATE_ADAPTER_GAP", `${reg.label}: ${issueId} 的 required_template_or_adapter_updates 为空，无 not_applicable 说明`, [reg.filePath], issueId, "旧 gate 不检查空数组是否有合理说明", "清理");
-                }
-            }
-        }
-    }
-}
-// ── 5. 旧 gate 误导 ──
-function checkOldGateMisdirection(rootDir, hardFail, _info) {
-    const gateFiles = ["scripts/validate_batch1_gate.mjs", "scripts/validate_batch2_gate.mjs", "scripts/validate_batch3_gate.mjs", "scripts/validate_batch4_gate.mjs", "scripts/validate_batch5_gate.mjs"];
-    // 检查 package.json 中对应脚本是否先输出历史警告
-    const pkgPath = path.join(rootDir, "package.json");
-    const pkgContent = safeRead(pkgPath);
-    const noticeModule = "validate_batch_historical_notice.mjs";
-    let pkgNoticeOk = true;
-    if (pkgContent) {
-        for (let i = 1; i <= 5; i++) {
-            const scriptKey = `"validate-batch${i}"`;
-            const scriptLine = pkgContent.split("\n").find(l => l.includes(scriptKey));
-            if (!scriptLine || !scriptLine.includes(noticeModule)) {
-                hardFail("HISTORICAL_GATE_NOT_RELEASE_PROOF", `package.json 中 ${scriptKey} 未在测试前输出历史 gate 警告（缺少 ${noticeModule}）`, ["package.json"], `validate-batch${i}`, "旧 gate 可能让用户误以为是正式发布门禁", "添加历史声明");
-                pkgNoticeOk = false;
-            }
-        }
-    }
-    // 检查每个旧 gate 脚本是否已降级为历史施工 gate
-    for (const gf of gateFiles) {
-        const content = safeRead(path.join(rootDir, gf));
-        if (!content)
-            continue;
-        const batchNum = gf.match(/batch(\d)/)?.[1] ?? "?";
-        const issues = [];
-        // 1. 顶部注释不得自称 Release Gate
-        if (/Release Gate/.test(content) && !/历史施工 gate/.test(content)) {
-            issues.push("仍自称 Release Gate，未改为历史施工 gate");
-        }
-        // 2. 必须导入 printHistoricalNotice
-        if (!sourceContainsIdentifier(content, "printHistoricalNotice")) {
-            issues.push("缺少 printHistoricalNotice 调用");
-        }
-        // 3. 必须包含 historical_only: true（JSON 输出场景）
-        if (!sourceContainsIdentifier(content, "historical_only") && !sourceContainsIdentifier(content, "getHistoricalJsonFields")) {
-            issues.push("JSON 输出缺少 historical_only: true / getHistoricalJsonFields()");
-        }
-        // 4. 底部消息不得称 Release Gate（应为历史施工 Gate）
-        if (/Release Gate/.test(content)) {
-            issues.push("底部消息仍称 Release Gate");
-        }
-        if (issues.length > 0) {
-            hardFail("HISTORICAL_GATE_NOT_RELEASE_PROOF", `旧 gate ${gf} 未完成历史降级: ${issues.join("; ")}`, [gf], `validate-batch${batchNum}`, "旧 gate 误导性的通过结论被标记为不可作为发布依据", "完成历史降级");
-        }
-    }
-    _info(`  已检查 ${gateFiles.length} 个旧 gate 和 package.json 历史声明`);
-}
-// ── 6. 测试污染初筛 ──
-function checkTestPollution(rootDir, hardFail, _info) {
-    const categories = { product_test: [], useful_contract_test: [], batch_construction_test: [], suspicious_test_pollution: [] };
-    const usefulContractExemptions = new Set([
-        "tests/engine/implementation_roadmap_registry.test.ts",
-    ]);
-    const testDir = path.join(rootDir, "tests");
-    function scanTestDir(dir) {
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const full = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                scanTestDir(full);
-            }
-            else if (entry.isFile() && (entry.name.endsWith(".test.ts") || entry.name.endsWith(".test.js"))) {
-                const content = safeRead(full);
-                if (!content)
-                    continue;
-                const rel = path.relative(rootDir, full);
-                const isScenarioMatrix = rel.includes("scenario_matrix");
-                const isBatchGateRelated = /batch\d/.test(content) && !rel.includes("scripts/");
-                const checksImplementedVerified = content.includes("implemented_verified");
-                const checksFileExists = /existsSync/.test(content) && /required.*file/i.test(content);
-                const checksScenarioSelfAttest = /fixture_status.*ready|scenario.*status.*PASS/.test(content);
-                const hasPlaceholderTest = /场景注册占位/.test(content) || /expect\s*\(\s*true\s*\)\s*\.\s*toBe\s*\(\s*true\s*\)/.test(content) || /registered\s+only/.test(content);
-                const hasTodoPlaceholder = /\bit\s*\.\s*todo\s*\(/.test(content) || /\bdescribe\s*\.\s*todo\s*\(/.test(content);
-                if (hasPlaceholderTest || hasTodoPlaceholder) {
-                    categories.suspicious_test_pollution.push(rel);
-                }
-                else if (isScenarioMatrix) {
-                    categories.batch_construction_test.push(rel);
-                }
-                else if (usefulContractExemptions.has(rel)) {
-                    categories.useful_contract_test.push(rel);
-                }
-                else if (isBatchGateRelated && (checksImplementedVerified || checksFileExists)) {
-                    categories.suspicious_test_pollution.push(rel);
-                }
-                else if (checksScenarioSelfAttest && !content.includes("真实") && !content.includes("real")) {
-                    categories.suspicious_test_pollution.push(rel);
-                }
-                else if (checksFileExists && !isBatchGateRelated) {
-                    categories.useful_contract_test.push(rel);
-                }
-                else {
-                    categories.product_test.push(rel);
-                }
-            }
-        }
-    }
-    scanTestDir(testDir);
-    _info(`  product_test: ${categories.product_test.length} 个`);
-    _info(`  useful_contract_test: ${categories.useful_contract_test.length} 个`);
-    _info(`  batch_construction_test: ${categories.batch_construction_test.length} 个`);
-    _info(`  suspicious_test_pollution: ${categories.suspicious_test_pollution.length} 个`);
-    for (const t of categories.suspicious_test_pollution) {
-        _info(`    [可疑] ${t}`);
-    }
-    if (categories.suspicious_test_pollution.length > 0) {
-        hardFail("SUSPICIOUS_TEST_POLLUTION", `发现 ${categories.suspicious_test_pollution.length} 个可疑测试文件: 可能只为 Batch 状态、implemented_verified、文件存在、scenario 自证而存在`, categories.suspicious_test_pollution, "测试体系", "旧 gate 把这些测试作为通过证据，但它们可能是循环自证", "删除测试污染");
-    }
-}
-// ── 8. 关键问题消费验证 (problem-17/38/57) ──
-async function checkCriticalProblemConsumption(rootDir, hardFail, _info) {
-    const taskContextPath = path.join(rootDir, "src/engine/task_context.ts");
-    const cliPath = path.join(rootDir, "src/bin/soloforge.ts");
-    // problem-17: StateFact 分区 — save() 必须调用 validateStateFactPartition，hard_fail 必须 throw
-    const stateFactPath = path.join(rootDir, "src/engine/state_fact_classifier.ts");
-    if (!fs.existsSync(stateFactPath)) {
-        hardFail("CRITICAL_PROBLEM_FILE_MISSING", "problem-17: state_fact_classifier.ts 不存在", ["src/engine/state_fact_classifier.ts"], "problem-17", "发布门禁不检查 problem-17 实现", "创建 state_fact_classifier.ts");
-    }
-    else {
-        const sfContent = safeRead(stateFactPath);
-        const tcContent = safeRead(taskContextPath);
-        if (!sfContent || !sourceContainsIdentifier(sfContent, "validateStateFactPartition")) {
-            hardFail("CRITICAL_PROBLEM_EXPORT_MISSING", "problem-17: state_fact_classifier.ts 未导出 validateStateFactPartition", ["src/engine/state_fact_classifier.ts"], "problem-17", "StateFact 分类器缺少核心导出函数", "添加 validateStateFactPartition 导出");
-        }
-        if (!tcContent || !sourceContainsIdentifier(tcContent, "validateStateFactPartition")) {
-            hardFail("CRITICAL_PROBLEM_NOT_CONSUMED", "problem-17: task_context.ts save() 未调用 validateStateFactPartition", ["src/engine/task_context.ts", "src/engine/state_fact_classifier.ts"], "problem-17", "StateFact 分区定义存在但未接入 TaskContext 保存路径", "在 task_context.ts save() 中接入 validateStateFactPartition");
-        }
-        else {
-            // 验证 hard_fail 时 throw（不是静默跳过）
-            const tcLines = tcContent.split("\n");
-            const vspLine = tcLines.findIndex(l => l.includes("validateStateFactPartition"));
-            if (vspLine === -1) {
-                hardFail("CRITICAL_PROBLEM_NOT_CONSUMED", "problem-17: task_context.ts save() 未调用 validateStateFactPartition", ["src/engine/task_context.ts"], "problem-17", "StateFact 分区定义存在但未接入 TaskContext 保存路径", "接入 validateStateFactPartition");
-            }
-            else {
-                // 检查调用后有 hard_fail throw 路径
-                const afterVsp = tcLines.slice(vspLine, vspLine + 15).join("\n");
-                if (!afterVsp.includes("throw") || !afterVsp.includes("hardFails") && !afterVsp.includes("hard_fail")) {
-                    hardFail("CRITICAL_PROBLEM_SOFT_ENFORCEMENT", "problem-17: task_context.ts 中 validateStateFactPartition 调用后缺少 hard_fail throw 路径", ["src/engine/task_context.ts"], "problem-17", "StateFact 校验结果被忽略而非阻断", "校验 hard_fail 时 throw Error");
-                }
-            }
-        }
-    }
-    // problem-38: Retention Policy — cleanup 必须调用 evaluateCleanup/checkForbiddenContent，存在 referenced evidence 保护
-    const retentionPath = path.join(rootDir, "src/engine/retention_policy.ts");
-    if (!fs.existsSync(retentionPath)) {
-        hardFail("CRITICAL_PROBLEM_FILE_MISSING", "problem-38: retention_policy.ts 不存在", ["src/engine/retention_policy.ts"], "problem-38", "发布门禁不检查 problem-38 实现", "创建 retention_policy.ts");
-    }
-    else {
-        const retContent = safeRead(retentionPath);
-        if (!retContent || !retContent.includes("evaluateCleanup") || !retContent.includes("checkForbiddenContent")) {
-            hardFail("CRITICAL_PROBLEM_EXPORT_MISSING", "problem-38: retention_policy.ts 未导出 evaluateCleanup 或 checkForbiddenContent", ["src/engine/retention_policy.ts"], "problem-38", "Retention Policy 缺少核心清理函数", "添加 evaluateCleanup 和 checkForbiddenContent 导出");
-        }
-        const tcContent = safeRead(taskContextPath);
-        const cliContent = safeRead(cliPath);
-        const tcHasCleanup = tcContent?.includes("evaluateCleanup") ?? false;
-        const cliHasCleanup = cliContent?.includes("evaluateCleanup") ?? false;
-        const cliHasCheck = cliContent?.includes("checkForbiddenContent") ?? false;
-        if (!tcHasCleanup && !cliHasCleanup) {
-            hardFail("CRITICAL_PROBLEM_NOT_CONSUMED", "problem-38: evaluateCleanup 未被 task_context.ts 或 soloforge.ts 调用", ["src/engine/task_context.ts", "src/bin/soloforge.ts", "src/engine/retention_policy.ts"], "problem-38", "Retention Policy 定义存在但无清理消费者", "将 evaluateCleanup 接入 TaskContext cleanup 或 CLI cleanup 命令");
-        }
-        // 验证 CLI cleanup 中有 referenced evidence 保护逻辑
-        if (cliContent) {
-            const cliLines = cliContent.split("\n");
-            const cleanupFn = cliLines.findIndex(l => l.match(/^(async\s+)?function\s+cmdCleanup/));
-            if (cleanupFn !== -1) {
-                // 搜索到下一个顶层函数或文件末尾
-                let cleanupEnd = cliLines.length;
-                for (let i = cleanupFn + 3; i < cliLines.length; i++) {
-                    if (cliLines[i].match(/^async function\s+\w+|^function\s+\w+/)) {
-                        cleanupEnd = i;
-                        break;
-                    }
-                }
-                const cleanupBody = cliLines.slice(cleanupFn, cleanupEnd).join("\n");
-                if (!cleanupBody.includes("referencedEvidenceIds") || !cleanupBody.includes("is_referenced")) {
-                    hardFail("CRITICAL_PROBLEM_SOFT_ENFORCEMENT", "problem-38: CLI cleanup 缺少真实 evidence 引用扫描（无 referencedEvidenceIds 或 is_referenced 逻辑）", ["src/bin/soloforge.ts"], "problem-38", "cleanup 未扫描 task context / governance report 中的 evidence 引用", "添加真实引用扫描");
-                }
-                // 验证策略异常导致非零退出
-                if (!cleanupBody.includes("process.exit(1)")) {
-                    hardFail("CRITICAL_PROBLEM_SOFT_ENFORCEMENT", "problem-38: CLI cleanup 策略异常时未非零退出", ["src/bin/soloforge.ts"], "problem-38", "策略异常被吞而非阻断", "添加 process.exit(1) 在 catch 中");
-                }
-            }
-        }
-    }
-    // problem-57: Knowledge Asset Audit — audit-template-mechanisms 必须调用 auditKnowledgeAssets 且 hard_fail/异常 process.exit(1)
-    const kaAuditPath = path.join(rootDir, "src/engine/knowledge_asset_audit.ts");
-    if (!fs.existsSync(kaAuditPath)) {
-        hardFail("CRITICAL_PROBLEM_FILE_MISSING", "problem-57: knowledge_asset_audit.ts 不存在", ["src/engine/knowledge_asset_audit.ts"], "problem-57", "发布门禁不检查 problem-57 实现", "创建 knowledge_asset_audit.ts");
-    }
-    else {
-        const kaContent = safeRead(kaAuditPath);
-        if (!kaContent || !kaContent.includes("auditKnowledgeAssets")) {
-            hardFail("CRITICAL_PROBLEM_EXPORT_MISSING", "problem-57: knowledge_asset_audit.ts 未导出 auditKnowledgeAssets", ["src/engine/knowledge_asset_audit.ts"], "problem-57", "Knowledge Asset Audit 缺少核心审计函数", "添加 auditKnowledgeAssets 导出");
-        }
-        const cliContent = safeRead(cliPath);
-        if (!cliContent?.includes("auditKnowledgeAssets")) {
-            hardFail("CRITICAL_PROBLEM_NOT_CONSUMED", "problem-57: auditKnowledgeAssets 未被 soloforge.ts CLI 消费", ["src/bin/soloforge.ts", "src/engine/knowledge_asset_audit.ts"], "problem-57", "Knowledge Asset Audit 定义存在但未接入 CLI", "将 auditKnowledgeAssets 接入 audit-template-mechanisms 命令");
-        }
-        else {
-            // 验证 hard_fail 阻断路径
-            const cliLines = cliContent.split("\n");
-            const kaCallLine = cliLines.findIndex(l => l.includes("auditKnowledgeAssets") && l.includes("await"));
-            if (kaCallLine !== -1) {
-                // 搜索到函数末尾（下一个 async function 或文件末尾）
-                let kaEnd = cliLines.length;
-                for (let i = kaCallLine + 1; i < cliLines.length; i++) {
-                    if (cliLines[i].match(/^async function\s+\w+|^function\s+\w+/)) {
-                        kaEnd = i;
-                        break;
-                    }
-                }
-                const afterKaCall = cliLines.slice(kaCallLine, kaEnd).join("\n");
-                if (!afterKaCall.includes("hard_fail_count") || !afterKaCall.includes("process.exit(1)")) {
-                    hardFail("CRITICAL_PROBLEM_SOFT_ENFORCEMENT", "problem-57: auditKnowledgeAssets 调用后 hard_fail 未阻断（缺少 process.exit(1)）", ["src/bin/soloforge.ts"], "problem-57", "知识资产审计 hard_fail 未阻断命令", "添加 hard_fail_count > 0 时 process.exit(1)");
-                }
-                // 验证异常也阻断（搜索整个函数体中的 catch 块）
-                const catchBlocks = afterKaCall.match(/catch\s*\(e[^)]*\)\s*\{[^}]+\}/g);
-                const hasKaAudit = afterKaCall.includes("auditKnowledgeAssets");
-                if (catchBlocks && hasKaAudit) {
-                    for (const cb of catchBlocks) {
-                        // 只检查紧跟 auditKnowledgeAssets 的 catch
-                        if (cb.includes("process.exit(1)"))
-                            continue;
-                        // 检查是否是 auditKnowledgeAssets 的 catch（通过位置判断）
-                    }
-                }
-                // 简化: 检查 auditKnowledgeAssets 后面的 catch 块中是否有 process.exit(1)
-                const kaCatchIdx = afterKaCall.lastIndexOf("catch");
-                if (kaCatchIdx !== -1) {
-                    const afterCatch = afterKaCall.slice(kaCatchIdx);
-                    if (!afterCatch.includes("process.exit(1)")) {
-                        hardFail("CRITICAL_PROBLEM_SOFT_ENFORCEMENT", "problem-57: auditKnowledgeAssets 异常时未阻断（catch 中缺少 process.exit(1)）", ["src/bin/soloforge.ts"], "problem-57", "知识资产审计异常被吞而非阻断", "catch 中添加 process.exit(1)");
-                    }
-                }
-            }
-        }
-    }
-    _info("  problem-17/38/57 消费验证完成");
-    // 问题六十：证据驱动与反幻觉契约 — 行为级检查
-    {
-        const evidenceGroundingPath = path.join(rootDir, "src/engine/evidence_grounding_contract.ts");
-        if (!fs.existsSync(evidenceGroundingPath)) {
-            hardFail("CRITICAL_PROBLEM_FILE_MISSING", "problem-60: evidence_grounding_contract.ts 不存在", ["src/engine/evidence_grounding_contract.ts"], "problem-60", "发布门禁不检查 problem-60 实现", "创建 evidence_grounding_contract.ts");
-        }
-        else {
-            // 行为级检查：动态导入并验证核心门禁行为
-            try {
-                const eg = await import(path.join(rootDir, "dist/engine/evidence_grounding_contract.js"));
-                const sys = eg.createEvidenceGroundingSystem();
-                // 检查 1：无证据高风险 claim 必须被 blocked
-                {
-                    const noEvClaims = [{
-                            id: "gate-test-no-ev", claim_text: "项目使用 React", category: "project_fact",
-                            evidence_ids: [], is_uncertain: false, risk_level: "high",
-                        }];
-                    const noEvResult = sys.verifier.verify(noEvClaims, "high");
-                    if (noEvResult.unsupported.length === 0) {
-                        hardFail("CRITICAL_PROBLEM_BEHAVIOR", "problem-60: 无证据高风险 claim 未被 blocked", ["src/engine/evidence_grounding_contract.ts"], "problem-60", "FactClaimVerifier 未阻断无证据声明", "验证 classify 逻辑");
-                    }
-                }
-                // 检查 2：generated_inference 单独支撑 project_fact 必须被 blocked
-                {
-                    const infEv = sys.registry.register({
-                        source_type: "generated_inference", authority: "weak", freshness: "unknown",
-                        permission: "allowed", scope: "test", description: "推理",
-                    });
-                    const infClaims = [{
-                            id: "gate-test-inference", claim_text: "项目使用 Vue", category: "tech_stack",
-                            evidence_ids: [infEv.id], is_uncertain: false, risk_level: "high",
-                        }];
-                    const infResult = sys.verifier.verify(infClaims, "high");
-                    if (infResult.unsupported.length === 0) {
-                        hardFail("CRITICAL_PROBLEM_BEHAVIOR", "problem-60: generated_inference 单独支撑 project_fact 未被 blocked", ["src/engine/evidence_grounding_contract.ts"], "problem-60", "FactClaimVerifier 未阻断推理自证", "验证 isSelfAttestation 逻辑");
-                    }
-                }
-                // 检查 3：validation_plan 冒充 validation_result 必须被 blocked
-                {
-                    const planEv = sys.registry.register({
-                        source_type: "generated_inference", authority: "weak", freshness: "unknown",
-                        permission: "allowed", scope: "test", description: "验证计划",
-                    });
-                    const planClaims = [{
-                            id: "gate-test-plan-as-result", claim_text: "验证已通过",
-                            category: "validation_result",
-                            evidence_ids: [planEv.id], is_uncertain: false, risk_level: "high",
-                        }];
-                    const planResult = sys.verifier.verify(planClaims, "high");
-                    if (planResult.unsupported.length === 0) {
-                        hardFail("CRITICAL_PROBLEM_BEHAVIOR", "problem-60: validation_plan 冒充 validation_result 未被 blocked", ["src/engine/evidence_grounding_contract.ts"], "problem-60", "FactClaimVerifier 未阻断验证计划冒充", "验证 validation_result 检查逻辑");
-                    }
-                }
-                // 检查 4：forbidden source 必须被 blocked
-                {
-                    const matrix = sys.builder.buildContext([], {
-                        target_claims: [], source_types: [], keywords: [], max_results: 10,
-                    });
-                    matrix.evidence.push({
-                        id: "ev-forbidden-test", source_type: "project_file",
-                        authority: "authoritative", freshness: "current",
-                        permission: "forbidden", scope: "sensitive",
-                        description: "敏感数据", timestamp: new Date().toISOString(),
-                    });
-                    matrix.risk_summary = { low: 0, medium: 0, high: 0, critical: 1 };
-                    const forbiddenResult = sys.gate.evaluate(matrix, "high");
-                    if (forbiddenResult.allowed) {
-                        hardFail("CRITICAL_PROBLEM_BEHAVIOR", "problem-60: forbidden source 未被 UnsupportedClaimGate 阻断", ["src/engine/evidence_grounding_contract.ts"], "problem-60", "UnsupportedClaimGate 允许 forbidden 证据通过", "验证 forbidden 检查逻辑");
-                    }
-                }
-                // 检查 5：conflict unresolved 必须被 blocked（高风险）
-                {
-                    const confMatrix = sys.builder.buildContext([], {
-                        target_claims: [], source_types: [], keywords: [], max_results: 10,
-                    });
-                    confMatrix.conflicts.push({
-                        claim_id: "claim-conflict-test",
-                        conflicting_evidence_ids: ["ev-a", "ev-b"],
-                        description: "矛盾",
-                        resolution_status: "unresolved",
-                    });
-                    confMatrix.risk_summary = { low: 0, medium: 0, high: 1, critical: 0 };
-                    const confResult = sys.gate.evaluate(confMatrix, "high");
-                    if (confResult.allowed) {
-                        hardFail("CRITICAL_PROBLEM_BEHAVIOR", "problem-60: unresolved conflict 未被 UnsupportedClaimGate 阻断", ["src/engine/evidence_grounding_contract.ts"], "problem-60", "UnsupportedClaimGate 允许未裁决冲突通过", "验证 conflict 检查逻辑");
-                    }
-                }
-                // 检查 6：classification-only 证据不得支撑 architecture 声明
-                {
-                    sys.registry.clear();
-                    const clsOnlyEv = sys.registry.register({
-                        source_type: "task_context", authority: "authoritative", freshness: "current",
-                        permission: "allowed", scope: "classification", description: "任务分类结果",
-                    });
-                    const clsOnlyClaims = [{
-                            id: "gate-test-cls-only", claim_text: "技术方案基于现有系统分析",
-                            category: "architecture",
-                            evidence_ids: [clsOnlyEv.id], is_uncertain: false, risk_level: "high",
-                        }];
-                    const clsOnlyResult = sys.verifier.verify(clsOnlyClaims, "high");
-                    if (clsOnlyResult.unsupported.length === 0) {
-                        hardFail("CRITICAL_PROBLEM_BEHAVIOR", "problem-60: classification-only 证据支撑 architecture 声明未被 blocked", ["src/engine/evidence_grounding_contract.ts"], "problem-60", "FactClaimVerifier 允许 task_context:classification 支撑项目事实声明", "验证 CATEGORY_REQUIRED_SOURCES 逻辑");
-                    }
-                }
-                // 检查 7：project_file + project_source_file 证据可以支撑 architecture 声明
-                {
-                    sys.registry.clear();
-                    const pfEv = sys.registry.register({
-                        source_type: "project_file", evidence_role: "project_source_file",
-                        authority: "authoritative", freshness: "current",
-                        permission: "allowed", scope: "src/", description: "项目源码文件",
-                    });
-                    const pfClaims = [{
-                            id: "gate-test-pf-ok", claim_text: "技术方案基于现有系统分析",
-                            category: "architecture",
-                            evidence_ids: [pfEv.id], is_uncertain: false, risk_level: "high",
-                        }];
-                    const pfResult = sys.verifier.verify(pfClaims, "high");
-                    if (pfResult.unsupported.length > 0) {
-                        hardFail("CRITICAL_PROBLEM_BEHAVIOR", "problem-60: project_source_file 证据支撑 architecture 声明被错误 blocked", ["src/engine/evidence_grounding_contract.ts"], "problem-60", "FactClaimVerifier 误阻断了有效证据", "验证 CATEGORY_REQUIRED_ROLES 逻辑");
-                    }
-                }
-                // 检查 8：template_guidance 证据不得支撑 architecture 声明
-                {
-                    sys.registry.clear();
-                    const tgEv = sys.registry.register({
-                        source_type: "knowledge_asset", evidence_role: "template_guidance",
-                        authority: "trusted", freshness: "current",
-                        permission: "allowed", scope: "knowledge", description: "默认模板",
-                    });
-                    const tgClaims = [{
-                            id: "gate-test-tg-block", claim_text: "技术方案基于现有系统分析",
-                            category: "architecture",
-                            evidence_ids: [tgEv.id], is_uncertain: false, risk_level: "high",
-                        }];
-                    const tgResult = sys.verifier.verify(tgClaims, "high");
-                    if (tgResult.unsupported.length === 0) {
-                        hardFail("CRITICAL_PROBLEM_BEHAVIOR", "problem-60: template_guidance 证据支撑 architecture 声明未被 blocked", ["src/engine/evidence_grounding_contract.ts"], "problem-60", "FactClaimVerifier 允许 template_guidance 支撑项目事实声明", "验证 CATEGORY_REQUIRED_ROLES 逻辑");
-                    }
-                }
-                // 检查 9：project_source_file 证据角色可以支撑 architecture 声明
-                {
-                    sys.registry.clear();
-                    const psfEv = sys.registry.register({
-                        source_type: "project_file", evidence_role: "project_source_file",
-                        authority: "authoritative", freshness: "current",
-                        permission: "allowed", scope: "src/", description: "项目源码文件",
-                    });
-                    const psfClaims = [{
-                            id: "gate-test-psf-ok", claim_text: "技术方案基于现有系统分析",
-                            category: "architecture",
-                            evidence_ids: [psfEv.id], is_uncertain: false, risk_level: "high",
-                        }];
-                    const psfResult = sys.verifier.verify(psfClaims, "high");
-                    if (psfResult.unsupported.length > 0) {
-                        hardFail("CRITICAL_PROBLEM_BEHAVIOR", "problem-60: project_source_file 角色支撑 architecture 声明被错误 blocked", ["src/engine/evidence_grounding_contract.ts"], "problem-60", "FactClaimVerifier 误阻断了有效 project_source_file 证据", "验证 CATEGORY_REQUIRED_ROLES 逻辑");
-                    }
-                }
-                // 检查 10：普通 code_change 不应因无 project_source_file 被 blocked（无 architecture claim 时）
-                {
-                    sys.registry.clear();
-                    const clsEv = sys.registry.register({
-                        source_type: "task_context", evidence_role: "classification",
-                        authority: "authoritative", freshness: "current",
-                        permission: "allowed", scope: "classification", description: "任务分类结果",
-                    });
-                    // 普通 code_change 只有 user_confirmation claim（无 architecture claim）
-                    const ccClaims = [{
-                            id: "gate-test-cc-ok", claim_text: "任务路由和执行范围已确认",
-                            category: "user_confirmation",
-                            evidence_ids: [clsEv.id], is_uncertain: false, risk_level: "high",
-                        }];
-                    const ccResult = sys.verifier.verify(ccClaims, "high");
-                    if (ccResult.unsupported.length > 0) {
-                        hardFail("CRITICAL_PROBLEM_BEHAVIOR", "problem-60: 普通 code_change 的 user_confirmation claim 被 classification 证据错误 blocked", ["src/engine/evidence_grounding_contract.ts"], "problem-60", "FactClaimVerifier 误阻断了不需要项目事实的普通任务", "验证 claim 语义逻辑");
-                    }
-                }
-                // 检查 11：architecture_design 无真实项目证据必须 blocked
-                {
-                    sys.registry.clear();
-                    const clsOnlyEv = sys.registry.register({
-                        source_type: "task_context", evidence_role: "classification",
-                        authority: "authoritative", freshness: "current",
-                        permission: "allowed", scope: "classification", description: "任务分类结果",
-                    });
-                    const tgOnlyEv = sys.registry.register({
-                        source_type: "knowledge_asset", evidence_role: "template_guidance",
-                        authority: "trusted", freshness: "current",
-                        permission: "allowed", scope: "knowledge", description: "默认模板",
-                    });
-                    const archClaims = [{
-                            id: "gate-test-arch-block", claim_text: "技术方案基于现有系统分析",
-                            category: "architecture",
-                            evidence_ids: [clsOnlyEv.id, tgOnlyEv.id], is_uncertain: false, risk_level: "high",
-                        }];
-                    const archResult = sys.verifier.verify(archClaims, "high");
-                    if (archResult.unsupported.length === 0) {
-                        hardFail("CRITICAL_PROBLEM_BEHAVIOR", "problem-60: architecture_design 无真实项目证据未被 blocked（classification + template_guidance 不够）", ["src/engine/evidence_grounding_contract.ts"], "problem-60", "FactClaimVerifier 允许非项目证据支撑架构声明", "验证 CATEGORY_REQUIRED_ROLES + claim 语义逻辑");
-                    }
-                }
-            }
-            catch (behaviorErr) {
-                hardFail("CRITICAL_PROBLEM_BEHAVIOR", `problem-60: 行为级检查执行失败: ${behaviorErr?.message ?? behaviorErr}`, ["src/engine/evidence_grounding_contract.ts"], "problem-60", "证据驱动机制行为检查不可执行", "修复 import 或机制代码");
-            }
-        }
-        // 静态检查：导出完整性
-        const egContent = safeRead(evidenceGroundingPath);
-        if (egContent) {
-            const requiredExports = ["createEvidenceGroundingSystem", "assessTaskRisk", "EvidenceSourceRegistry", "FactClaimVerifier", "UnsupportedClaimGate"];
-            for (const exp of requiredExports) {
-                if (!egContent.includes(exp)) {
-                    hardFail("CRITICAL_PROBLEM_EXPORT_MISSING", `problem-60: evidence_grounding_contract.ts 缺少导出: ${exp}`, ["src/engine/evidence_grounding_contract.ts"], "problem-60", "证据驱动机制缺少核心导出", `添加 ${exp} 导出`);
-                }
-            }
-        }
-        // 静态检查：InstructionContract schema 必须包含 evidence 字段
-        const instrContractPath = path.join(rootDir, "src/engine/instruction_contract.ts");
-        const instrContent = safeRead(instrContractPath);
-        if (instrContent) {
-            const evidenceFields = ["evidence_matrix", "unsupported_claim_policy", "uncertainty_policy", "conflict_resolution_policy"];
-            for (const field of evidenceFields) {
-                if (!instrContent.includes(field)) {
-                    hardFail("CRITICAL_PROBLEM_SCHEMA_INCOMPLETE", `problem-60: instruction_contract.ts schema 缺少证据字段: ${field}`, ["src/engine/instruction_contract.ts"], "problem-60", "施工指令契约缺少证据驱动字段", `添加 ${field} 字段`);
-                }
-            }
-        }
-        // 静态检查：主链路必须有 runtime 阻断（不能只是 advisory）
-        const toolsPath = path.join(rootDir, "src/adapters/claude_code/tools.ts");
-        const toolsContent = safeRead(toolsPath);
-        if (!toolsContent?.includes("evidence_grounding_contract")) {
-            hardFail("CRITICAL_PROBLEM_NOT_CONSUMED", "problem-60: tools.ts 未消费 evidence_grounding_contract", ["src/adapters/claude_code/tools.ts"], "problem-60", "证据驱动机制未接入主链路", "在 sf_expand/sf_verify/sf_deliver 中接入");
-        }
-        // sf_expand 必须有 blocked/manual_required 分支
-        if (toolsContent && !toolsContent.includes("_evGate.allowed") && !toolsContent.includes("evidence_blocked")) {
-            hardFail("CRITICAL_PROBLEM_ADVISORY_ONLY", "problem-60: sf_expand 证据检查只有 advisory，缺少 blocked 分支", ["src/adapters/claude_code/tools.ts"], "problem-60", "sf_expand 证据门禁不阻断", "添加 evidence gate blocked 分支");
-        }
-        // sf_verify: 验证计划描述行中不得包含 source_type: "validation_result"
-        if (toolsContent) {
-            // 找到 sf_verify handler 中问题六十部分
-            const verifyStart = toolsContent.indexOf("问题六十：验证结论必须经过 FactClaimVerifier");
-            const verifyEnd = toolsContent.indexOf("// 验证后核心体验评估", verifyStart);
-            if (verifyStart >= 0 && verifyEnd >= 0) {
-                const verifySection = toolsContent.substring(verifyStart, verifyEnd);
-                // 检查验证计划注册调用中是否使用了 validation_result
-                const planRegMatch = verifySection.match(/register\(\{[^}]*验证计划:[^}]*\}\)/s);
-                if (planRegMatch && planRegMatch[0].includes("source_type: \"validation_result\"")) {
-                    hardFail("CRITICAL_PROBLEM_PLAN_AS_RESULT", "problem-60: sf_verify 把验证计划注册为 validation_result", ["src/adapters/claude_code/tools.ts"], "problem-60", "验证计划冒充验证结果", "验证计划应注册为 task_context 类型");
-                }
-            }
-        }
-        // 静态检查：负向测试
-        const testPath = path.join(rootDir, "tests/engine/evidence_grounding_contract.test.ts");
-        if (!fs.existsSync(testPath)) {
-            hardFail("CRITICAL_PROBLEM_TEST_MISSING", "problem-60: 缺少负向测试文件", ["tests/engine/evidence_grounding_contract.test.ts"], "problem-60", "证据驱动机制缺少测试覆盖", "创建 evidence_grounding_contract.test.ts");
-        }
-        // 静态检查：知识规则
-        const kaRulePath = path.join(rootDir, "templates/knowledge/rules/证据驱动与反幻觉规则.md");
-        if (!fs.existsSync(kaRulePath)) {
-            hardFail("CRITICAL_PROBLEM_ASSET_MISSING", "problem-60: 缺少知识规则文件 证据驱动与反幻觉规则.md", ["templates/knowledge/rules/证据驱动与反幻觉规则.md"], "problem-60", "证据驱动知识规则缺失", "创建知识规则文件");
-        }
-        // 静态检查：workflow_template
-        const wfPath = path.join(rootDir, "src/adapters/shared/workflow_template.ts");
-        const wfContent = safeRead(wfPath);
-        if (!wfContent?.includes("wf-evidence-grounding")) {
-            hardFail("CRITICAL_PROBLEM_TEMPLATE_MISSING", "problem-60: workflow_template.ts 缺少 wf-evidence-grounding 硬规则", ["src/adapters/shared/workflow_template.ts"], "problem-60", "工作流模板未包含证据驱动规则", "添加 wf-evidence-grounding 硬规则");
-        }
-        // 静态检查：TaskContext 类型必须有证据字段
-        const typesPath = path.join(rootDir, "src/types.ts");
-        const typesContent = safeRead(typesPath);
-        if (typesContent && !typesContent.includes("evidence_matrix?:") && !typesContent.includes("evidence_gate_result?:")) {
-            hardFail("CRITICAL_PROBLEM_TASKCTX_MISSING", "problem-60: TaskContext 缺少 evidence_matrix/evidence_gate_result 字段", ["src/types.ts"], "problem-60", "TaskContext 未保存证据结果", "添加 evidence_matrix 和 evidence_gate_result 字段");
-        }
-        // 静态检查：task_context.ts 必须有 setEvidenceGroundingResult 写入方法
-        const tcPath = path.join(rootDir, "src/engine/task_context.ts");
-        const tcContent = safeRead(tcPath);
-        if (tcContent && !sourceContainsIdentifier(tcContent, "setEvidenceGroundingResult")) {
-            hardFail("CRITICAL_PROBLEM_NO_WRITEBACK", "problem-60: task_context.ts 缺少 setEvidenceGroundingResult 写入方法", ["src/engine/task_context.ts"], "problem-60", "TaskContext 只有类型字段没有写入方法", "添加 setEvidenceGroundingResult 方法");
-        }
-        // 静态检查：tools.ts 主链路必须调用 setEvidenceGroundingResult
-        if (toolsContent && !toolsContent.includes("setEvidenceGroundingResult")) {
-            hardFail("CRITICAL_PROBLEM_NO_RUNTIME_WRITEBACK", "problem-60: tools.ts 未调用 setEvidenceGroundingResult 写回 TaskContext", ["src/adapters/claude_code/tools.ts"], "problem-60", "主链路不写回证据结果到 TaskContext", "在 sf_expand/sf_verify/sf_deliver 中调用 setEvidenceGroundingResult");
-        }
-        // 静态检查：tools.ts 不得出现 registry.query({}).map() 无差别证据绑定
-        if (toolsContent) {
-            const toolsLines = toolsContent.split("\n");
-            for (let i = 0; i < toolsLines.length; i++) {
-                if (/registry\.query\(\{\}\)\.map/.test(toolsLines[i])) {
-                    hardFail("CRITICAL_PROBLEM_INDISCRIMINATE_BINDING", `problem-60: tools.ts:${i + 1} 使用 registry.query({}).map() 无差别绑定证据到所有 claim`, ["src/adapters/claude_code/tools.ts"], "problem-60", "所有 registry 证据被无差别绑定到所有 claim，不区分语义", "按 claim 语义筛选 evidence_ids");
-                }
-            }
-        }
-        // 行为检查：setEvidenceGroundingResult 写入后 load 能读回
-        try {
-            const tcModule = await import(path.join(rootDir, "dist/engine/task_context.js"));
-            const tmpStateDir = path.join(rootDir, ".soloforge", "state");
-            const fsModule = await import("node:fs");
-            if (!fsModule.existsSync(tmpStateDir)) {
-                fsModule.mkdirSync(tmpStateDir, { recursive: true });
-            }
-            const tmpMgr = new tcModule.TaskContextManager(tmpStateDir);
-            const tmpCtx = await tmpMgr.create("gate-evidence-writeback-test", "test");
-            const testMatrix = {
-                task_id: tmpCtx.task_id, claims: [], evidence: [],
-                conflicts: [], unsupported_claims: ["test-claim"],
-                risk_summary: { low: 0, medium: 0, high: 1, critical: 0 },
-                created_at: new Date().toISOString(),
-            };
-            const testGate = {
-                allowed: false, reason_zh: "测试", diagnostic_code: "SF-EVIDENCE-TEST",
-                unsupported_claims: ["test-claim"], unresolved_conflicts: [],
-                missing_evidence: [], risk_level: "high",
-                requires_user_confirmation: [],
-            };
-            await tmpMgr.setEvidenceGroundingResult(tmpCtx.task_id, {
-                evidence_matrix: testMatrix,
-                evidence_gate_result: testGate,
-                unsupported_claims: ["test-claim"],
-            });
-            const loaded = await tmpMgr.load(tmpCtx.task_id);
-            if (!loaded?.evidence_matrix || !loaded?.evidence_gate_result) {
-                hardFail("CRITICAL_PROBLEM_WRITEBACK_FAILED", "problem-60: setEvidenceGroundingResult 写入后 load 无法读回", ["src/engine/task_context.ts"], "problem-60", "TaskContext 写入方法不工作", "修复 setEvidenceGroundingResult 或 save/load");
-            }
-            if (loaded.evidence_gate_result?.allowed !== false) {
-                hardFail("CRITICAL_PROBLEM_WRITEBACK_CORRUPT", "problem-60: setEvidenceGroundingResult 写入的 gate result 数据损坏", ["src/engine/task_context.ts"], "problem-60", "写入的 allowed=false 被读回为 true", "检查序列化逻辑");
-            }
-            // 清理测试任务
-            try {
-                fsModule.rmSync(path.join(tmpStateDir, `${tmpCtx.task_id}.json`), { force: true });
-            }
-            catch { }
-        }
-        catch (wbErr) {
-            hardFail("CRITICAL_PROBLEM_WRITEBACK_ERROR", `problem-60: setEvidenceGroundingResult 行为检查失败: ${wbErr?.message ?? wbErr}`, ["src/engine/task_context.ts"], "problem-60", "TaskContext 写入方法不可用", "修复 import 或方法实现");
-        }
-    }
-    _info("  problem-60 证据驱动消费验证完成");
-}
-// ── 7. Batch 问题文档格式一致性 ──
-async function checkBatchIssueFormatConsistency(rootDir, hardFail, _info) {
-    // 复用 scripts/batch_issue_details.mjs 的共享解析逻辑，不维护独立的问题识别规则
-    const scriptPath = path.join(rootDir, "scripts", "batch_issue_details.mjs");
-    let loadBatchIssueDetails;
-    let validateCanonicalIssueLedger;
-    try {
-        const mod = await import(scriptPath);
-        loadBatchIssueDetails = mod.loadBatchIssueDetails;
-        validateCanonicalIssueLedger = mod.validateCanonicalIssueLedger;
-    }
-    catch (e) {
-        hardFail("BATCH_ISSUE_FORMAT_INCONSISTENT", `无法加载共享解析脚本: ${e.message}`, ["scripts/batch_issue_details.mjs"], "构建系统", "共享解析脚本不可用", "修复脚本");
-        return;
-    }
-    if (!loadBatchIssueDetails || !validateCanonicalIssueLedger) {
-        hardFail("BATCH_ISSUE_FORMAT_INCONSISTENT", "共享解析脚本缺少 Batch 加载或 canonical ledger 校验导出", ["scripts/batch_issue_details.mjs"], "构建系统", "共享解析脚本导出不正确", "修复脚本");
-        return;
-    }
-    const expectedCounts = { 1: 19, 2: 12, 3: 9, 4: 14, 5: 6, 6: 5, 7: 2, 8: 5, 9: 1 };
-    const parsedBatches = [];
-    const requiredPerProblemSections = [
-        "问题背景", "用户反馈 / 触发场景", "根因分析", "解决方案", "方案细节",
-        "硬规则", "非目标", "影响范围", "落地文件", "验收标准", "回归风险",
-        "与其他问题的关联", "发布门禁要求",
-    ];
-    for (let batch = 1; batch <= 9; batch++) {
-        const details = loadBatchIssueDetails(batch, rootDir);
-        parsedBatches.push(details);
-        if (!details.loaded) {
-            hardFail("BATCH_ISSUE_FORMAT_INCONSISTENT", `Batch${batch} 问题集未加载: ${details.error}`, [`docs/SoloForge-Batch${batch}问题集.md`], `Batch${batch}`, "旧 gate 只检查文档存在，不验证是否可解析", "第 3 步统一格式");
-            continue;
-        }
-        // 检查问题数量（问题X 已被 loadBatchIssueDetails 过滤）
-        const expected = expectedCounts[batch];
-        if (details.issue_count !== expected) {
-            hardFail("BATCH_ISSUE_COUNT_MISMATCH", `Batch${batch} 实际问题数=${details.issue_count}，期望=${expected}`, [`docs/SoloForge-Batch${batch}问题集.md`], `Batch${batch}`, "旧 gate 不检查问题数量一致性", "第 3 步统一格式");
-        }
-        // 检查方案细节表和落点表
-        const content = details.markdown;
-        if (!/Batch\s+\d+\s+全问题方案细节表/.test(content)) {
-            hardFail("BATCH_ISSUE_FORMAT_INCONSISTENT", `Batch${batch} 缺少全问题方案细节表`, [`docs/SoloForge-Batch${batch}问题集.md`], `Batch${batch}`, "旧 gate 不检查文档结构一致性", "第 3 步统一格式");
-        }
-        if (!/Batch\s+\d+\s+全问题(细节)?落点表/.test(content)) {
-            hardFail("BATCH_ISSUE_FORMAT_INCONSISTENT", `Batch${batch} 缺少全问题落点表`, [`docs/SoloForge-Batch${batch}问题集.md`], `Batch${batch}`, "旧 gate 不检查文档结构一致性", "第 3 步统一格式");
-        }
-        if (!/Batch\s+\d+\s+全问题真实性落点表/.test(content)) {
-            hardFail("BATCH_ISSUE_FORMAT_INCONSISTENT", `Batch${batch} 缺少全问题真实性落点表`, [`docs/SoloForge-Batch${batch}问题集.md`], `Batch${batch}`, "旧 gate 不检查文档结构一致性", "第 3 步统一格式");
-        }
-        // 基于 loadBatchIssueDetails 结果检查必备章节
-        for (const issue of details.issues) {
-            const sectionNames = (issue.sections || []).map((s) => s.heading);
-            const missing = requiredPerProblemSections.filter(s => !sectionNames.some(sn => sn.includes(s)));
-            if (missing.length > 0) {
-                hardFail("BATCH_ISSUE_FORMAT_INCONSISTENT", `Batch${batch} ${issue.issue_label} 缺少必备章节: ${missing.join(", ")}（其他 Batch 的问题均有这些章节）`, [`docs/SoloForge-Batch${batch}问题集.md`], `Batch${batch}/${issue.issue_label}`, "旧 gate 只检查文档存在和行数，不检查问题内部结构完整性", "第 3 步统一格式");
-            }
-            // 检查章节顺序
-            const expectedOrder = [
-                "问题背景", "用户反馈 / 触发场景", "根因分析", "解决方案", "方案细节",
-                "硬规则", "非目标", "影响范围", "落地文件", "验收标准", "回归风险",
-                "与其他问题的关联", "发布门禁要求",
-            ];
-            if (sectionNames.length >= expectedOrder.length) {
-                const orderOk = expectedOrder.length === sectionNames.length
-                    && expectedOrder.every((v, i) => sectionNames[i] === v);
-                if (!orderOk) {
-                    hardFail("BATCH_ISSUE_FORMAT_INCONSISTENT", `Batch${batch} ${issue.issue_label} 章节顺序不符合模板要求: 实际 ${sectionNames.slice(0, 5).join(", ")}...`, [`docs/SoloForge-Batch${batch}问题集.md`], `Batch${batch}/${issue.issue_label}`, "旧 gate 只检查章节存在，不检查章节顺序", "第 3 步统一格式");
-                }
-            }
-        }
-        _info(`  Batch${batch}: 已检查 (${details.issue_count} 个问题)`);
-    }
-    try {
-        const roadmapPath = path.join(rootDir, "dist", "engine", "implementation_roadmap_registry.js");
-        const roadmap = await import(roadmapPath);
-        const roadmapProblems = roadmap.listAllProblems();
-        const ledgerFindings = validateCanonicalIssueLedger(parsedBatches, roadmapProblems, 73);
-        for (const finding of ledgerFindings) {
-            hardFail("CANONICAL_ISSUE_LEDGER_INCONSISTENT", finding.message, ["scripts/batch_issue_details.mjs", "src/engine/implementation_roadmap_registry.ts"], finding.issue_label ?? finding.problem_id ?? "canonical-ledger", "旧 gate 只校验单份文档格式与数量，不校验 Batch 文档和 roadmap 的唯一身份映射", "修正 canonical issue ID、文档归属或 roadmap 登记");
-        }
-        const roadmapFindings = roadmap.validateImplementationRoadmap()
-            .filter((finding) => finding.severity === "hard_fail");
-        for (const finding of roadmapFindings) {
-            hardFail("CANONICAL_ISSUE_LEDGER_INCONSISTENT", finding.message, ["src/engine/implementation_roadmap_registry.ts"], finding.subject_id ?? "roadmap", "旧 gate 不执行 roadmap 内部双向引用校验", "修正 ProblemEntry 与 ImplementationBatch 的双向归属");
-        }
-        if (ledgerFindings.length === 0 && roadmapFindings.length === 0) {
-            _info("  canonical ledger: 问题文档与 roadmap 的 73 个问题身份、归属一致");
-        }
-    }
-    catch (e) {
-        hardFail("CANONICAL_ISSUE_LEDGER_INCONSISTENT", `无法执行 canonical 问题账本对账: ${e.message}`, ["scripts/batch_issue_details.mjs", "src/engine/implementation_roadmap_registry.ts"], "canonical-ledger", "旧 gate 不加载 roadmap 执行文档双向对账", "先完成 build 并修复账本校验入口");
-    }
-    _info("  说明: 本检查不修改文档；格式或 canonical 身份不一致会阻断发布。");
-}
-// ── 机制身份一致性 ──
-async function checkMechanismIdentityConsistency(rootDir, hardFail, _info) {
-    // 加载 DL registry
-    const dlPath = path.join(rootDir, "dist/engine/dual_layer_mechanism_registry.js");
-    if (!fs.existsSync(dlPath)) {
-        hardFail("MECHANISM_IDENTITY", "dual_layer_mechanism_registry.js 未编译", ["dist/engine/"], "机制身份一致性", "旧 gate 不检查机制身份一致性", "npm run build");
-        return;
-    }
-    let dlModule;
-    try {
-        dlModule = await import(dlPath);
-    }
-    catch (e) {
-        hardFail("MECHANISM_IDENTITY", `无法加载 dual_layer_mechanism_registry: ${e.message}`, ["dist/engine/"], "机制身份一致性", "旧 gate 不检查机制身份一致性", "修复编译错误");
-        return;
-    }
-    const canonicalIds = dlModule.getAllCanonicalMechanismIds();
-    const resolveId = dlModule.resolveMechanismId;
-    const aliases = dlModule.MECHANISM_ALIASES;
-    // 加载 MC registry
-    const mcPath = path.join(rootDir, "dist/engine/mechanism_contract_registry.js");
-    if (!fs.existsSync(mcPath)) {
-        hardFail("MECHANISM_IDENTITY", "mechanism_contract_registry.js 未编译", ["dist/engine/"], "机制身份一致性", "旧 gate 不检查机制身份一致性", "npm run build");
-        return;
-    }
-    let mcModule;
-    try {
-        mcModule = await import(mcPath);
-    }
-    catch (e) {
-        hardFail("MECHANISM_IDENTITY", `无法加载 mechanism_contract_registry: ${e.message}`, ["dist/engine/"], "机制身份一致性", "旧 gate 不检查机制身份一致性", "修复编译错误");
-        return;
-    }
-    const mcContracts = mcModule.listMechanismContracts();
-    // 检查 MC 中 active/enforced 的机制必须能解析到 DL canonical ID
-    for (const c of mcContracts) {
-        if (c.status === "deprecated")
-            continue;
-        const resolved = resolveId(c.id);
-        if (!canonicalIds.has(resolved)) {
-            hardFail("MECHANISM_IDENTITY", `mechanism_contract_registry 中 ${c.id} (status=${c.status}) 无法解析到 dual_layer_mechanism_registry 的正式机制 ID (resolved=${resolved})`, ["src/engine/mechanism_contract_registry.ts", "src/engine/dual_layer_mechanism_registry.ts"], c.id, "旧 gate 不检查 MC 与 DL 的机制身份一致性", `在 dual_layer_mechanism_registry.ts 中添加 ${resolved} 或建立 alias 映射`);
-        }
-    }
-    // 检查 DL 中的机制必须能解析到 MC 中（canonical 或 deprecated alias）
-    const mcIds = new Set(mcContracts.map((c) => c.id));
-    for (const id of canonicalIds) {
-        if (!mcIds.has(id)) {
-            hardFail("MECHANISM_IDENTITY", `dual_layer_mechanism_registry 中 ${id} 在 mechanism_contract_registry 中不存在`, ["src/engine/dual_layer_mechanism_registry.ts", "src/engine/mechanism_contract_registry.ts"], id, "旧 gate 不检查 DL 与 MC 的双向一致性", `在 mechanism_contract_registry.ts 中添加 ${id}`);
-        }
-    }
-    // 检查 templates/knowledge frontmatter owner_mechanism_id 可解析
-    const knowledgeDir = path.join(rootDir, "templates/knowledge");
-    if (fs.existsSync(knowledgeDir)) {
-        const knowledgeFiles = findFilesRecursive(knowledgeDir, ".md");
-        for (const f of knowledgeFiles) {
-            const content = safeRead(f);
-            if (!content)
-                continue;
-            const match = content.match(/^owner_mechanism_id:\s*(.+)$/m);
-            if (match) {
-                const ownerId = match[1].trim();
-                const resolved = resolveId(ownerId);
-                if (!canonicalIds.has(resolved)) {
-                    hardFail("MECHANISM_IDENTITY", `模板 ${path.relative(rootDir, f)} 的 owner_mechanism_id="${ownerId}" 无法解析到正式机制 ID (resolved=${resolved})`, [path.relative(rootDir, f)], ownerId, "旧 gate 不检查知识模板的 owner_mechanism_id 可解析性", `将 owner_mechanism_id 改为正式机制 ID 或建立 alias 映射`);
-                }
-            }
-        }
-    }
-    // 检查 consumable_asset_registry owner_mechanism_id 可解析
-    const carPath = path.join(rootDir, "dist/engine/consumable_asset_registry.js");
-    if (fs.existsSync(carPath)) {
-        try {
-            const carModule = await import(carPath);
-            const assets = carModule.listBuiltinConsumableAssets();
-            for (const a of assets) {
-                if (!a.owner_mechanism_id)
-                    continue;
-                const resolved = resolveId(a.owner_mechanism_id);
-                if (!canonicalIds.has(resolved)) {
-                    hardFail("MECHANISM_IDENTITY", `consumable_asset_registry 中 ${a.id} 的 owner_mechanism_id="${a.owner_mechanism_id}" 无法解析到正式机制 ID`, ["src/engine/consumable_asset_registry.ts"], a.owner_mechanism_id, "旧 gate 不检查 consumable_asset 的 owner_mechanism_id 可解析性", `将 owner_mechanism_id 改为正式机制 ID 或建立 alias 映射`);
-                }
-            }
-        }
-        catch { /* 模块加载失败，跳过 */ }
-    }
-    // 检查 workflow_contract_registry required_mechanisms/advisory_mechanisms 可解析
-    const wcPath = path.join(rootDir, "dist/engine/workflow_contract_registry.js");
-    if (fs.existsSync(wcPath)) {
-        try {
-            const wcModule = await import(wcPath);
-            const contracts = wcModule.listWorkflowContracts();
-            for (const c of contracts) {
-                for (const mId of [...c.required_mechanisms, ...c.advisory_mechanisms]) {
-                    const resolved = resolveId(mId);
-                    if (!canonicalIds.has(resolved)) {
-                        hardFail("MECHANISM_IDENTITY", `workflow_contract_registry 中 ${c.id} 引用机制 "${mId}" 无法解析到正式机制 ID (resolved=${resolved})`, ["src/engine/workflow_contract_registry.ts"], mId, "旧 gate 不检查 workflow required_mechanisms 的可解析性", `将 ${mId} 改为正式机制 ID 或建立 alias 映射`);
-                    }
-                }
-            }
-        }
-        catch { /* 模块加载失败，跳过 */ }
-    }
-    // 检查 asset_manifest owner_mechanism_id 可解析
-    const amSrcPath = path.join(rootDir, "src/engine/asset_manifest.ts");
-    if (fs.existsSync(amSrcPath)) {
-        const amContent = safeRead(amSrcPath);
-        if (amContent) {
-            const ownerMatches = amContent.matchAll(/owner_mechanism_id:\s*"([^"]+)"/g);
-            for (const m of ownerMatches) {
-                const ownerId = m[1];
-                const resolved = resolveId(ownerId);
-                if (!canonicalIds.has(resolved)) {
-                    hardFail("MECHANISM_IDENTITY", `asset_manifest.ts 中 owner_mechanism_id="${ownerId}" 无法解析到正式机制 ID`, ["src/engine/asset_manifest.ts"], ownerId, "旧 gate 不检查 asset_manifest 的 owner_mechanism_id 可解析性", `将 owner_mechanism_id 改为正式机制 ID 或建立 alias 映射`);
-                }
-            }
-        }
-    }
-}
-function findFilesRecursive(dir, ext) {
-    const results = [];
-    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-        const full = path.join(dir, entry.name);
-        if (entry.isDirectory())
-            results.push(...findFilesRecursive(full, ext));
-        else if (entry.name.endsWith(ext))
-            results.push(full);
-    }
-    return results;
-}
-// ── Phase 10: P0/P1 知识资产 schema 完整性 ──
-async function checkKnowledgeAssetSchema(rootDir, hardFail, _info) {
-    const matter = (await import("gray-matter")).default;
-    const { validateKnowledgeAssetFrontmatter } = await import("./knowledge_asset_schema.js");
-    const knowledgeDir = path.join(rootDir, "templates", "knowledge");
-    if (!fs.existsSync(knowledgeDir))
-        return;
-    const mdFiles = findFilesRecursive(knowledgeDir, ".md");
-    for (const filePath of mdFiles) {
-        const raw = fs.readFileSync(filePath, "utf-8");
-        const { data: frontmatter } = matter(raw);
-        if (!frontmatter || Object.keys(frontmatter).length === 0)
-            continue;
-        if (!frontmatter.asset_kind)
-            continue;
-        const findings = validateKnowledgeAssetFrontmatter(frontmatter, filePath);
-        for (const f of findings) {
-            if (f.severity === "hard_fail") {
-                hardFail(`KA_SCHEMA_${f.kind}`, f.message_zh, [filePath], f.asset_id, "旧 validate-release 不独立校验知识资产 schema", "补齐缺失的 frontmatter 字段");
-            }
-        }
-    }
-}
-// ── Phase 11: engine console 直写检查 ──
-function checkEngineConsoleLog(rootDir, hardFail) {
-    // 扫描全 src/ 目录（不仅 engine）
-    const srcDir = path.join(rootDir, "src");
-    if (!fs.existsSync(srcDir))
-        return;
-    const files = findFilesRecursive(srcDir, ".ts");
-    for (const file of files) {
-        const content = fs.readFileSync(file, "utf-8");
-        const lines = content.split("\n");
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            if (/^\s*\/\//.test(line))
-                continue;
-            if (/^\s*\*|^\s*\/\*/.test(line))
-                continue;
-            if (/"console\.log"|`console\.log`|'console\.log'|console\\.log/.test(line))
-                continue;
-            // 日志模块内部 stdout/stderr 封装允许 console.log / console.error
-            if (/logger\.ts$/.test(file) && /^\s*console\.(log|error)\(/.test(line))
-                continue;
-            const directConsole = line.match(/console\.(log|warn|error|debug)\s*\(/);
-            if (directConsole) {
-                const rel = path.relative(rootDir, file);
-                hardFail("ENGINE_DIRECT_CONSOLE", `${rel}:${i + 1} 使用 console.${directConsole[1]}（应使用 logger 模块）`, [rel], "发布门禁 console 检查", "旧 gate 不检查 src/ 全目录 console 直写", "替换为 logger 模块调用");
-            }
-        }
-    }
-}
-// ── Phase 12: 中文注释检查 ──
-function checkChineseComments(rootDir, hardFail) {
-    const srcDir = path.join(rootDir, "src");
-    if (!fs.existsSync(srcDir))
-        return;
-    const tsFiles = findFilesRecursive(srcDir, ".ts");
-    for (const file of tsFiles) {
-        const content = fs.readFileSync(file, "utf-8");
-        const lines = content.split("\n");
-        for (let i = 0; i < lines.length; i++) {
-            const line = lines[i];
-            if (!/^\s*\/\//.test(line))
-                continue;
-            if (/[一-龥]/.test(line))
-                continue;
-            // 跳过装饰分隔线
-            if (/^\s*\/\/\s*[─═\-~=*#]+\s*$/.test(line))
-                continue;
-            // 跳过工具指令
-            if (/@ts-|eslint|TODO|FIXME|NOTE|prettier|istanbul|c8/.test(line))
-                continue;
-            // 跳过机制 ID 标签
-            if (/\/\/\s*──\s*\d+\./.test(line))
-                continue;
-            if (/\/\/\s*mc-[a-z]/.test(line))
-                continue;
-            // 跳过纯代码标识符
-            if (/^\s*\/\/\s*[a-z][a-z0-9_.\/-]+\s*$/.test(line))
-                continue;
-            // 跳过大小标注
-            if (/^\s*\/\/\s*\d+\s*(MB|KB|GB|ms|min|分钟|秒)/.test(line))
-                continue;
-            // 跳过技术术语注释
-            if (/^\s*\/\/\s*[a-z_]+\.[a-z_]+/.test(line))
-                continue;
-            // 检查连续 4+ 字母
-            if (/[a-zA-Z]{4,}/.test(line)) {
-                const rel = path.relative(rootDir, file);
-                hardFail("ENGLISH_COMMENT", `${rel}:${i + 1}: ${line.trim()}（应使用中文注释）`, [rel], "中文注释检查", "旧 gate 不检查中文注释", "将英文注释改为中文");
-            }
-        }
-    }
-}
-// ── 13. 第五批文档↔roadmap↔scenario 一致性 ──
-async function checkLastBatchConsistency(rootDir, hardFail, _info) {
-    // 动态导入避免循环依赖
-    const roadmapPath = path.join(rootDir, "dist", "engine", "implementation_roadmap_registry.js");
-    const scenarioPath = path.join(rootDir, "dist", "engine", "release_gate_scenario_registry.js");
-    let listAllProblems;
-    let listBatches;
-    let RELEASE_GATE_SCENARIOS;
-    let runAllReleaseGateScenarios;
-    try {
-        const roadmap = await import(roadmapPath);
-        listAllProblems = roadmap.listAllProblems;
-        listBatches = roadmap.listBatches;
-    }
-    catch {
-        hardFail("LAST_BATCH_CONSISTENCY", "无法导入 implementation_roadmap_registry", ["src/engine/implementation_roadmap_registry.ts"], "末批一致性", "旧 gate 不检查 roadmap↔scenario 一致性", "先 build");
-        return;
-    }
-    try {
-        const scenario = await import(scenarioPath);
-        RELEASE_GATE_SCENARIOS = scenario.RELEASE_GATE_SCENARIOS;
-        runAllReleaseGateScenarios = scenario.runAllReleaseGateScenarios;
-    }
-    catch {
-        hardFail("LAST_BATCH_CONSISTENCY", "无法导入 release_gate_scenario_registry", ["src/engine/release_gate_scenario_registry.ts"], "末批一致性", "旧 gate 不检查 roadmap↔scenario 一致性", "先 build");
-        return;
-    }
-    // 1. 末批必须存在且包含 problem-55 到 problem-60
-    const batches = listBatches();
-    const lastBatch = batches.find((b) => b.batch_id === "batch-5");
-    if (!lastBatch) {
-        hardFail("LAST_BATCH_CONSISTENCY", "implementation_roadmap_registry 缺少 batch-5", ["src/engine/implementation_roadmap_registry.ts"], "末批一致性", "旧 gate 不检查末批是否存在于 roadmap", "新增 batch-5 并登记 problem-55 到 problem-60");
-        return;
-    }
-    const expectedLastProblems = ["problem-55", "problem-56", "problem-57", "problem-58", "problem-59", "problem-60"];
-    const missing = expectedLastProblems.filter((pid) => !lastBatch.included_problem_ids.includes(pid));
-    if (missing.length > 0) {
-        hardFail("LAST_BATCH_CONSISTENCY", `batch-5 缺少问题: ${missing.join(", ")}`, ["src/engine/implementation_roadmap_registry.ts"], "末批一致性", "旧 gate 不检查末批问题归属完整性", `将 ${missing.join(", ")} 加入 batch-5`);
-    }
-    // 2. problem-58 和 problem-60 不得在 batch-4
-    const prevBatch = batches.find((b) => b.batch_id === "batch-4");
-    if (prevBatch) {
-        const misattrib = ["problem-58", "problem-60"].filter((pid) => prevBatch.included_problem_ids.includes(pid));
-        if (misattrib.length > 0) {
-            hardFail("LAST_BATCH_CONSISTENCY", `problem-58/60 错误归属到 batch-4: ${misattrib.join(", ")}`, ["src/engine/implementation_roadmap_registry.ts"], "末批一致性", "旧 gate 不检查问题是否被错误归入其他批次", "将 problem-58/60 从 batch-4 迁到 batch-5");
-        }
-    }
-    // 3. 场景矩阵必须覆盖问题五十五到问题六十
-    const scenarios = RELEASE_GATE_SCENARIOS;
-    const allCoveredIssues = scenarios.flatMap((s) => s.covered_issues);
-    const expectedIssueLabels = ["问题五十五", "问题五十六", "问题五十七", "问题五十八", "问题五十九", "问题六十"];
-    const uncovered = expectedIssueLabels.filter((label) => !allCoveredIssues.includes(label));
-    if (uncovered.length > 0) {
-        hardFail("LAST_BATCH_CONSISTENCY", `场景矩阵未覆盖: ${uncovered.join(", ")}`, ["src/engine/release_gate_scenario_registry.ts"], "末批一致性", "旧 gate 不检查场景矩阵是否覆盖所有末批问题", `为 ${uncovered.join(", ")} 新增场景`);
-    }
-    // 4. 场景矩阵必须全部通过
-    const results = runAllReleaseGateScenarios();
-    const failedScenarios = results.filter((r) => !r.passed);
-    if (failedScenarios.length > 0) {
-        hardFail("LAST_BATCH_CONSISTENCY", `场景矩阵未全部通过: ${failedScenarios.map((r) => `${r.scenario_id}: ${r.failures.join("; ")}`).join(", ")}`, ["src/engine/release_gate_scenario_registry.ts"], "末批一致性", "旧 gate 不运行场景矩阵验证", "修复失败场景");
-    }
-    _info("  第五批一致性校验通过");
-}
-// ── 14. 依赖漏洞扫描 ──
-function checkDependencyAudit(rootDir, hardFail, _info) {
-    const reportPath = path.join(rootDir, ".soloforge", "advisory-report.json");
-    if (!fs.existsSync(reportPath)) {
-        hardFail("DEPENDENCY_AUDIT", "未找到依赖漏洞扫描报告 (.soloforge/advisory-report.json)", ["package.json"], "依赖健康", "旧 gate 不检查依赖漏洞", "运行 npm run audit-deps");
-        return;
-    }
-    try {
-        const report = JSON.parse(fs.readFileSync(reportPath, "utf-8"));
-        if (!report.timestamp) {
-            hardFail("DEPENDENCY_AUDIT", "漏洞扫描报告缺少时间戳", ["package.json"], "依赖健康", "旧 gate 不验证报告完整性", "重新运行 npm run audit-deps");
-            return;
-        }
-        // 报告过期检查: 超过 24 小时视为过期
-        const reportAge = Date.now() - new Date(report.timestamp).getTime();
-        const maxAge = 24 * 60 * 60 * 1000;
-        if (reportAge > maxAge) {
-            hardFail("DEPENDENCY_AUDIT", `漏洞扫描报告已过期 (生成于 ${report.timestamp})`, ["package.json"], "依赖健康", "旧 gate 不检查报告时效", "重新运行 npm run audit-deps");
-            return;
-        }
-        const blocked = report.blocked || [];
-        if (blocked.length > 0) {
-            const details = blocked.map((b) => `[${b.severity}] ${b.package}: ${b.title}`).join("; ");
-            hardFail("DEPENDENCY_AUDIT", `发现 ${blocked.length} 个阻断级漏洞: ${details}`, ["package.json"], "依赖健康", "旧 gate 不扫描依赖漏洞", "npm audit fix 或升级依赖");
-            return;
-        }
-        const total = report.vulnerability_summary?.total || 0;
-        _info(`  依赖漏洞扫描通过: ${total} 个已知漏洞（无阻断级）`);
-    }
-    catch {
-        hardFail("DEPENDENCY_AUDIT", "漏洞扫描报告格式无效", ["package.json"], "依赖健康", "旧 gate 不验证报告格式", "删除 .soloforge/advisory-report.json 并重新运行 npm run audit-deps");
-    }
-}
-// ── 16. 工作流导航契约行为验证（问题六十五） ──
-async function checkWorkflowNavigationBehavior(rootDir, hardFail, _info) {
-    // 1. 编译产物存在性
-    const navPath = path.join(rootDir, "dist", "engine", "next_action_planner.js");
-    if (!fs.existsSync(navPath)) {
-        hardFail("NAVIGATION_MODULE_MISSING", "problem-65: next_action_planner.js 未编译到 dist/", ["src/engine/next_action_planner.ts"], "problem-65", "发布门禁不检查问题-65 导航机制是否存在", "实现 next_action_planner 并编译");
-        return;
-    }
-    // 2. 核心导出存在性
-    let nav;
-    try {
-        nav = await import(navPath);
-    }
-    catch (e) {
-        hardFail("NAVIGATION_IMPORT_ERROR", `problem-65: next_action_planner 导入失败: ${e.message}`, ["src/engine/next_action_planner.ts"], "problem-65", "导航模块存在但不可导入", "修复导入错误");
-        return;
-    }
-    if (typeof nav.planNextAction !== "function") {
-        hardFail("NAVIGATION_EXPORT_MISSING", "problem-65: next_action_planner 未导出 planNextAction 函数", ["src/engine/next_action_planner.ts"], "problem-65", "导航模块缺少核心导出", "添加 planNextAction 导出");
-    }
-    if (typeof nav.computeDisallowedActions !== "function") {
-        hardFail("NAVIGATION_DISALLOWED_MISSING", "problem-65: next_action_planner 未导出 computeDisallowedActions 函数", ["src/engine/next_action_planner.ts"], "problem-65", "禁止动作规则计算函数缺失", "添加 computeDisallowedActions 导出");
-    }
-    const repairPath = path.join(rootDir, "dist", "engine", "config_auto_repair.js");
-    if (!fs.existsSync(repairPath)) {
-        hardFail("NAVIGATION_CONFIG_REPAIR_MODULE_MISSING", "problem-65: config_auto_repair.js 未编译到 dist/，机械配置问题无法自动修复", ["src/engine/config_auto_repair.ts"], "problem-65", "导航只提示配置待确认，不检查自动修复能力是否存在", "实现 config_auto_repair 并接入导航");
-    }
-    else {
-        try {
-            const repairMod = await import(repairPath);
-            if (typeof repairMod.analyzeConfigRepair !== "function" || typeof repairMod.repairProjectConfig !== "function") {
-                hardFail("NAVIGATION_CONFIG_REPAIR_EXPORT_MISSING", "problem-65: config_auto_repair 必须导出 analyzeConfigRepair 和 repairProjectConfig", ["src/engine/config_auto_repair.ts"], "problem-65", "自动修复模块存在但主链路不可消费", "补齐自动修复导出函数");
-            }
-        }
-        catch (e) {
-            hardFail("NAVIGATION_CONFIG_REPAIR_IMPORT_ERROR", `problem-65: config_auto_repair 导入失败: ${e.message}`, ["src/engine/config_auto_repair.ts"], "problem-65", "自动修复模块存在但不可导入", "修复 config_auto_repair 导入错误");
-        }
-    }
-    // 3. 行为验证: 未初始化项目应返回 uninitialized
-    const tmpDir = path.join(rootDir, ".soloforge-gate-nav-test-" + Date.now());
-    try {
-        fs.mkdirSync(tmpDir, { recursive: true });
-        const plan = await nav.planNextAction(tmpDir);
-        if (plan.project_stage !== "uninitialized") {
-            hardFail("NAVIGATION_BEHAVIOR_UNINIT", `problem-65: 未初始化项目的阶段应为 uninitialized，实际为 ${plan.project_stage}`, ["src/engine/project_stage_detector.ts"], "problem-65", "导航未正确检测未初始化项目", "修复 detectProjectStage 逻辑");
-        }
-        if (!plan.work_package || plan.work_package.action !== "sf_init") {
-            hardFail("NAVIGATION_BEHAVIOR_INIT_WP", `problem-65: 未初始化项目的工作包应为 sf_init，实际为 ${plan.work_package?.action ?? "null"}`, ["src/engine/next_action_planner.ts"], "problem-65", "导航工作包未正确推荐初始化", "修复 computeWorkPackage 逻辑");
-        }
-        if (!plan.confirmation_decisions) {
-            hardFail("NAVIGATION_CONFIRMATION_TIER_MISSING", "problem-65: 导航计划缺少 confirmation_decisions 分级结构", ["src/engine/next_action_planner.ts", "src/engine/workflow_navigation_contract.ts"], "problem-65", "旧导航只输出笼统确认提示，用户不知道哪些必须确认", "补充 must_confirm/should_confirm/auto_resolvable 分级");
-        }
-        else {
-            const decisions = plan.confirmation_decisions;
-            if (!Array.isArray(decisions.must_confirm) || !Array.isArray(decisions.should_confirm) || !Array.isArray(decisions.auto_resolvable)) {
-                hardFail("NAVIGATION_CONFIRMATION_TIER_INVALID", "problem-65: confirmation_decisions 必须同时包含 must_confirm / should_confirm / auto_resolvable 数组", ["src/engine/workflow_navigation_contract.ts"], "problem-65", "确认项没有结构化分级", "修复 ConfirmationDecisionSummary 类型和 planNextAction 输出");
-            }
-            if ((decisions.must_confirm?.length ?? 0) !== 0) {
-                hardFail("NAVIGATION_GREENFIELD_FALSE_MUST_CONFIRM", "problem-65: 从 0 开发的未初始化项目不得要求确认既有项目事实", ["src/engine/next_action_planner.ts"], "problem-65", "空项目确认口径错误，把基线确认当成既有事实确认", "将新项目基线归类为 should_confirm，不阻塞初始化和只读规划");
-            }
-            const greenfieldHint = JSON.stringify(decisions.should_confirm ?? []);
-            if (!greenfieldHint.includes("从 0 开发时没有既有项目事实可确认")) {
-                hardFail("NAVIGATION_GREENFIELD_CONFIRMATION_EXPLANATION_MISSING", "problem-65: 新项目确认提示必须说明没有既有项目事实，只确认目标、边界、技术选择和默认口径", ["src/engine/next_action_planner.ts"], "problem-65", "用户不知道空项目如何确认", "补充新项目基线确认说明");
-            }
-        }
-    }
-    catch (e) {
-        hardFail("NAVIGATION_BEHAVIOR_ERROR", `problem-65: 行为级检查执行失败: ${e.message}`, ["src/engine/next_action_planner.ts"], "problem-65", "导航机制行为检查不可执行", "修复导航机制代码");
-    }
-    finally {
-        try {
-            fs.rmSync(tmpDir, { recursive: true });
-        }
-        catch { }
-    }
-    // 3.1 行为验证: 机械配置问题必须归类为 auto_resolvable，不得要求用户确认业务口径
-    const repairTmpDir = path.join(rootDir, ".soloforge-gate-config-repair-" + Date.now());
-    try {
-        const sfDir = path.join(repairTmpDir, ".soloforge");
-        fs.mkdirSync(sfDir, { recursive: true });
-        fs.writeFileSync(path.join(sfDir, "config.yaml"), [
-            "schema_version: 1",
-            "name: demo-saas",
-            "tech_stack:",
-            "  backend:",
-            "    lang: java",
-            "    framework: spring-boot",
-            "    version: 3",
-            "  frontend:",
-            "    lang: typescript",
-            "    framework: react",
-            "    version: 18",
-            "product_profile: saas",
-            "repos: []",
-            "build_commands:",
-            "  backend:",
-            "    build: mvn -q -DskipTests package",
-            "    test: mvn test",
-            "    full: mvn verify",
-            "  frontend:",
-            "    build: npm run build",
-            "    test: npm test",
-            "    full: npm run build && npm test",
-            "scope:",
-            "  backend: demo-saas-backend",
-            "  frontend: demo-saas-frontend",
-        ].join("\n"), "utf-8");
-        fs.writeFileSync(path.join(sfDir, "config.evidence.json"), JSON.stringify({
-            schema_version: 2,
-            generated_at: "2026-01-01T00:00:00.000Z",
-            fields: {
-                name: { value: "old-name", confidence: "high", confidence_source: "confirmed", evidence: ["old"] },
-            },
-            entries: [],
-        }, null, 2), "utf-8");
-        const repairPlan = await nav.planNextAction(repairTmpDir);
-        const decisions = repairPlan.confirmation_decisions;
-        const autoItems = decisions?.auto_resolvable ?? [];
-        const hasConfigRepair = autoItems.some((item) => item.id === "config-auto-repair" && item.command_hint === "soloforge config repair");
-        if (!hasConfigRepair) {
-            hardFail("NAVIGATION_CONFIG_REPAIR_NOT_RECOMMENDED", "problem-65: version/scope/evidence 这类机械配置问题必须推荐 soloforge config repair", ["src/engine/next_action_planner.ts", "src/engine/config_auto_repair.ts"], "problem-65", "旧导航把机械配置问题误当成业务确认", "将机械配置问题归入 auto_resolvable");
-        }
-        if ((decisions?.must_confirm?.length ?? 0) > 0) {
-            hardFail("NAVIGATION_CONFIG_REPAIR_FALSE_MUST_CONFIRM", "problem-65: 机械配置问题不得进入 must_confirm，不得要求用户逐字段确认", ["src/engine/next_action_planner.ts"], "problem-65", "旧导航把可自动修复项伪装成用户确认项", "保持 config repair 为 auto_resolvable");
-        }
-        const actionText = decisions?.recommended_action ?? "";
-        if (!actionText.includes("soloforge config repair")) {
-            hardFail("NAVIGATION_CONFIG_REPAIR_ACTION_MISSING", "problem-65: recommended_action 必须明确给出 soloforge config repair", ["src/engine/next_action_planner.ts"], "problem-65", "用户不知道下一步该运行哪个命令", "在 recommended_action 中输出自动修复命令");
-        }
-    }
-    catch (e) {
-        hardFail("NAVIGATION_CONFIG_REPAIR_BEHAVIOR_ERROR", `problem-65: 配置自动修复导航行为检查失败: ${e.message}`, ["src/engine/next_action_planner.ts", "src/engine/config_auto_repair.ts"], "problem-65", "配置自动修复行为未纳入发布门禁", "修复配置自动修复导航行为");
-    }
-    finally {
-        try {
-            fs.rmSync(repairTmpDir, { recursive: true });
-        }
-        catch { }
-    }
-    // 4. 知识文件存在性
-    const rulePath = path.join(rootDir, "templates", "knowledge", "rules", "工作流导航契约规则.md");
-    if (!fs.existsSync(rulePath)) {
-        hardFail("NAVIGATION_RULE_MISSING", "problem-65: 缺少知识规则文件 工作流导航契约规则.md", ["templates/knowledge/rules/工作流导航契约规则.md"], "problem-65", "导航知识规则缺失", "创建知识规则文件");
-    }
-    const procedurePath = path.join(rootDir, "templates", "knowledge", "procedures", "全生命周期工作流导航.md");
-    if (!fs.existsSync(procedurePath)) {
-        hardFail("NAVIGATION_PROCEDURE_MISSING", "problem-65: 缺少知识流程文件 全生命周期工作流导航.md", ["templates/knowledge/procedures/全生命周期工作流导航.md"], "problem-65", "导航知识流程缺失", "创建知识流程文件");
-    }
-    // 5. CLI 命令存在性
-    const cliDist = fs.readFileSync(path.join(rootDir, "dist", "bin", "soloforge.js"), "utf-8");
-    if (!cliDist.includes('case "next"') && !cliDist.includes("cmdNext")) {
-        hardFail("NAVIGATION_CLI_MISSING", "problem-65: CLI 缺少 next 命令入口", ["src/bin/soloforge.ts"], "problem-65", "CLI 无 next 命令", "添加 case 'next' dispatch");
-    }
-    if (!cliDist.includes('case "stage"') && !cliDist.includes("cmdStage")) {
-        hardFail("NAVIGATION_CLI_STAGE_MISSING", "problem-65: CLI 缺少 stage 命令入口", ["src/bin/soloforge.ts"], "problem-65", "CLI 无 stage 命令", "添加 case 'stage' dispatch");
-    }
-    if (!cliDist.includes('case "repair"') || !cliDist.includes("cmdConfigRepair")) {
-        hardFail("NAVIGATION_CONFIG_REPAIR_CLI_MISSING", "problem-65: CLI 缺少 config repair 命令入口", ["src/bin/soloforge.ts", "src/bin/config_commands.ts"], "problem-65", "自动修复能力存在但用户无法通过 CLI 调用", "添加 soloforge config repair");
-    }
-    _info("  problem-65 工作流导航行为验证完成");
-}
-// ── 17. 实现工程契约行为验证（问题六十六/六十七） ──
-async function checkImplementationContractBehavior(rootDir, hardFail, _info) {
-    const oodPath = path.join(rootDir, "dist", "engine", "ood_solid_contract.js");
-    const backendPath = path.join(rootDir, "dist", "engine", "backend_implementation_contract.js");
-    if (!fs.existsSync(oodPath) || !fs.existsSync(backendPath)) {
-        hardFail("IMPLEMENTATION_CONTRACT_MODULE_MISSING", "problem-66/67: OOD/SOLID 或后端工程契约未编译到 dist/", ["src/engine/ood_solid_contract.ts", "src/engine/backend_implementation_contract.ts"], "problem-66/problem-67", "仅登记问题而未验证运行时模块", "实现并编译两个工程契约模块");
-        return;
-    }
-    try {
-        const ood = await import(oodPath);
-        const backend = await import(backendPath);
-        const blockedOod = ood.evaluateOodDesignGate({
-            task_id: "gate-ood",
-            intent: "实现订单领域服务状态流转策略",
-            route: "code_change",
-        });
-        if (blockedOod.allowed || blockedOod.status !== "blocked") {
-            hardFail("OOD_SUMMARY_FALSE_PASS", "problem-66: 复杂业务编码缺少 OOD 摘要仍被放行", ["src/engine/ood_solid_contract.ts"], "problem-66", "文件存在不能证明编码前门禁有效", "修复 evaluateOodDesignGate 的缺摘要阻断");
-        }
-        const lowRisk = ood.evaluateOodDesignGate({
-            task_id: "gate-ood-low",
-            intent: "修复 README 文案错别字",
-            route: "code_change",
-        });
-        if (!lowRisk.allowed || lowRisk.status !== "not_applicable") {
-            hardFail("OOD_LOW_RISK_OVERBLOCK", "problem-66: 低风险文案任务被 OOD 门禁误阻断", ["src/engine/ood_solid_contract.ts"], "problem-66", "门禁不能以流程重量替代适用性判断", "修复低风险跳过判断");
-        }
-        const solidFindings = ood.reviewSolidCode({
-            "src/OrderController.ts": "class OrderController { save(){ return this.repository.save(this.calculate()); } }",
-        });
-        if (!ood.hasBlockingSolidFindings(solidFindings)) {
-            hardFail("SOLID_REVIEW_FALSE_PASS", "problem-66: Controller 职责膨胀没有产生阻断 finding", ["src/engine/ood_solid_contract.ts"], "problem-66", "必须用真实代码内容验证审查能力", "修复 SRP 阻断识别");
-        }
-        const blockedBackend = backend.evaluateBackendImplementationGate({
-            task_id: "gate-backend",
-            intent: "实现后端 API 支付接口",
-            route: "code_change",
-        });
-        if (blockedBackend.allowed || blockedBackend.status !== "blocked") {
-            hardFail("BACKEND_WORK_PACKAGE_FALSE_PASS", "problem-67: 后端实现缺少工程工作包仍被放行", ["src/engine/backend_implementation_contract.ts"], "problem-67", "文件存在不能证明编码前门禁有效", "修复 evaluateBackendImplementationGate");
-        }
-        const backendFindings = backend.reviewBackendImplementationFiles({
-            "src/PaymentController.java": "@PostMapping(\"/pay\") @Transactional public PaymentEntity pay(@RequestBody PaymentEntity value) { webClient.post(); return value; }",
-        });
-        if (!backend.hasBlockingBackendFindings(backendFindings)) {
-            hardFail("BACKEND_REVIEW_FALSE_PASS", "problem-67: 实体暴露或事务内外调没有产生阻断 finding", ["src/engine/backend_implementation_contract.ts"], "problem-67", "必须用真实代码内容验证后端审查能力", "修复后端工程 finding 检测");
-        }
-        if (backend.requiresBackendImplementationContract("实现简单 GET 详情只读接口", "code_change")) {
-            hardFail("BACKEND_LOW_RISK_OVERBLOCK", "problem-67: 简单只读接口被完整后端工程工作包误阻断", ["src/engine/backend_implementation_contract.ts"], "problem-67", "后端契约必须具备适用性边界", "修复低风险只读任务跳过逻辑");
-        }
-        const alignmentFindings = backend.verifyBackendArtifactAlignment({
-            apiDocumentText: "GET /api/payments/{id}",
-            openapiText: "paths:\n  /api/orders/{id}:",
-            migrationText: "create table payment(id bigint);",
-        });
-        if (!backend.hasBlockingBackendFindings(alignmentFindings)) {
-            hardFail("BACKEND_API_OPENAPI_DRIFT_FALSE_PASS", "problem-67: Markdown API 与 OpenAPI endpoint 漂移未阻断", ["src/engine/backend_implementation_contract.ts"], "problem-67", "契约对齐必须由行为检查证明", "修复 API/OpenAPI 漂移检测");
-        }
-        const lombokFindings = backend.reviewBackendImplementationFiles({
-            "src/main/java/com/demoapp/account/entity/Account.java": "import jakarta.persistence.Entity; import lombok.Data; @Entity @Data public class Account { private Long id; }",
-            "src/main/java/com/demoapp/account/dto/AccountCreateRequest.java": "import lombok.Getter; import lombok.Setter; @Getter @Setter public class AccountCreateRequest { private String name; }",
-        });
-        const modelContractFindings = lombokFindings.filter((item) => item.category === "model_lombok_contract" && item.severity === "hard_fail");
-        if (modelContractFindings.length < 2) {
-            hardFail("BACKEND_MODEL_LOMBOK_CONTRACT_FALSE_PASS", "problem-71: Java Entity/DTO/VO/Request Lombok 分层契约未阻断错误注解", ["src/engine/backend_implementation_contract.ts", "templates/scaffolds/spring-boot/Entity.java.hbs", "templates/scaffolds/spring-boot/DTO.java.hbs"], "problem-71", "后端工程契约不能只治理 Controller/DTO 命名，还必须约束数据模型注解语义", "添加 Entity @Getter/@Setter、DTO/VO/Request @Data 的行为检查和脚手架默认值");
-        }
-    }
-    catch (e) {
-        hardFail("IMPLEMENTATION_CONTRACT_EXECUTION_ERROR", `problem-66/67: 实现工程行为检查执行失败: ${e.message}`, ["src/engine/ood_solid_contract.ts", "src/engine/backend_implementation_contract.ts"], "problem-66/problem-67", "契约模块必须可运行并返回确定结果", "修复运行时异常");
-    }
-    const toolsText = safeRead(path.join(rootDir, "src", "adapters", "claude_code", "tools.ts")) ?? "";
-    const requiredHooks = [
-        "lazyOodSolid", "lazyBackendImplementation", "evaluateOodDesignGate",
-        "evaluateBackendImplementationGate", "reviewSolidCode",
-        "reviewBackendImplementationFiles", "hasBlockingSolidFindings", "hasBlockingBackendFindings",
-    ];
-    for (const hook of requiredHooks) {
-        if (!toolsText.includes(hook)) {
-            hardFail("IMPLEMENTATION_CONTRACT_MAINPATH_MISSING", `problem-66/67: MCP 主链路缺少真实消费点 ${hook}`, ["src/adapters/claude_code/tools.ts"], "problem-66/problem-67", "只实现引擎函数不能证明用户路径受约束", "接入 sf_expand/sf_review/sf_verify/sf_deliver");
-        }
-    }
-    _info("  problem-66/67 实现工程契约行为验证完成");
-}
-// ── 15. 发布问题全局合同 ──
-async function checkReleaseIssueDesignPath(rootDir, hardFail, _info) {
-    const toolsText = safeRead(path.join(rootDir, "src", "adapters", "claude_code", "tools.ts")) ?? "";
-    const cliText = safeRead(path.join(rootDir, "src", "bin", "soloforge.ts")) ?? "";
-    const workflowText = safeRead(path.join(rootDir, "src", "adapters", "shared", "workflow_template.ts")) ?? "";
-    // ══ 前置检查: roadmap 状态与发布文档一致性 ══
-    const roadmapText = safeRead(path.join(rootDir, "src", "engine", "implementation_roadmap_registry.ts")) ?? "";
-    const gateDocText = safeRead(path.join(rootDir, "docs", "正式发布门槛.md")) ?? "";
-    if (/status:\s*"in_repair"/.test(roadmapText)) {
-        hardFail("RELEASE_ISSUE_ROADMAP_IN_REPAIR", "发布问题仍有 in_repair 状态，不得通过发布门禁", ["src/engine/implementation_roadmap_registry.ts"], "release-issues", "roadmap 状态为 in_repair 时不能声称完成", "完成所有返修后改为 implemented_verified");
-    }
-    // 发布问题场景矩阵: 结构化场景注册表验证测试文件存在 + 执行证据
-    {
-        const { validateReleaseIssueScenarios, executeReleaseIssueScenarios } = await import("./release_issue_scenario_registry.js");
-        const scenarioResult = validateReleaseIssueScenarios(rootDir);
-        _info(`  发布问题场景: ${scenarioResult.scenario_count} 条，覆盖 ${scenarioResult.covered_problems.join(", ")}`);
-        if (scenarioResult.missing_runners.length > 0) {
-            hardFail("RELEASE_ISSUE_SCENARIO_NO_RUNNER", `发布问题场景缺少 runner: ${scenarioResult.missing_runners.join("; ")}`, ["src/engine/release_issue_scenario_registry.ts"], "release-issues", "所有场景必须有真实生产入口 runner", "为缺失场景添加 runner");
-        }
-        if (scenarioResult.missing_tests.length > 0) {
-            hardFail("RELEASE_ISSUE_SCENARIO_TESTS_MISSING", `发布问题场景引用的测试文件缺失: ${scenarioResult.missing_tests.join("; ")}`, scenarioResult.missing_tests.map(m => m.split(": ")[1] ?? "unknown"), "release-issues", "场景测试文件必须存在", "创建缺失的测试文件");
-        }
-        // 运行所有场景收集执行证据（全部必须有 runner）
-        const execResults = await executeReleaseIssueScenarios();
-        const failed = execResults.filter(r => r.status === "fail");
-        _info(`  发布问题场景执行: ${execResults.length} 条已执行，${failed.length} 条失败`);
-        if (failed.length > 0) {
-            hardFail("RELEASE_ISSUE_SCENARIO_EXECUTION_FAILED", `发布问题场景执行失败: ${failed.map(f => `${f.scenario_id}: ${f.error ?? "unknown"}`).join("; ")}`, ["src/engine/release_issue_scenario_registry.ts"], "release-issues", "所有场景执行必须通过", "修复失败场景的 runner 逻辑");
-        }
-        // R10: 所有场景必须有 production_trace 且 tool_entrypoint 引用真实工具
-        const noTrace = execResults.filter(r => !r.production_trace);
-        if (noTrace.length > 0) {
-            hardFail("RELEASE_ISSUE_SCENARIO_NO_PRODUCTION_TRACE", `场景缺少 production_trace: ${noTrace.map(r => r.scenario_id).join("; ")}`, ["src/engine/release_issue_scenario_registry.ts"], "release-issues", "所有场景必须有 production_trace 记录真实入口", "为缺失场景添加 production_trace");
-        }
-        // R10.1: 每个场景（非 engine_contract 声明）的 tool_entrypoint 必须包含真实工具名
-        const allRealToolNames = ["sf_classify", "sf_expand", "sf_verify", "sf_deliver", "sf_learn", "sf_accept", "sf_record_verification_execution", "sf_scaffold", "sf_navigation", "soloforge next", "checkArchitectureDecisionWorkshopGate", "planNextAction"];
-        const fakeTraceScenarios = execResults.filter(r => r.production_trace &&
-            !allRealToolNames.some(t => r.production_trace.tool_entrypoint.includes(t)) &&
-            !r.production_trace.gates_consumed?.includes("engine_contract"));
-        if (fakeTraceScenarios.length > 0) {
-            hardFail("RELEASE_ISSUE_SCENARIO_NO_PRODUCTION_TRACE", `场景 production_trace 不引用真实工具入口: ${fakeTraceScenarios.map(r => `${r.scenario_id}(entrypoint=${r.production_trace.tool_entrypoint})`).join("; ")}`, ["src/engine/release_issue_scenario_registry.ts"], "release-issues", "所有场景的 production_trace.tool_entrypoint 必须引用真实工具（sf_classify/sf_expand/adapter gate 等）", "用 createToolHarness 重写 runner");
-        }
-        // R12: production_trace 的 diagnostic_codes 必须非空（来自工具返回值或函数调用结果）
-        const noDiagCodes = execResults.filter(r => r.production_trace && (!r.production_trace.diagnostic_codes || r.production_trace.diagnostic_codes.length === 0));
-        if (noDiagCodes.length > 0) {
-            hardFail("RELEASE_ISSUE_SCENARIO_NO_PRODUCTION_TRACE", `场景 production_trace 缺少 diagnostic_codes: ${noDiagCodes.map(r => r.scenario_id).join("; ")}`, ["src/engine/release_issue_scenario_registry.ts"], "release-issues", "所有 production_trace 必须包含来自工具/函数返回值的 diagnostic_codes", "为场景添加真实 diagnostic_codes");
-        }
-        // R14: architecture-workshop 非 low-risk 场景必须真正触发 workshop（不得假绿）
-        {
-            const archNonLowRisk = execResults.filter(r => r.scenario_id.startsWith("release-scenario-architecture-workshop-") &&
-                !r.scenario_id.includes("low-risk-skip"));
-            const fakeGreenPatterns = ["workshop=false", "domains=0", "no workshop", "blocked by earlier gate"];
-            const fakeGreens = archNonLowRisk.filter(r => r.status === "pass" && fakeGreenPatterns.some(p => r.evidence?.includes(p)));
-            if (fakeGreens.length > 0) {
-                hardFail("RELEASE_ISSUE_SCENARIO_NO_PRODUCTION_TRACE", `architecture-workshop 场景假绿: ${fakeGreens.map(r => `${r.scenario_id}(evidence=${r.evidence?.slice(0, 120)})`).join("; ")}`, ["src/engine/release_issue_scenario_registry.ts"], "release-issues", "非 low-risk 架构研讨场景必须真正触发 architecture_decision_workshop，不得把证据门阻断当作 pass", "确保场景提供足够证据通过 evidence grounding gate，使 workshop gate 能实际触发");
-            }
-            // 非 low-risk 场景必须同时有 sf_classify 和 sf_expand 入口
-            const missingEntrypoint = archNonLowRisk.filter(r => r.production_trace &&
-                (!r.production_trace.tool_entrypoint.includes("sf_classify") || !r.production_trace.tool_entrypoint.includes("sf_expand")));
-            if (missingEntrypoint.length > 0) {
-                hardFail("RELEASE_ISSUE_SCENARIO_NO_PRODUCTION_TRACE", `architecture-workshop 场景缺少 sf_classify 或 sf_expand 入口: ${missingEntrypoint.map(r => `${r.scenario_id}(entrypoint=${r.production_trace.tool_entrypoint})`).join("; ")}`, ["src/engine/release_issue_scenario_registry.ts"], "release-issues", "architecture-workshop 非 low-risk 场景必须同时通过 sf_classify 和 sf_expand 真实 MCP 工具执行", "使用 createToolHarness + callTool('sf_classify') + callTool('sf_expand') 重写 runner");
-            }
-        }
-        // R15: production_trace.diagnostic_codes 不得包含运行时异常
-        {
-            const runtimeErrorPattern = /Cannot read|TypeError|ReferenceError|^undefined$|uncaught exception|\.error\b/i;
-            const runtimeDiagCodes = execResults.filter(r => r.production_trace?.diagnostic_codes?.some(c => runtimeErrorPattern.test(c)));
-            if (runtimeDiagCodes.length > 0) {
-                hardFail("RELEASE_ISSUE_SCENARIO_DIAGNOSTIC_SWALLOWED_ERROR", `场景 production_trace.diagnostic_codes 包含运行时异常（不是业务/门禁诊断码）: ${runtimeDiagCodes.map(r => `${r.scenario_id}(codes=${r.production_trace.diagnostic_codes.filter(c => runtimeErrorPattern.test(c)).join("; ")})`).join("; ")}`, ["src/engine/release_issue_scenario_registry.ts"], "release-issues", "diagnostic_codes 必须来自真实业务/门禁诊断，不得把异常信息当作有效诊断码", "定位异常根因并修复，或确保场景提供完整输入使工具不抛异常");
-            }
-        }
-        // R10: 每个 problem 必须至少有一个场景通过真实 MCP 工具入口执行
-        const realToolNames = ["sf_classify", "sf_expand", "sf_verify", "sf_deliver", "sf_learn", "sf_accept", "sf_record_verification_execution", "sf_scaffold"];
-        // 用 scenario_id 前缀识别 problem 归属
-        const problemPrefixes = {
-            "problem-61": ["release-scenario-architecture-workshop-", "release-scenario-decision-workshop-"],
-            "problem-62": ["release-scenario-design-pack-"],
-            "problem-63": ["release-scenario-template-contract-"],
-            "problem-64": ["release-scenario-template-visibility-"],
-            "problem-68": ["release-scenario-code-observability-"],
-        };
-        for (const [problem, prefixes] of Object.entries(problemPrefixes)) {
-            const problemScenarios = execResults.filter(r => prefixes.some(p => r.scenario_id.startsWith(p)));
-            const withRealTools = problemScenarios.filter(r => r.production_trace && realToolNames.some(t => r.production_trace.tool_entrypoint.includes(t)));
-            if (withRealTools.length === 0 && problemScenarios.length > 0) {
-                hardFail("RELEASE_ISSUE_SCENARIO_NO_PRODUCTION_TRACE", `${problem} 无场景通过真实 MCP 工具入口执行`, ["src/engine/release_issue_scenario_registry.ts"], "release-issues", `R10 ${problem} 必须有通过 sf_classify/sf_expand 等真实 MCP 工具执行的场景`, "用 createToolHarness + callTool 重写 runner");
-            }
-        }
-        // R13: problem-61 必须证明 awaiting_confirmation 阻断 + 确认放行双向
-        {
-            const p61 = execResults.filter(r => r.scenario_id.startsWith("release-scenario-decision-workshop-"));
-            // 阻断证据: evidence 包含 "awaiting" 或 diagnostic_codes 包含决策研讨阻断码
-            const hasAwaiting = p61.some(r => r.evidence?.includes("awaiting") ||
-                r.production_trace?.diagnostic_codes?.some(c => c.includes("决策研讨") || c.includes("awaiting_confirmation")));
-            // 放行证据: 至少一个 decision_workshop 场景通过两次 sf_expand（tool_entrypoint 含两个 sf_expand）
-            const hasConfirmedPass = p61.some(r => r.status === "pass" && r.production_trace?.tool_entrypoint &&
-                (r.production_trace.tool_entrypoint.match(/sf_expand/g) ?? []).length >= 2);
-            if (!hasAwaiting || !hasConfirmedPass) {
-                hardFail("RELEASE_ISSUE_SCENARIO_NO_PRODUCTION_TRACE", `problem-61 缺少 awaiting_confirmation 阻断+放行双向证据 (awaiting=${hasAwaiting}, confirmed=${hasConfirmedPass})`, ["src/engine/release_issue_scenario_registry.ts"], "release-issues", "problem-61 必须有场景证明 decision_workshop 阻断后确认放行", "确保 data-migration/security-policy 等场景含 awaiting 阻断和确认放行双向证据");
-            }
-        }
-        // problem-63 必须在同一正式产物任务上证明阻断、清零、接受与交付，不能由描述文字自证。
-        {
-            const p63 = execResults.filter(r => r.scenario_id.startsWith("release-scenario-template-contract-"));
-            const lifecycleProof = p63.find(r => r.scenario_id === "release-scenario-template-contract-repair-directive")?.behavioral_proof;
-            const sameTask = lifecycleProof?.task_id
-                && lifecycleProof.blocked_task_id === lifecycleProof.task_id
-                && lifecycleProof.delivered_task_id === lifecycleProof.task_id;
-            const completed = lifecycleProof?.contract_blocked === true
-                && lifecycleProof?.repair_directive_cleared === true
-                && lifecycleProof?.artifact_status === "accepted"
-                && !!lifecycleProof?.acceptance_confirmation_ref
-                && lifecycleProof?.delivery_succeeded === true;
-            if (!sameTask || !completed) {
-                hardFail("RELEASE_ISSUE_SCENARIO_NO_PRODUCTION_TRACE", `problem-63 缺少同任务正式产物生命周期证据 (same_task=${!!sameTask}, completed=${completed})`, ["src/engine/release_issue_scenario_registry.ts"], "release-issues", "problem-63 必须从同一 task 的 artifact_output 证明阻断、重验、显式接受和成功交付", "修复 repair-directive 场景的 behavioral_proof 与真实工具链");
-            }
-        }
-    }
-    // R10: index_only 泄漏行为门禁 — 通过真实 sf_expand 验证 index_only 不进入 prompt
-    {
-        const { createToolHarness } = await import("./release_tool_harness.js");
-        const { clearInjectionContractCache } = await import("./knowledge_injection_boundary.js");
-        clearInjectionContractCache();
-        try {
-            const harness = await createToolHarness({ copyKnowledge: true });
-            try {
-                const all = harness.knowledgeIndex.getAllEntries();
-                // 找到 index_only 条目
-                const { buildTemplateAssetContracts } = await import("./template_asset_contract_registry.js");
-                const contracts = buildTemplateAssetContracts(rootDir);
-                const indexOnlyIds = new Set(contracts.filter(c => c.runtime_visibility === "index_only").map(c => c.asset_id));
-                // R12: 前置条件缺失 = hardFail，不得静默跳过
-                if (all.project.length === 0) {
-                    hardFail("RELEASE_ISSUE_INDEX_ONLY_PROMPT_LEAK", "copyKnowledge 后无项目资产被索引，前置条件不满足", ["src/engine/knowledge_injection_boundary.ts"], "release-issues", "index_only 行为检查必须有同步+索引的资产", "检查 copyKnowledgeToProject 和 KIM build");
-                }
-                if (indexOnlyIds.size === 0) {
-                    hardFail("RELEASE_ISSUE_INDEX_ONLY_PROMPT_LEAK", "模板合同中无 index_only 资产，前置条件不满足", ["src/engine/template_asset_contract_registry.ts"], "release-issues", "index_only 行为检查必须存在 index_only 合同", "检查 buildTemplateAssetContracts 是否注册了 index_only 资产");
-                }
-                const clsRaw = await harness.callTool("sf_classify", { intent: "添加用户管理功能" });
-                const cls = harness.parseResult(clsRaw);
-                if (!cls.task_id) {
-                    hardFail("RELEASE_ISSUE_INDEX_ONLY_PROMPT_LEAK", "sf_classify 未返回 task_id，前置条件不满足", ["src/engine/classifier.ts"], "release-issues", "index_only 行为检查必须 sf_classify 返回有效 task_id", "检查分类器是否正常返回");
-                }
-                const expRaw = await harness.callTool("sf_expand", { task_id: cls.task_id });
-                const exp = harness.parseResult(expRaw);
-                // index_only 资产不得进入 matched_knowledge
-                const leaked = (exp.matched_knowledge ?? []).filter((k) => indexOnlyIds.has(k.id));
-                if (leaked.length > 0) {
-                    hardFail("RELEASE_ISSUE_INDEX_ONLY_PROMPT_LEAK", `index_only 资产泄漏到 expand 结果: ${leaked.map((k) => k.id).join(", ")}`, ["src/engine/knowledge_injection_boundary.ts"], "release-issues", "index_only 资产不得进入 matched_knowledge 或 prompt", "修复注入边界逻辑");
-                }
-                // prompt 中也不得包含 index_only 资产内容
-                const promptStr = exp.prompt ?? "";
-                const leakedInPrompt = all.project.filter((e) => {
-                    const contract = contracts.find(c => c.asset_id === e.id || c.path.endsWith(e.name + ".md"));
-                    return contract?.runtime_visibility === "index_only" && e.body && promptStr.includes(e.body.slice(0, 50));
-                });
-                if (leakedInPrompt.length > 0) {
-                    hardFail("RELEASE_ISSUE_INDEX_ONLY_PROMPT_LEAK", `index_only 资产内容泄漏到 prompt: ${leakedInPrompt.map((e) => e.id).join(", ")}`, ["src/engine/knowledge_injection_boundary.ts"], "release-issues", "index_only 资产内容不得出现在 prompt 中", "修复注入边界逻辑");
-                }
-            }
-            finally {
-                harness.cleanup();
-            }
-        }
-        catch (err) {
-            // R11: fail-closed — 缺少前置条件或异常 = hard_fail
-            hardFail("RELEASE_ISSUE_INDEX_ONLY_PROMPT_LEAK", `index_only 行为检查失败: ${err.message}`, ["src/engine/knowledge_injection_boundary.ts"], "release-issues", "index_only 行为检查不得跳过", "修复 index_only 检查前置条件");
-        }
-    }
-    // R10: 权威来源 fail-closed 主动负向测试 — 已注册但文件缺失必须被阻断
-    {
-        const { getConsumptionTraces, clearConsumptionTraces } = await import("./consumption_trace_store.js");
-        // 先检查已有 traces
-        const traces = getConsumptionTraces();
-        const authorityLeaks = traces.filter((t) => t.matched_reason?.includes("权威来源文件缺失") && t.contract_decision === "allowed");
-        if (authorityLeaks.length > 0) {
-            hardFail("RELEASE_ISSUE_AUTHORITIVE_FAIL_OPEN", `权威来源缺失的资产被 allowed: ${authorityLeaks.map((t) => t.asset_id).join(", ")}`, ["src/knowledge/index_manager.ts"], "release-issues", "已注册资产权威来源缺失时必须 fail-closed", "检查 filterByContractGate 逻辑");
-        }
-        // 主动负向测试: 创建临时项目，manifest 指向不存在的权威文件
-        try {
-            const { copyKnowledgeToProject } = await import("./template_init_sync.js");
-            const { KnowledgeIndexManager } = await import("../knowledge/index_manager.js");
-            const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "soloforge-r10-auth-"));
-            try {
-                await copyKnowledgeToProject(rootDir, tmpDir);
-                const manifestPath = path.join(tmpDir, ".soloforge", "sync-manifest.json");
-                const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
-                const domainKey = Object.keys(manifest.entries).find(k => k.startsWith("domain/"));
-                // R12: 找不到 domain 条目 = hardFail，不得静默通过
-                if (!domainKey) {
-                    hardFail("RELEASE_ISSUE_AUTHORITIVE_FAIL_OPEN", "sync-manifest 中无 domain/ 条目可做篡改测试，前置条件不满足", ["src/engine/template_init_sync.ts"], "release-issues", "权威 fail-closed 测试必须找到可篡改的 domain 合同", "检查 copyKnowledgeToProject 是否同步了 domain 资产");
-                }
-                manifest.entries[domainKey].source_contract_path = "templates/knowledge/domain/不存在的权威文件.md";
-                fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2), "utf-8");
-                clearConsumptionTraces();
-                const kim = new KnowledgeIndexManager({
-                    tech_stack: { backend: { lang: "java", framework: "spring-boot" }, frontend: { lang: "typescript", framework: "react" } },
-                    _projectPath: tmpDir,
-                }, { watch: false });
-                await kim.build();
-                const domainEntries = kim.getAllEntries().project.filter((e) => e.file_path?.replace(/\\/g, "/").includes(domainKey));
-                await kim.close();
-                // 权威来源缺失 → 不得被索引
-                if (domainEntries.length > 0) {
-                    hardFail("RELEASE_ISSUE_AUTHORITIVE_FAIL_OPEN", `权威缺失的资产被索引: ${domainKey}`, ["src/knowledge/index_manager.ts"], "release-issues", "已注册资产权威来源缺失时必须 fail-closed", "检查 filterByContractGate 逻辑");
-                }
-            }
-            finally {
-                fs.rmSync(tmpDir, { recursive: true, force: true });
-            }
-        }
-        catch (err) {
-            // R11: fail-closed — 找不到篡改目标或执行异常 = hard_fail
-            hardFail("RELEASE_ISSUE_AUTHORITIVE_FAIL_OPEN", `权威 fail-closed 主动测试失败: ${err.message}`, ["src/knowledge/index_manager.ts"], "release-issues", "权威来源缺失测试不得跳过", "检查 filterByContractGate 和模板合同配置");
-        }
-    }
-    // 工作流硬规则正文单真源检查
-    {
-        const { WORKFLOW_TEMPLATE_HARD_RULES } = await import("./asset_manifest.js");
-        const { generateWorkflowRules } = await import("../adapters/shared/workflow_template.js");
-        const emptyRules = WORKFLOW_TEMPLATE_HARD_RULES.filter(r => r.enforcement_status === "enforced" && (!r.user_instruction || r.user_instruction.trim() === ""));
-        if (emptyRules.length > 0) {
-            hardFail("WORKFLOW_RULE_EMPTY_INSTRUCTION", `enforced 规则 user_instruction 为空: ${emptyRules.map(r => r.rule_id).join(", ")}`, ["src/engine/asset_manifest.ts"], "release-issues", "enforced 规则必须有非空 user_instruction", "为空规则补充用户可见指令文本");
-        }
-        const output = generateWorkflowRules({});
-        for (const rule of WORKFLOW_TEMPLATE_HARD_RULES) {
-            if (rule.user_instruction) {
-                const lines = rule.user_instruction.split("\n").filter(l => l.trim());
-                for (const line of lines) {
-                    if (!output.includes(line)) {
-                        hardFail("WORKFLOW_RULE_TEXT_MISSING_IN_OUTPUT", `规则 ${rule.rule_id} 正文未出现在生成输出: ${line}`, ["src/engine/asset_manifest.ts", "src/adapters/shared/workflow_template.ts"], "release-issues", "每条规则正文必须出现在 generateWorkflowRules 输出", "检查 WORKFLOW_STEPS 中是否遗漏该规则");
-                    }
-                }
-            }
-            if (!output.includes(`id=${rule.rule_id}`)) {
-                hardFail("WORKFLOW_RULE_MARKER_MISSING", `规则 ${rule.rule_id} marker 未出现在生成输出`, ["src/adapters/shared/workflow_template.ts"], "release-issues", "每条规则 marker 必须出现在 generateWorkflowRules 输出", "将规则添加到 WORKFLOW_STEPS");
-            }
-        }
-    }
-    if (/发布问题.*100%|100%.*发布问题/.test(gateDocText)) {
-        hardFail("RELEASE_ISSUE_DOC_PREMATURE_100", "发布门槛文档提前声称发布问题 100% 完成", ["docs/正式发布门槛.md"], "release-issues", "文档不得在返修未完成前声称 100%", "完成所有返修后更新文档");
-    }
-    // ══ 问题六十一: 通用决策研讨机制 ══
-    // TaskContext 必须有强类型通用决策研讨字段
-    const typesText = safeRead(path.join(rootDir, "src", "types.ts")) ?? "";
-    if (!sourceContainsPattern(typesText, "decision_workshop?: import")) {
-        hardFail("RELEASE_ISSUE_TASKCONTEXT_WEAK_TYPE", "TaskContext 缺少强类型 decision_workshop 字段", ["src/types.ts"], "problem-61", "使用 (ctx as any).decision_workshop 是弱类型", "在 TaskContext 添加 decision_workshop 强类型字段");
-    }
-    // tools.ts 不得使用 (ctx as any).decision_workshop
-    if (sourceContainsPropertyAccess(toolsText, "ctx", "decision_workshop") && toolsText.includes("(ctx as any)")) {
-        hardFail("RELEASE_ISSUE_TOOLS_ANY_CAST", "tools.ts 仍使用 (ctx as any).decision_workshop 弱类型", ["src/adapters/claude_code/tools.ts"], "problem-61", "必须使用 TaskContext 强类型字段", "将 (ctx as any).decision_workshop 改为 ctx.decision_workshop");
-    }
-    // ExpandSchema 必须支持 decision_workshop 输入
-    if (!sourceContainsIdentifier(toolsText, "decision_workshop:") || (!sourceContainsZodSchema(toolsText, "decision_workshop", "z.record(z.unknown())") && !sourceContainsZodSchema(toolsText, "decision_workshop", "z.unknown()"))) {
-        hardFail("RELEASE_ISSUE_EXPAND_NO_WORKSHOP_INPUT", "ExpandSchema 不支持通用 decision_workshop 输入", ["src/adapters/claude_code/tools.ts"], "problem-61", "用户无法回传确认后的决策合同", "在 ExpandSchema 添加 decision_workshop 输入参数");
-    }
-    if (!sourceContainsIdentifier(toolsText, "parseContractObject") || !sourceContainsIdentifier(toolsText, "JSON.parse")) {
-        hardFail("RELEASE_ISSUE_EXPAND_WORKSHOP_JSON_STRING_UNSUPPORTED", "sf_expand 未兼容 MCP 客户端以 JSON 字符串回传 decision_workshop", ["src/adapters/claude_code/tools.ts"], "problem-61", "真实用户项目中 decision_workshop 被序列化为字符串后触发 undefined.includes 服务端错误", "在 sf_expand 入口解析 JSON 字符串契约，解析失败返回结构化错误");
-    }
-    const dwTextForShape = safeRead(path.join(rootDir, "src", "engine", "decision_workshop.ts")) ?? "";
-    if (!sourceContainsIdentifier(toolsText, "normalizeDecisionWorkshopContract") || !sourceContainsPattern(dwTextForShape, "MCP 客户端回传的领域字典已规范化")) {
-        hardFail("RELEASE_ISSUE_EXPAND_WORKSHOP_NATURAL_SHAPE_UNSUPPORTED", "sf_expand 未兼容 AI 回传的决策域字典结构", ["src/adapters/claude_code/tools.ts", "src/engine/decision_workshop.ts"], "problem-61", "真实 AI 会回传 { delivery_validation: {...} } 形状，若不规范化会卡在 expanding 或结构无效", "在 decision_workshop.ts 提供 normalizeDecisionWorkshopContract，并在 sf_expand 入口使用");
-    }
-    const s4RecoveryFields = [
-        "technology_decision_contract",
-        "technology_decision_record",
-        "detail_discipline_contract",
-        "provided_details",
-        "first_principles_frame",
-        "brainstorm_session",
-    ];
-    const missingS4SchemaFields = s4RecoveryFields.filter((field) => !sourceContainsZodSchema(toolsText, field, "z.record(z.unknown())") && !sourceContainsZodSchema(toolsText, field, "z.unknown()"));
-    const missingS4ContextFields = s4RecoveryFields.filter((field) => !sourceContainsPattern(typesText, `${field}?:`));
-    const missingS4SaveFields = s4RecoveryFields.filter((field) => !sourceContainsPattern(toolsText, `(ctx as Record<string, unknown>)[field]`) && !sourceContainsPattern(toolsText, `ctx.${field} = parsed.value`));
-    const staleS4AnyFields = s4RecoveryFields.filter((field) => sourceContainsPattern(toolsText, `(ctx as any).${field}`) || sourceContainsPattern(toolsText, `(params.ctx as any).${field}`));
-    if (missingS4SchemaFields.length > 0 || missingS4ContextFields.length > 0 || missingS4SaveFields.length > 0 || staleS4AnyFields.length > 0) {
-        hardFail("RELEASE_ISSUE_S4_RECOVERY_INPUT_MISSING", "S4 强门禁缺少可执行 sf_expand 恢复入口", ["src/adapters/claude_code/tools.ts", "src/types.ts"], "problem-16/26/27/42", `缺 schema=${missingS4SchemaFields.join(",")}; 缺 TaskContext=${missingS4ContextFields.join(",")}; 缺保存=${missingS4SaveFields.join(",")}; 弱类型=${staleS4AnyFields.join(",")}`, "所有返回“请提供 X 后重新 sf_expand”的强门禁，都必须在 ExpandSchema 接受 X、写入 TaskContext，并通过强类型主链路消费");
-    }
-    // 架构决策研讨子包必须接入 sf_expand
-    if (!sourceContainsIdentifier(toolsText, "checkArchitectureDecisionWorkshopGate") ||
-        !sourceContainsPattern(toolsText, "projectContext: detectedArchitectureContext")) {
-        hardFail("RELEASE_ISSUE_MAINLINE_MISSING", "问题六十一架构研讨子包未接入 sf_expand", ["src/adapters/claude_code/tools.ts"], "problem-61", "仅有合同或模板不能证明主链路消费", "在 sf_expand 真实路由调用架构研讨门");
-    }
-    // 通用决策研讨必须接入 sf_expand（可组合决策包）
-    if (!sourceContainsIdentifier(toolsText, "lazyDecisionWorkshop") || !sourceContainsIdentifier(toolsText, "matchDecisionPacks") || !sourceContainsIdentifier(toolsText, "nonArchPacks")) {
-        hardFail("RELEASE_ISSUE_DECISION_WORKSHOP_MISSING", "问题六十一通用决策研讨未接入 sf_expand 可组合决策包", ["src/adapters/claude_code/tools.ts"], "problem-61", "非架构高影响任务也必须门禁，且必须支持组合多个决策包", "在 sf_expand 接入 matchDecisionPacks 门禁");
-    }
-    // DecisionPackRegistry 必须有 business_process 和 delivery_validation 独立包
-    {
-        const dwText = safeRead(path.join(rootDir, "src", "engine", "decision_workshop.ts")) ?? "";
-        if (!dwText.includes("business_process") || !dwText.includes("delivery_validation")) {
-            hardFail("RELEASE_ISSUE_DECISION_PACK_MISSING", "问题六十一 DecisionPackRegistry 缺少 business_process 或 delivery_validation 独立包", ["src/engine/decision_workshop.ts"], "problem-61", "业务流程和交付验证必须可独立触发", "在 DECISION_PACKS 添加 business_process 和 delivery_validation");
-        }
-    }
-    try {
-        const dw = await import(path.join(rootDir, "dist", "engine", "decision_workshop.js"));
-        // must-fail: 未确认的技术选型必须阻断
-        const techContract = dw.createDecisionWorkshop("gate-test", "technology_selection");
-        const techGate = dw.evaluateDecisionWorkshop(techContract);
-        if (techGate.allowed) {
-            hardFail("RELEASE_ISSUE_DECISION_FALSE_PASS", "问题六十一未确认技术选型草稿错误放行", ["src/engine/decision_workshop.ts"], "problem-61", "技术选型未确认应阻断", "修复 evaluateDecisionWorkshop");
-        }
-        // must-fail: 低风险任务不需要研讨
-        const lowRisk = dw.requiresDecisionWorkshop({ intent: "修复按钮颜色" });
-        if (lowRisk.required) {
-            hardFail("RELEASE_ISSUE_DECISION_LOW_RISK_BLOCKED", "问题六十一低风险任务错误触发决策研讨", ["src/engine/decision_workshop.ts"], "problem-61", "低风险任务不应触发研讨", "修复 requiresDecisionWorkshop 触发条件");
-        }
-        // must-pass: 确认的技术选型放行
-        const confirmed = dw.createDecisionWorkshop("gate-test-2", "technology_selection");
-        confirmed.extended_domains.technology_selection.status = "confirmed";
-        confirmed.extended_domains.technology_selection.user_confirmation_ref = "user-ok";
-        if (!dw.evaluateDecisionWorkshop(confirmed).allowed) {
-            hardFail("RELEASE_ISSUE_DECISION_CONFIRMED_BLOCKED", "问题六十一已确认决策仍被阻断", ["src/engine/decision_workshop.ts"], "problem-61", "已确认决策应放行", "修复 evaluateDecisionWorkshop 确认检查");
-        }
-    }
-    catch (error) {
-        hardFail("RELEASE_ISSUE_DECISION_LOAD_FAILED", `无法执行问题六十一行为复验: ${error?.message ?? error}`, ["src/engine/decision_workshop.ts"], "problem-61", "模块不可执行", "修复构建或导出");
-    }
-    // ══ 问题六十二: 标准资产覆盖机制 ══
-    if (!sourceContainsCall(toolsText, "verifyDesignArtifactPack") ||
-        !sourceContainsPattern(toolsText, "ctx.design_artifact_pack.status !== \"implementation_ready\"") ||
-        !sourceContainsCall(toolsText, "checkDesignArtifactWriteGate")) {
-        hardFail("RELEASE_ISSUE_MAINLINE_MISSING", "问题六十二设计产物包子机制未接入真实消费路径", ["src/adapters/claude_code/tools.ts"], "problem-62", "仅有文档校验函数不能阻断用户编码/交付", "在验证、写入与交付路径消费设计产物包状态");
-    }
-    if (!sourceContainsCall(toolsText, "auditDesignImplementationTraceability") ||
-        !sourceContainsIdentifier(toolsText, "verifyChangedFilesAgainstDesignTraceability") ||
-        !sourceContainsIdentifier(toolsText, "TOOL_DIAGNOSTIC_CODES.traceabilityVerifyFailed")) {
-        hardFail("RELEASE_ISSUE_TRACEABILITY_MAINLINE_MISSING", "问题七十三追踪契约未接入 sf_expand/sf_verify 主链路", ["src/adapters/claude_code/tools.ts", "src/engine/traceability.ts"], "problem-73", "只审计设计产物不能保证编码来自需求、原型、架构、详细设计和切片", "在 sf_expand 编码前门和 sf_verify changed_files 门接入追踪契约");
-    }
-    const traceabilityText = safeRead(path.join(rootDir, "src", "engine", "traceability.ts")) ?? "";
-    const nextPlannerText = safeRead(path.join(rootDir, "src", "engine", "next_action_planner.ts")) ?? "";
-    if (!sourceContainsIdentifier(traceabilityText, "DESIGN_IMPLEMENTATION_TRACEABILITY_TEMPLATE_PATH") ||
-        !sourceContainsIdentifier(traceabilityText, "recovery_command") ||
-        !sourceContainsIdentifier(traceabilityText, "recovery_zh") ||
-        !sourceContainsIdentifier(nextPlannerText, "DESIGN_IMPLEMENTATION_TRACEABILITY_TEMPLATE_PATH") ||
-        !sourceContainsPattern(cliText, "finding.template_path") ||
-        !sourceContainsPattern(cliText, "finding.recovery_command")) {
-        hardFail("RELEASE_ISSUE_TRACEABILITY_RECOVERY_PATH_MISSING", "问题七十三追踪矩阵强门禁缺少模板/引导/审计恢复路径", ["src/engine/traceability.ts", "src/engine/next_action_planner.ts", "src/bin/soloforge.ts"], "problem-73", "强门禁只阻断不给模板和恢复命令会导致用户无法闭环", "为追踪矩阵 finding、soloforge next 和 audit-design-artifacts 输出模板路径与恢复命令");
-    }
-    const designPackText = safeRead(path.join(rootDir, "src", "engine", "design_artifact_pack.ts")) ?? "";
-    if (!designPackText.includes("traceability_matrix") ||
-        !designPackText.includes("auditDesignImplementationTraceability")) {
-        hardFail("RELEASE_ISSUE_TRACEABILITY_DESIGN_AUDIT_MISSING", "问题七十三未并入设计产物包审计", ["src/engine/design_artifact_pack.ts"], "problem-73", "追踪矩阵不进入 audit-design-artifacts 会导致用户设计阶段无法发现缺口", "把追踪矩阵作为设计产物包权威资产审计");
-    }
-    const lifecycleContractText = safeRead(path.join(rootDir, "src", "engine", "design_lifecycle_contract.ts")) ?? "";
-    const lifecycleKnowledgeText = safeRead(path.join(rootDir, "src", "engine", "lifecycle_knowledge_contract.ts")) ?? "";
-    if (!lifecycleContractText.includes("detail_design") ||
-        !lifecycleContractText.includes("docs/architecture/02-数据库设计文档.md") ||
-        !lifecycleContractText.includes("docs/architecture/03-API接口规格文档.md") ||
-        !lifecycleContractText.includes("optional_implementation_detail_document") ||
-        !lifecycleContractText.includes("docs/architecture/04-开发切片计划.md") ||
-        !lifecycleContractText.includes("DESIGN_LIFECYCLE_LEGACY_SLICE_PLAN_PATHS") ||
-        !lifecycleContractText.includes("slice_planning") ||
-        !designPackText.includes("getDesignLifecycleArtifactPaths")) {
-        hardFail("RELEASE_ISSUE_DESIGN_LIFECYCLE_CONTRACT_MISSING", "设计、实现、测试、验收生命周期 I/O 合同缺失或未被设计产物包消费", ["src/engine/design_lifecycle_contract.ts", "src/engine/design_artifact_pack.ts"], "problem-62/problem-73", "没有中心合同会导致后续门禁凭空新增输入输出，详细设计又被误判成单文件", "建立中心生命周期合同，并让设计产物包、追踪审计和 hook 消费同一合同");
-    }
-    if (!lifecycleKnowledgeText.includes("evaluateLifecycleKnowledgeDecision") ||
-        !lifecycleKnowledgeText.includes("selectProjectKnowledgeForTaskWithReasons") ||
-        !lifecycleKnowledgeText.includes("auditDesignImplementationTraceability") ||
-        !lifecycleKnowledgeText.includes("assessControlledGenerationChain")) {
-        hardFail("RELEASE_ISSUE_UNIFIED_LIFECYCLE_KNOWLEDGE_CONTRACT_MISSING", "生命周期、项目知识选择和证据消费仍未收口到统一决策合同", ["src/engine/lifecycle_knowledge_contract.ts"], "problem-62/problem-73/project-knowledge-control-plane", "三个并行机制会导致 next/expand/verify/deliver 各自新增局部口径", "建立并强制消费 evaluateLifecycleKnowledgeDecision");
-    }
-    const injectionBoundaryText = safeRead(path.join(rootDir, "src", "engine", "knowledge_injection_boundary.ts")) ?? "";
-    if (injectionBoundaryText.includes("buildTemplateAssetContracts(process.cwd())")) {
-        hardFail("RELEASE_ISSUE_KNOWLEDGE_CONTRACT_CWD_DRIFT", "知识注入边界仍用 process.cwd() 读取模板合同", ["src/engine/knowledge_injection_boundary.ts"], "project-knowledge-consumption", "用户项目、全局安装和测试目录会取错合同根目录", "改为从模块根或显式合同根读取模板合同");
-    }
-    if (!cliText.includes("cmdAuditDesignArtifacts") ||
-        !cliText.includes("cmdUpgradeDesignArtifacts") ||
-        !cliText.includes("currentTask?.design_artifact_pack")) {
-        hardFail("RELEASE_ISSUE_USER_CLI_MISSING", "问题六十二缺少用户 CLI 审计/升级或 Claude Code 写入 hook 阻断路径", ["src/bin/soloforge.ts"], "problem-62", "MCP 内部调用不能覆盖用户现有文档升级与直接 Edit/Write 路径", "接入 audit/upgrade CLI 与 check-write 设计产物门");
-    }
-    // 标准资产覆盖机制必须使用真实注册表审计
-    try {
-        const cov = await import(path.join(rootDir, "dist", "engine", "standard_asset_coverage.js"));
-        const car = await import(path.join(rootDir, "dist", "engine", "consumable_asset_registry.js"));
-        const manifest = await import(path.join(rootDir, "dist", "engine", "asset_manifest.js"));
-        // 从真实注册表构建消费证据
-        const registeredAssets = car.listBuiltinConsumableAssets();
-        const consumablePaths = new Set(registeredAssets.map((a) => a.path));
-        const ownerMap = new Map(registeredAssets.map((a) => [a.path, a.owner_mechanism_id ?? ""]));
-        const manifestEntries = manifest.ASSET_MANIFEST;
-        const consumerMap = new Map(manifestEntries.map((e) => [e.path, []]));
-        const visibilityMap = new Map(manifestEntries.map((e) => [e.path, e.consumption_mode ?? "unknown"]));
-        const report = cov.auditStandardAssetCoverage(rootDir, consumablePaths, ownerMap, consumerMap, visibilityMap);
-        // 必须能审计并返回结构化报告
-        if (typeof report.total_assets !== "number" || typeof report.covered_assets !== "number") {
-            hardFail("RELEASE_ISSUE_COVERAGE_REPORT_INVALID", "问题六十二覆盖审计报告结构不完整", ["src/engine/standard_asset_coverage.ts"], "problem-62", "审计报告缺少必须字段", "修复 auditStandardAssetCoverage 返回结构");
-        }
-        // 不得传空 Set/空 Map 通过覆盖检查 — 必须使用真实数据
-        if (report.total_assets > 0 && report.covered_assets === report.total_assets && consumablePaths.size === 0) {
-            hardFail("RELEASE_ISSUE_COVERAGE_EMPTY_REGISTRY_PASS", "问题六十二空注册表不应全部覆盖", ["src/engine/standard_asset_coverage.ts"], "problem-62", "空注册表时所有资产必须 uncovered", "修复覆盖检查使用真实注册表");
-        }
-    }
-    catch (error) {
-        hardFail("RELEASE_ISSUE_COVERAGE_LOAD_FAILED", `无法执行问题六十二覆盖审计行为复验: ${error?.message ?? error}`, ["src/engine/standard_asset_coverage.ts"], "problem-62", "模块不可执行", "修复构建或导出");
-    }
-    try {
-        const workshop = await import(path.join(rootDir, "dist", "engine", "architecture_decision_workshop.js"));
-        const designPack = await import(path.join(rootDir, "dist", "engine", "design_artifact_pack.js"));
-        const lifecycle = await import(path.join(rootDir, "dist", "engine", "design_lifecycle_contract.js"));
-        const lifecycleFindings = lifecycle.validateDesignLifecycleContract();
-        if (lifecycleFindings.length > 0) {
-            hardFail("RELEASE_ISSUE_DESIGN_LIFECYCLE_CONTRACT_INVALID", `设计生命周期合同不满足不变量: ${lifecycleFindings.map((finding) => finding.code).join(",")}`, ["src/engine/design_lifecycle_contract.ts"], "problem-62/problem-73", "生命周期合同必须明确设计、实现、测试、验收节点的输入输出和门禁", "修复 validateDesignLifecycleContract 报告的不变量缺口");
-        }
-        const detailStage = lifecycle.getDesignLifecycleStageContract("detail_design");
-        const detailRequiredOutputs = detailStage.outputs.filter((artifact) => artifact.required).map((artifact) => artifact.path);
-        if (!detailRequiredOutputs.includes("docs/architecture/02-数据库设计文档.md") ||
-            !detailRequiredOutputs.includes("docs/architecture/03-API接口规格文档.md") ||
-            detailRequiredOutputs.includes("docs/architecture/04-详细设计文档.md")) {
-            hardFail("RELEASE_ISSUE_DETAIL_DESIGN_TOPOLOGY_INVALID", "详细设计阶段输出拓扑错误", ["src/engine/design_lifecycle_contract.ts"], "problem-62/problem-73", "详细设计必需载体是数据库设计和 API 规格，04-详细设计文档只能是可选兼容", "修复 detail_design 生命周期合同");
-        }
-        const lifecyclePaths = lifecycle.getDesignLifecycleArtifactPaths();
-        if (lifecyclePaths.slice_plan !== "docs/architecture/04-开发切片计划.md") {
-            hardFail("RELEASE_ISSUE_SLICE_PLAN_CANONICAL_PATH_INVALID", "开发切片计划仍绑定到固定阶段文件", ["src/engine/design_lifecycle_contract.ts"], "problem-62/problem-73", "切片计划是全项目调度权威资产，不能命名成第一阶段", "将 canonical slice_plan 改为 docs/architecture/04-开发切片计划.md，旧第一阶段文件仅作为 alias");
-        }
-        const packPaths = designPack.defaultDesignArtifactPaths();
-        if (JSON.stringify(lifecyclePaths) !== JSON.stringify(packPaths)) {
-            hardFail("RELEASE_ISSUE_DESIGN_PACK_PATH_DRIFT", "设计产物包路径与生命周期合同漂移", ["src/engine/design_lifecycle_contract.ts", "src/engine/design_artifact_pack.ts"], "problem-62/problem-73", "设计产物包不得独立硬编码另一套输入输出路径", "让 defaultDesignArtifactPaths 从 getDesignLifecycleArtifactPaths 派生");
-        }
-        const draft = workshop.createArchitectureDecisionWorkshop("release-issue", "new_system");
-        if (workshop.evaluateArchitectureDecisionWorkshop(draft).allowed) {
-            hardFail("RELEASE_ISSUE_BEHAVIOR_FALSE_PASS", "问题六十一未确认六域的草稿错误放行", ["src/engine/architecture_decision_workshop.ts"], "problem-61", "必须有负向行为证据", "修复研讨生成门");
-        }
-        const missingPackResult = designPack.verifyDesignArtifactPack(rootDir, designPack.createDesignArtifactPack("release-issue"));
-        if (missingPackResult.passed) {
-            hardFail("RELEASE_ISSUE_BEHAVIOR_FALSE_PASS", "问题六十二缺少用户项目设计产物时错误放行", ["src/engine/design_artifact_pack.ts"], "problem-62", "必须读取真实资产并阻断缺失", "修复设计产物复验门");
-        }
-        const traceability = await import(path.join(rootDir, "dist", "engine", "traceability.js"));
-        const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "sf-trace-gate-"));
-        const write = (relativePath, content) => {
-            const target = path.join(tmp, relativePath);
-            fs.mkdirSync(path.dirname(target), { recursive: true });
-            fs.writeFileSync(target, content);
-        };
-        write("docs/architecture/01-架构设计文档.md", "# 架构\n来源: REQ-001, PROTO-001\nARCH-001");
-        const missingTrace = traceability.auditDesignImplementationTraceability(tmp);
-        if (missingTrace.passed || !missingTrace.findings.some((f) => f.code === "TRACEABILITY_MATRIX_MISSING")) {
-            hardFail("RELEASE_ISSUE_TRACEABILITY_MATRIX_FALSE_PASS", "问题七十三缺少追踪矩阵时错误放行", ["src/engine/traceability.ts", "src/engine/design_artifact_pack.ts"], "problem-73", "设计产物存在但无追踪矩阵必须阻断", "修复 auditDesignImplementationTraceability");
-        }
-        write("docs/traceability/01-需求原型设计实现追踪矩阵.md", [
-            "# 需求原型设计实现追踪矩阵",
-            "| 需求 | 原型 | 架构 | 详细设计 | 切片 | 验收 |",
-            "| --- | --- | --- | --- | --- | --- |",
-            "| REQ-001 | PROTO-001 | ARCH-001 | DD-T001, DD-A001 | PHASE-001, SLICE-001 | AC-001 |",
-        ].join("\n"));
-        write("docs/architecture/02-数据库设计文档.md", "# 数据库设计\nARCH-001 -> DD-T001");
-        write("docs/architecture/03-API接口规格文档.md", "# API 设计\nARCH-001 -> DD-A001");
-        write("docs/architecture/04-开发切片计划.md", "# 开发切片计划\nPHASE-001\nSLICE-001\n来源 DD-T001, DD-A001\n验收 AC-001");
-        const bindingFail = traceability.verifyChangedFilesAgainstDesignTraceability(tmp, ["src/main/java/demo/BedService.java"], {
-            task_id: "trace-gate",
-            created_at: new Date().toISOString(),
-            intent: "实现资源管理",
-            product_profile: "default",
-            status: "executing",
-        });
-        if (bindingFail.passed || !bindingFail.findings.some((f) => f.code === "TRACEABILITY_CODE_BINDING_MISSING")) {
-            hardFail("RELEASE_ISSUE_TRACEABILITY_CODE_BINDING_FALSE_PASS", "问题七十三编码缺少 PHASE/SLICE/DD/AC 绑定时错误放行", ["src/engine/traceability.ts", "src/adapters/claude_code/tools.ts"], "problem-73", "实现代码必须能追溯到详细设计、切片和验收", "修复 sf_expand/sf_verify 追踪绑定门");
-        }
-        const bindingPass = traceability.verifyChangedFilesAgainstDesignTraceability(tmp, ["src/main/java/demo/BedService.java"], {
-            task_id: "trace-gate-ok",
-            created_at: new Date().toISOString(),
-            intent: "实现资源管理 PHASE-001 SLICE-001 DD-T001 DD-A001 AC-001",
-            product_profile: "default",
-            status: "executing",
-        });
-        if (!bindingPass.passed) {
-            hardFail("RELEASE_ISSUE_TRACEABILITY_CODE_BINDING_FALSE_BLOCK", "问题七十三合法 PHASE/SLICE/DD/AC 绑定被错误阻断", ["src/engine/traceability.ts"], "problem-73", "合法追踪绑定应允许编码验证继续", "修复 traceability binding 校验");
-        }
-    }
-    catch (error) {
-        hardFail("RELEASE_ISSUE_MODULE_LOAD_FAILED", `无法执行 发布问题行为复验: ${error?.message ?? error}`, ["src/engine/architecture_decision_workshop.ts", "src/engine/design_artifact_pack.ts", "src/engine/traceability.ts"], "发布问题", "模块不可执行", "修复构建或导出");
-    }
-    if (!workflowText.includes("wf-architecture-workshop-first") || !workflowText.includes("wf-design-artifact-pack")) {
-        hardFail("RELEASE_ISSUE_USER_INJECTION_MISSING", "用户项目工作流模板未注入 发布问题硬协议", ["src/adapters/shared/workflow_template.ts"], "problem-61/problem-62", "运行时有门但用户不可预期会造成体验断裂", "向 workflow template 注入硬规则");
-    }
-    // workflow_template @sf-hard-rule 机制 ID 必须能解析到权威机制注册条目且资产文件存在
-    try {
-        const { validateWorkflowRuleSources } = await import("../adapters/shared/workflow_template.js");
-        const wfValidation = validateWorkflowRuleSources(rootDir);
-        if (!wfValidation.valid) {
-            if (wfValidation.missing_mechanisms.length > 0) {
-                hardFail("RELEASE_ISSUE_WF_RULE_MISSING_MECHANISM", `工作流模板引用了未注册的机制: ${wfValidation.missing_mechanisms.join(", ")}`, ["src/adapters/shared/workflow_template.ts"], "发布问题", "硬编码规则与权威机制注册表漂移", "在 dual_layer_mechanism_registry 中注册缺失机制或修正 workflow_template 引用");
-            }
-            if (wfValidation.missing_assets.length > 0) {
-                hardFail("RELEASE_ISSUE_WF_RULE_MISSING_ASSET", `工作流模板规则的权威资产文件缺失: ${wfValidation.missing_assets.join(", ")}`, ["src/adapters/shared/workflow_template.ts"], "发布问题", "权威规则资产文件不存在", "恢复缺失的模板文件或修正注册表路径");
-            }
-            if (wfValidation.checksum_mismatch) {
-                hardFail("RELEASE_ISSUE_WF_RULE_CONTENT_DRIFT", `工作流模板权威规则内容校验和不匹配: 嵌入=${wfValidation.embedded_checksum}, 实际=${wfValidation.computed_checksum}`, ["src/adapters/shared/workflow_template.ts"], "发布问题", "权威规则资产内容已变化但工作流模板未同步", "运行 updateEmbeddedChecksum 或重新生成工作流模板");
-            }
-        }
-    }
-    catch (error) {
-        hardFail("RELEASE_ISSUE_WF_RULE_VALIDATION_FAILED", `工作流规则来源校验失败: ${error?.message ?? error}`, ["src/adapters/shared/workflow_template.ts"], "发布问题", "校验函数不可执行", "修复 validateWorkflowRuleSources 导出");
-    }
-    // ══ 问题六十三: 标准资产契约 ══
-    const sacText = safeRead(path.join(rootDir, "src", "engine", "standard_asset_contract.ts")) ?? "";
-    if (!sourceContainsIdentifier(sacText, "matchTemplateContract") || !sourceContainsIdentifier(sacText, "verifyOutputAgainstContract") || !sourceContainsIdentifier(sacText, "createRepairReverifyDirective")) {
-        hardFail("RELEASE_ISSUE_CONTRACT_MISSING", "问题六十三缺少模板契约匹配、产物验证或修复重验函数", ["src/engine/standard_asset_contract.ts"], "problem-63", "缺少核心函数不能实现契约验证", "实现 matchTemplateContract / verifyOutputAgainstContract / createRepairReverifyDirective");
-    }
-    // sf_verify 必须按文件逐一匹配契约（不得使用 changed_files[0] 的契约校验全部文件）
-    if (!sourceContainsIdentifier(toolsText, "lazyStandardAssetContract") || !sourceContainsIdentifier(toolsText, "TOOL_DIAGNOSTIC_CODES.contractDraft") || !sourceContainsIdentifier(toolsText, "repair_reverify_directive")) {
-        hardFail("RELEASE_ISSUE_CONTRACT_MAINLINE_MISSING", "问题六十三未接入 sf_verify 模板契约验证和 sf_deliver 修复重验阻断", ["src/adapters/claude_code/tools.ts"], "problem-63", "仅有契约定义不能阻断交付", "在 sf_verify 消费模板契约验证、sf_deliver 消费修复重验阻断");
-    }
-    // 必须检查 per-file 匹配（不得 changed_files[0] 统一匹配）
-    if (sourceContainsPattern(toolsText, "file_path: args.changed_files?.[0]") && !sourceContainsIdentifier(toolsText, "file_path: changedFile")) {
-        hardFail("RELEASE_ISSUE_CONTRACT_SINGLE_FILE_MATCH", "问题六十三 sf_verify 仍使用 changed_files[0] 单一匹配", ["src/adapters/claude_code/tools.ts"], "problem-63", "一个契约不能校验所有文件", "改为按文件逐一匹配 matchTemplateContract");
-    }
-    // 草稿必须阻断（不得 continue 跳过）
-    if (!sourceContainsIdentifier(toolsText, "SF-CONTRACT-DRAFT")) {
-        hardFail("RELEASE_ISSUE_CONTRACT_DRAFT_SKIP", "问题六十三草稿文件未阻断下游消费", ["src/adapters/claude_code/tools.ts"], "problem-63", "草稿不得静默跳过", "草稿必须写入 blocked 状态并阻断");
-    }
-    try {
-        const sac = await import(path.join(rootDir, "dist", "engine", "standard_asset_contract.js"));
-        if (sac.matchTemplateContract({ file_path: "docs/architecture/01-架构设计文档.md" }) === null) {
-            hardFail("RELEASE_ISSUE_CONTRACT_MATCH_FAILURE", "问题六十三模板匹配失败：架构设计文档路径应匹配模板契约", ["src/engine/standard_asset_contract.ts"], "problem-63", "精确路径应匹配 P0 模板", "修复 matchTemplateContract 路径匹配逻辑");
-        }
-    }
-    catch (error) {
-        hardFail("RELEASE_ISSUE_CONTRACT_LOAD_FAILED", `无法执行问题六十三行为复验: ${error?.message ?? error}`, ["src/engine/standard_asset_contract.ts"], "problem-63", "模块不可执行", "修复构建或导出");
-    }
-    // ══ 问题六十四: 模板资产可见性 ══
-    const visText = safeRead(path.join(rootDir, "src", "engine", "template_asset_visibility.ts")) ?? "";
-    if (!visText.includes("isInherentlyInternal") || !visText.includes("inferVisibilityFromPath") || !visText.includes("filterSyncAssets")) {
-        hardFail("RELEASE_ISSUE_VISIBILITY_MISSING", "问题六十四缺少内部资产识别、可见性推断或同步过滤函数", ["src/engine/template_asset_visibility.ts"], "problem-64", "缺少核心函数不能实现可见性门禁", "实现 isInherentlyInternal / inferVisibilityFromPath / filterSyncAssets");
-    }
-    const syncText = safeRead(path.join(rootDir, "src", "engine", "template_init_sync.ts")) ?? "";
-    if (!cliText.includes("getContractDecision") && !syncText.includes("getContractDecision")) {
-        hardFail("RELEASE_ISSUE_VISIBILITY_SYNC_MISSING", "问题六十四 copyKnowledgeTemplates 未接入可见性门禁", ["src/engine/template_init_sync.ts"], "problem-64", "init/sync 不加门禁会泄漏内部资产到用户项目", "在 template_init_sync 中消费可见性门禁");
-    }
-    // copyKnowledgeTemplates 不得使用 subDirs 硬编码列表
-    if (cliText.includes("const subDirs = [")) {
-        hardFail("RELEASE_ISSUE_VISIBILITY_SUBDIRS_HARDCODE", "问题六十四 copyKnowledgeTemplates 仍使用 subDirs 硬编码列表", ["src/bin/soloforge.ts"], "problem-64", "硬编码 subDirs 无法覆盖新增目录", "改为递归发现并统一走可见性门禁");
-    }
-    // scaffolder 不得使用 process.cwd() 作为内置路径 fallback
-    const scaffolderText = safeRead(path.join(rootDir, "src", "engine", "scaffolder.ts")) ?? "";
-    if (scaffolderText.includes("process.cwd()")) {
-        hardFail("RELEASE_ISSUE_SCAFFOLDER_CWD_FALLBACK", "问题六十四 scaffolder 仍使用 process.cwd() 作为内置路径", ["src/engine/scaffolder.ts"], "problem-64", "process.cwd() 在 npm 安装场景解析错误", "改为 import.meta.dirname 解析包内路径");
-    }
-    try {
-        const vis = await import(path.join(rootDir, "dist", "engine", "template_asset_visibility.js"));
-        // 内部资产必须被识别
-        if (!vis.isInherentlyInternal("templates/knowledge/rules/演进回归规则.md")) {
-            hardFail("RELEASE_ISSUE_VISIBILITY_INTERNAL_MISS", "问题六十四内部资产识别失败：演进回归规则应被识别为内部资产", ["src/engine/template_asset_visibility.ts"], "problem-64", "denylist 不生效", "修复 isInherentlyInternal 逻辑");
-        }
-        // 用户可见资产不应被识别为内部
-        if (vis.isInherentlyInternal("templates/knowledge/acceptance_templates/架构设计模版.md")) {
-            hardFail("RELEASE_ISSUE_VISIBILITY_USER_MISS", "问题六十四用户项目资产误判为内部资产", ["src/engine/template_asset_visibility.ts"], "problem-64", "用户可见资产不应被过滤", "修复 isInherentlyInternal 逻辑");
-        }
-    }
-    catch (error) {
-        hardFail("RELEASE_ISSUE_VISIBILITY_LOAD_FAILED", `无法执行问题六十四行为复验: ${error?.message ?? error}`, ["src/engine/template_asset_visibility.ts"], "problem-64", "模块不可执行", "修复构建或导出");
-    }
-    // ══ 发布问题返修新增门禁 ══
-    // 问题六十一: sf_expand 不得使用不存在的 args.intent
-    {
-        const expandFnMatch = toolsText.match(/\/\/ 问题六十一[\s\S]*?matchDecisionPacks\(\{[^}]*\}\)/);
-        if (expandFnMatch && expandFnMatch[0].includes("args.intent")) {
-            hardFail("RELEASE_ISSUE_DECISION_ARGS_INTENT", "问题六十一 sf_expand 使用不存在的 args.intent 调用 matchDecisionPacks", ["src/adapters/claude_code/tools.ts"], "problem-61", "ExpandSchema 无 intent 字段，args.intent 永远 undefined", "改用 ctx.intent / ctx.classification / ctx.route_decision");
-        }
-    }
-    // 问题六十二: standard_asset_coverage 不得以注册存在替代复验路径
-    {
-        const sacCovText = safeRead(path.join(rootDir, "src", "engine", "standard_asset_coverage.ts")) ?? "";
-        if (sacCovText.includes("hasRevalidation = isRegistered") || sacCovText.includes("has_revalidation_path: isRegistered")) {
-            hardFail("RELEASE_ISSUE_COVERAGE_FAKE_REVALIDATION", "问题六十二 hasRevalidation=isRegistered 将注册等同于复验路径", ["src/engine/standard_asset_coverage.ts"], "problem-62", "注册存在不等于有复验入口", "必须从真实消费链路验证复验路径");
-        }
-        // 覆盖审计不得从 ASSET_MANIFEST 创建空 consumerMap
-        if (cliText.includes("ASSET_MANIFEST") && cliText.includes("[] as string[]") && cliText.includes("consumerMap")) {
-            hardFail("RELEASE_ISSUE_COVERAGE_EMPTY_CONSUMER", "问题六十二 audit-template-visibility 从 ASSET_MANIFEST 创建空 consumerMap", ["src/bin/soloforge.ts"], "problem-62", "空 consumerMap 导致所有资产 missing_consumer=0 假通过", "从权威合同获取真实消费者");
-        }
-        // 覆盖报告中有 uncovered/missing_consumer 时必须 hard_fail
-        // 消费者证据从逐资产运行时观察结果获取，不从合同声明字段复制
-        try {
-            const cov = await import(path.join(rootDir, "dist", "engine", "standard_asset_coverage.js"));
-            const car = await import(path.join(rootDir, "dist", "engine", "consumable_asset_registry.js"));
-            const contractReg = await import(path.join(rootDir, "dist", "engine", "template_asset_contract_registry.js"));
-            const obsMod = await import(path.join(rootDir, "dist", "engine", "observed_consumption.js"));
-            const registeredAssets = car.listBuiltinConsumableAssets();
-            const contracts = contractReg.listTemplateAssetContracts();
-            const consumablePaths = new Set(registeredAssets.map((a) => a.path));
-            const ownerMap = new Map(contracts.map((c) => [c.path, c.owner_mechanism_id]));
-            // 运行真实 scenario 生成消费 trace，然后构建消费者映射
-            const obsReport = await obsMod.observeAllConsumption(rootDir);
-            const consumerMap = new Map();
-            for (const obs of obsReport.observations) {
-                const consumers = consumerMap.get(obs.asset_path) ?? [];
-                // entry_point 即为真实消费入口
-                if (obs.entry_point && !consumers.includes(obs.entry_point)) {
-                    consumers.push(obs.entry_point);
-                }
-                consumerMap.set(obs.asset_path, consumers);
-            }
-            // 补充复验入口标识（与消费者证据不同维度，复验入口是审计/验证角色标识）
-            for (const c of contracts) {
-                const consumers = consumerMap.get(c.path) ?? [];
-                if (c.validation_entrypoint && !consumers.includes(c.validation_entrypoint)) {
-                    consumers.push(c.validation_entrypoint);
-                }
-                consumerMap.set(c.path, consumers);
-            }
-            const visibilityMap = new Map(contracts.map((c) => [c.path, c.asset_visibility ?? "unknown"]));
-            const report = cov.auditStandardAssetCoverage(rootDir, consumablePaths, ownerMap, consumerMap, visibilityMap);
-            if (report.uncovered_assets > 0) {
-                hardFail("RELEASE_ISSUE_COVERAGE_UNCOVERED", `问题六十二覆盖审计发现 ${report.uncovered_assets} 个未覆盖资产`, ["src/engine/standard_asset_coverage.ts", "src/engine/template_asset_contract_registry.ts"], "problem-62", "未覆盖资产不得通过发布门禁", "为每个资产建立真实消费证据");
-            }
-            if (report.missing_consumer > 0) {
-                hardFail("RELEASE_ISSUE_COVERAGE_MISSING_CONSUMER", `问题六十二覆盖审计发现 ${report.missing_consumer} 个资产缺少主链路消费者`, ["src/engine/standard_asset_coverage.ts", "src/engine/template_asset_contract_registry.ts"], "problem-62", "无消费者证据不得通过发布门禁", "为每个资产建立真实主链路消费者");
-            }
-            if (report.missing_revalidation > 0) {
-                hardFail("RELEASE_ISSUE_COVERAGE_MISSING_REVALIDATION", `问题六十二覆盖审计发现 ${report.missing_revalidation} 个资产缺少复验入口`, ["src/engine/standard_asset_coverage.ts", "src/engine/template_asset_contract_registry.ts"], "problem-62", "无复验入口不得通过发布门禁", "为每个资产建立真实复验入口");
-            }
-        }
-        catch (error) {
-            // template_asset_contract_registry 尚不存在 — 这是预期失败
-            hardFail("RELEASE_ISSUE_CONTRACT_REGISTRY_MISSING", `问题六十三权威合同注册表不存在: ${error?.message ?? error}`, ["src/engine/template_asset_contract_registry.ts"], "problem-63", "214 资产必须有权威合同", "创建 template_asset_contract_registry.ts");
-        }
-    }
-    // 问题六十三: templates 总数 = 权威合同覆盖数
-    {
-        const contractRegText = safeRead(path.join(rootDir, "src", "engine", "template_asset_contract_registry.ts")) ?? "";
-        if (!contractRegText.includes("TemplateAssetContract") || !contractRegText.includes("listTemplateAssetContracts")) {
-            hardFail("RELEASE_ISSUE_CONTRACT_REGISTRY_MISSING", "问题六十三缺少权威合同注册表（TemplateAssetContract / listTemplateAssetContracts）", ["src/engine/template_asset_contract_registry.ts"], "problem-63", "214 资产必须有单一权威元数据体系", "创建 template_asset_contract_registry.ts");
-        }
-    }
-    // 问题六十四: 可见性不得使用 denylist 猜测
-    {
-        const visText2 = safeRead(path.join(rootDir, "src", "engine", "template_asset_visibility.ts")) ?? "";
-        if (visText2.includes("INTERNAL_ASSET_PATTERNS")) {
-            hardFail("RELEASE_ISSUE_VISIBILITY_DENYLIST", "问题六十四 template_asset_visibility.ts 仍使用 INTERNAL_ASSET_PATTERNS denylist", ["src/engine/template_asset_visibility.ts"], "problem-64", "denylist 猜测不是权威分类", "改用权威合同注册表的 asset_visibility 字段");
-        }
-    }
-    // 问题六十四: 必须存在并执行真实技术栈受限资产，禁止以跳过或内存假资产代替。
-    {
-        const { buildTemplateAssetContracts } = await import("./template_asset_contract_registry.js");
-        const restrictedScaffolds = buildTemplateAssetContracts(rootDir).filter((contract) => contract.consume_category === "scaffold_only" && contract.applicable_tech_stack.length > 0);
-        if (restrictedScaffolds.length === 0) {
-            hardFail("RELEASE_ISSUE_TECH_STACK_ASSET_MISSING", "问题六十四不存在真实 applicable_tech_stack 脚手架资产", ["src/engine/explicit_asset_registry.ts"], "problem-64", "没有真实受限资产不能证明技术栈隔离", "为内置脚手架声明权威 applicable_tech_stack 并走 sf_scaffold 验证");
-        }
-        const scenarioTestText = safeRead(path.join(rootDir, "tests", "engine", "release_issue_scenario_matrix.test.ts")) ?? "";
-        const failClosedTestText = safeRead(path.join(rootDir, "tests", "engine", "contract_fail_closed.test.ts")) ?? "";
-        if (/it\.skip\([\s\S]{0,80}技术栈|test-java-rule/.test(`${scenarioTestText}\n${failClosedTestText}`)) {
-            hardFail("RELEASE_ISSUE_TECH_STACK_FAKE_TEST", "问题六十四仍以跳过测试或内存假资产代替真实技术栈复验", ["tests/engine/release_issue_scenario_matrix.test.ts", "tests/engine/contract_fail_closed.test.ts"], "problem-64", "假资产/skip 不证明用户实际链路", "仅使用 explicit_asset_registry 已登记资产执行真实 scaffold 场景");
-        }
-    }
-    // sf_accept 必须为需要显式授权的验收入口，且处理器不得直接篡改产物状态。
-    {
-        const contractText = safeRead(path.join(rootDir, "src", "engine", "tool_invocation_contract_registry.ts")) ?? "";
-        const acceptStart = toolsText.indexOf('registerSafeTool(\n    "sf_accept"');
-        const deliverStart = toolsText.indexOf('registerSafeTool(\n    "sf_deliver"', acceptStart + 1);
-        const acceptBody = toolsText.substring(acceptStart, deliverStart > 0 ? deliverStart : toolsText.length);
-        const contractStrict = /tool_name:\s*"sf_accept"[\s\S]{0,120}category:\s*"strict_controlled"[\s\S]{0,120}requires_authorization:\s*true/.test(contractText);
-        const confirmsEvidence = acceptBody.includes("confirmation_ref") && acceptBody.includes("confirmed_by") && acceptBody.includes("updateArtifactStatus");
-        const directStatusWrite = /artifact_output\.status\s*=\s*"accepted"/.test(acceptBody);
-        if (!contractStrict || !confirmsEvidence || directStatusWrite) {
-            hardFail("RELEASE_ISSUE_ACCEPTANCE_SELF_ATTESTATION", "sf_accept 仍可缺少显式确认或绕过 artifact 生命周期", ["src/adapters/claude_code/tools.ts", "src/engine/tool_invocation_contract_registry.ts"], "problem-63", "自动生成的验收证据不得放行正式产物", "要求显式确认引用并只通过 updateArtifactStatus 接受产物");
-        }
-    }
-    // 问题五十九: 新增 CLI 命令不得使用 console.log
-    {
-        const auditFnStart = cliText.indexOf("async function cmdAuditTemplateVisibility");
-        const nextFnStart = cliText.indexOf("\nasync function ", auditFnStart + 1);
-        const fnBody = cliText.substring(auditFnStart, nextFnStart > 0 ? nextFnStart : cliText.length);
-        if (fnBody.includes("console.log")) {
-            hardFail("RELEASE_ISSUE_LOGGER_VIOLATION", "问题五十九 cmdAuditTemplateVisibility 使用 console.log 违反日志治理", ["src/bin/soloforge.ts"], "problem-59", "新增代码必须使用统一 logger", "替换 console.log 为 userInfo/userJson");
-        }
-    }
-    // 问题六十二/六十三: 逐资产运行时消费证据 — 不得接受"consumer file exists"或"export name exists"作为真实消费证明
-    {
-        const { observeAllConsumption } = await import("./observed_consumption.js");
-        const report = await observeAllConsumption(rootDir);
-        if (report.fail > 0) {
-            hardFail("RELEASE_ISSUE_CONSUMPTION_EVIDENCE_FAIL", `问题六十二逐资产消费证据验证失败(${report.fail} failures): ${report.failures.join("; ")}`, ["src/engine/observed_consumption.ts", "src/engine/template_asset_contract_registry.ts"], "problem-62", "逐资产运行时消费证据不完整", "检查 observeAllConsumption 中每个资产的观察结果");
-        }
-        if (report.total < 215) {
-            hardFail("RELEASE_ISSUE_CONSUMPTION_EVIDENCE_INCOMPLETE", `问题六十二消费证据仅覆盖 ${report.total} 个资产，预期至少 215`, ["src/engine/observed_consumption.ts"], "problem-62", "消费证据覆盖不全", "确保所有注册资产都有消费观察记录");
-        }
-        // trace 必须来自真实入口（init/sync_templates），不得仅来自 contract_gate 兜底
-        const traceCounts = report.trace_counts;
-        if ((traceCounts.init ?? 0) === 0 && (traceCounts.sync_templates ?? 0) === 0) {
-            hardFail("RELEASE_ISSUE_CONSUMPTION_EVIDENCE_NO_REAL_TRACE", "问题六十二消费证据无真实入口 trace（init/sync_templates 均为 0）", ["src/engine/observed_consumption.ts"], "problem-62", "必须运行真实入口 scenario 产生 trace", "检查 observeAllConsumption 中的 scenario runner");
-        }
-        // 硬检查: mainline trace 的 declared_consumer 必须与合同 mainline_consumer 精确匹配
-        for (const obs of report.observations) {
-            if (obs.consume_category === "mainline" && obs.validation_result === "fail" && obs.failure_reason?.includes("无精确消费 trace")) {
-                hardFail("RELEASE_ISSUE_MAINLINE_TRACE_MISMATCH", `mainline 资产消费 trace 不匹配: ${obs.failure_reason}`, ["src/engine/observed_consumption.ts", obs.asset_path], "problem-62", "mainline trace declared_consumer 必须与合同 mainline_consumer 精确对应", "确保生产函数记录 declared_consumer");
-            }
-        }
-    }
-    // 负向测试: scaffold_only 资产必须有 scaffold trace，删除 scaffold scenario 后必须 fail
-    {
-        const { buildTemplateAssetContracts } = await import("./template_asset_contract_registry.js");
-        const { getConsumptionTraces, clearConsumptionTraces, recordConsumptionTrace } = await import("./consumption_trace_store.js");
-        clearConsumptionTraces();
-        // 只运行 init+sync（不运行 scaffold），scaffold_only 资产应无合法 trace
-        const { copyKnowledgeToProject, copyPatternsToGlobal } = await import("./template_init_sync.js");
-        const tmpNegDir = fs.mkdtempSync(path.join(os.tmpdir(), "soloforge-neg-"));
-        try {
-            await copyKnowledgeToProject(rootDir, tmpNegDir);
-            const globalDir = path.join(tmpNegDir, ".soloforge", "patterns");
-            await copyPatternsToGlobal(rootDir, globalDir);
-        }
-        finally {
-            fs.rmSync(tmpNegDir, { recursive: true, force: true });
-        }
-        // 收集 scaffold_only 合同，验证它们都没有 scaffold trace
-        const contracts = buildTemplateAssetContracts(rootDir);
-        const scaffoldContracts = contracts.filter(c => c.consume_category === "scaffold_only");
-        const traces = getConsumptionTraces();
-        const scaffoldTracedPaths = new Set(traces.filter(t => t.consumer === "scaffold").map(t => t.asset_path));
-        const scaffoldWithTrace = scaffoldContracts.filter(c => scaffoldTracedPaths.has(c.path));
-        if (scaffoldWithTrace.length > 0) {
-            hardFail("RELEASE_ISSUE_NEGATIVE_SCAFFOLD_LEAK", `负向测试失败: 未运行 scaffold scenario 但 ${scaffoldWithTrace.length} 个 scaffold_only 资产有 scaffold trace`, ["src/engine/observed_consumption.ts"], "problem-62", "scaffold trace 不应从其他 scenario 泄露", "检查 scaffold scenario 是否独立");
-        }
-        clearConsumptionTraces();
-    }
-    // 问题六十四: copyKnowledgeTemplates 必须对无合同资产 fail-closed
-    {
-        const copyFnSource = syncText || cliText;
-        const copyFnStart = copyFnSource.indexOf("async function copyKnowledge") !== -1
-            ? copyFnSource.indexOf("async function copyKnowledge")
-            : copyFnSource.indexOf("export async function copyKnowledgeToProject");
-        const copyFnEnd = copyFnSource.indexOf("\nasync function ", copyFnStart + 1);
-        const copyFnBody = copyFnSource.substring(copyFnStart, copyFnEnd > 0 ? copyFnEnd : copyFnSource.length);
-        // 必须有 "skipped_no_contract" 或 "unregistered" — 证明无合同时会跳过
-        if (!copyFnBody.includes("skipped_no_contract") && !copyFnBody.includes("unregistered")) {
-            hardFail("RELEASE_ISSUE_COPY_NO_CONTRACT_FAIL_OPEN", "问题六十四 copyKnowledgeTemplates 未对无合同资产 fail-closed", ["src/engine/template_init_sync.ts"], "problem-64", "无合同资产不应被复制", "添加 skipped_no_contract 计数并在无合同时 continue");
-        }
-    }
-}
-// ── 18. 代码可维护性与可观测性契约行为验证（问题六十八） ──
-async function checkCodeObservabilityBehavior(rootDir, hardFail, _info) {
-    const obsPath = path.join(rootDir, "dist", "engine", "code_maintainability_observability_contract.js");
-    if (!fs.existsSync(obsPath)) {
-        hardFail("CODE_OBSERVABILITY_MODULE_MISSING", "problem-68: code_maintainability_observability_contract.js 未编译到 dist/", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "发布门禁不检查问题-68 实现是否存在", "实现 code_maintainability_observability_contract 并编译");
-        return;
-    }
-    let obs;
-    try {
-        obs = await import(obsPath);
-    }
-    catch (e) {
-        hardFail("CODE_OBSERVABILITY_IMPORT_ERROR", `problem-68: code_maintainability_observability_contract 导入失败: ${e.message}`, ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "可观测性模块存在但不可导入", "修复导入错误");
-        return;
-    }
-    // 核心导出存在性
-    const requiredExports = ["reviewMissingLogs", "detectSensitiveLogs", "reviewCommentQuality", "hasBlockingObservabilityFindings", "requiresCodeObservabilityContract", "isLowRiskChange", "detectProjectLogger", "verifyChangedFilesObservability", "evaluateDeliveryBlock"];
-    for (const exp of requiredExports) {
-        if (typeof obs[exp] !== "function") {
-            hardFail("CODE_OBSERVABILITY_EXPORT_MISSING", `problem-68: code_maintainability_observability_contract.ts 缺少导出函数: ${exp}`, ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "可观测性模块缺少核心导出", `添加 ${exp} 导出`);
-        }
-    }
-    // 行为验证: 支付写操作无日志必须被检测
-    try {
-        const paymentFindings = obs.reviewMissingLogs({
-            "PaymentService.java": `public void refund(String orderId, BigDecimal amount) {
-  orderRepository.save(order);
-  paymentGateway.refund(orderId, amount);
-}`,
-        });
-        if (!obs.hasBlockingObservabilityFindings(paymentFindings)) {
-            hardFail("CODE_OBSERVABILITY_PAYMENT_FALSE_PASS", "problem-68: 支付写操作无日志未被检测到", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "文件存在不能证明审查能力有效", "修复 reviewMissingLogs 检测逻辑");
-        }
-        // 行为验证: catch 吞异常无日志必须被检测
-        const catchFindings = obs.reviewMissingLogs({
-            "OrderService.ts": `async processOrder(orderId: string) {
-  try {
-    await this.client.submit(orderId);
-  } catch (e) {
-    return false;
-  }
-}`,
-        });
-        if (!obs.hasBlockingObservabilityFindings(catchFindings)) {
-            hardFail("CODE_OBSERVABILITY_CATCH_FALSE_PASS", "problem-68: catch 吞异常无日志未被检测到", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "catch 吞异常必须产生阻断 finding", "修复 reviewMissingLogs 检测逻辑");
-        }
-        // 行为验证: 敏感信息日志泄漏必须被检测
-        const sensitiveFindings = obs.detectSensitiveLogs({
-            "UserService.ts": `function login(user) {
-  logger.info("user login", { token: "eyJhbGciOiJIUzI1NiJ9.xxxxx", password: user.password, phone: "13812345678" });
-}`,
-        });
-        if (!obs.hasBlockingObservabilityFindings(sensitiveFindings)) {
-            hardFail("CODE_OBSERVABILITY_SENSITIVE_FALSE_PASS", "problem-68: 敏感信息日志泄漏未被检测到", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "token/password/手机号泄漏必须被阻断", "修复 detectSensitiveLogs 检测逻辑");
-        }
-        // 行为验证: 低风险任务不应触发
-        const notTriggered = !obs.requiresCodeObservabilityContract("修复 README 错别字", "code_change");
-        if (!notTriggered) {
-            hardFail("CODE_OBSERVABILITY_LOW_RISK_OVERBLOCK", "problem-68: 低风险文案任务错误触发可观测性检查", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "低风险任务不应触发检查", "修复 requiresCodeObservabilityContract 判断逻辑");
-        }
-        // 行为验证: 项目 logger 类型检测
-        const javaLogger = obs.detectProjectLogger({
-            "Application.java": "import org.slf4j.LoggerFactory; private static final Logger log = LoggerFactory.getLogger(App.class);",
-        });
-        if (javaLogger.type !== "slf4j") {
-            hardFail("CODE_OBSERVABILITY_LOGGER_DETECT_FAIL", `problem-68: SLF4J logger 未被正确识别 (got: ${javaLogger.type})`, ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "项目 logger 类型检测必须准确", "修复 detectProjectLogger 逻辑");
-        }
-        // 行为验证: 迁移脚本无审计日志必须被检测
-        const migrationFindings = obs.reviewMissingLogs({
-            "scripts/data_fix_order_status.ts": `async function migrateOrderStatus() {
-  const orders = await db.query("SELECT * FROM orders WHERE status IS NULL");
-  for (const order of orders) {
-    await db.update("UPDATE orders SET status = 'pending' WHERE id = ?", [order.id]);
-  }
-}`,
-        });
-        if (!obs.hasBlockingObservabilityFindings(migrationFindings)) {
-            hardFail("CODE_OBSERVABILITY_MIGRATION_FALSE_PASS", "problem-68: 迁移脚本无审计日志未被检测到", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "数据修复脚本必须有审计日志", "修复 reviewMissingLogs 迁移脚本检测逻辑");
-        }
-        // 行为验证: 普通 Spring 后端 Slice 的 CRUD/事务双写无日志无注释也必须被检测。
-        const smartCareSliceFindings = obs.verifyChangedFilesObservability({
-            changed_files: ["src/main/java/com/demoapp/account/service/impl/AccountServiceImpl.java"],
-            file_contents: {
-                "src/main/java/com/demoapp/account/service/impl/AccountServiceImpl.java": `@Service
-public class AccountServiceImpl implements AccountService {
-  @Transactional
-  public AccountVO create(AccountCreateRequest request) {
-    Account account = convert(request);
-    accountMapper.insert(account);
-    SysUser user = buildUser(request);
-    sysUserMapper.insert(user);
-    return toVO(account);
-  }
-  @Transactional
-  public void resign(Long accountId) {
-    accountMapper.updateStatus(accountId, AccountStatus.RESIGNED);
-    sysUserMapper.updateAccountStatus(accountId, 0);
-  }
-}`,
-            },
-            intent: "完成 Slice 2 资源目录与账号管理后端实现",
-        });
-        const smartCareBlocked = smartCareSliceFindings.some((f) => f.category === "missing_log_business_write" && f.severity === "hard_fail")
-            && smartCareSliceFindings.some((f) => f.category === "missing_comment_complex");
-        if (!smartCareBlocked) {
-            hardFail("CODE_OBSERVABILITY_BACKEND_SLICE_FALSE_PASS", "problem-68: 普通后端 Slice 的 Controller/Service 事务双写和级联规则无日志无注释未被阻断", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "旧门禁只覆盖支付/安全/迁移，真实 CRUD 后端实现仍可无日志无注释通过", "扩展后端实现文件检测，覆盖 Controller/Service/DTO/Entity");
-        }
-        const javaDocAndChineseFindings = obs.verifyChangedFilesObservability({
-            changed_files: ["src/main/java/com/demoapp/account/service/impl/AccountServiceImpl.java"],
-            file_contents: {
-                "src/main/java/com/demoapp/account/service/impl/AccountServiceImpl.java": `@Service
-public class AccountServiceImpl implements AccountService {
-  public AccountVO create(AccountCreateRequest request) {
-    Account account = convert(request);
-    accountMapper.insert(account);
-    logger.info("account created accountId=" + account.getId());
-    return toVO(account);
-  }
-}`,
-            },
-            intent: "完成 Slice 2 账号管理后端实现",
-        });
-        const javaDocAndChineseBlocked = ["missing_class_doc", "missing_method_doc", "missing_important_line_comment", "non_chinese_log"].every((category) => javaDocAndChineseFindings.some((f) => f.category === category && f.severity === "hard_fail"));
-        if (!javaDocAndChineseBlocked) {
-            hardFail("CODE_OBSERVABILITY_CHINESE_DOC_CONTRACT_FALSE_PASS", "problem-68: 后端类/方法中文 Javadoc、关键行中文注释或中文日志缺失未被阻断", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "只检查是否有日志/注释会放过英文日志、无类说明、无方法入参出参说明和关键行业务意图缺失", "扩展 reviewCommentQuality/reviewMissingLogs，强制中文日志、中文注释、类 Javadoc、方法 Javadoc 和关键行注释");
-        }
-        const crossStackFindings = obs.verifyChangedFilesObservability({
-            changed_files: ["src/routes/account.route.ts", "app/api/account.py", "src/pages/AccountForm.tsx"],
-            file_contents: {
-                "src/routes/account.route.ts": `router.post('/account', async (req, res) => {
-  const account = await accountRepo.create(req.body);
-  await userRepo.create({ accountId: account.id });
-  res.json(account);
-});`,
-                "app/api/account.py": `@router.post("/account")
-async def create_account(payload: AccountCreate):
-    account = await account_repo.create(payload)
-    await user_repo.create(account_id=account.id)
-    return account`,
-                "src/pages/AccountForm.tsx": `export function AccountForm() {
-  async function handleSubmit(values) {
-    await apiClient.post('/api/tenant/users', values);
-    setStatus('created');
-  }
-  return <form onSubmit={handleSubmit}>...</form>;
-}`,
-            },
-            intent: "实现账号新增前后端接口与表单",
-        });
-        const crossStackBlocked = crossStackFindings.filter((f) => f.category === "missing_log_business_write" && f.severity === "hard_fail").length >= 3;
-        if (!crossStackBlocked) {
-            hardFail("CODE_OBSERVABILITY_CROSS_STACK_FALSE_PASS", "problem-68: 非 Spring 后端或前端业务写操作无日志/埋点未被阻断", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "问题六十八不能只覆盖 Spring 后端文件", "扩展检测到 Nest/Express/FastAPI/Go/React/Vue 等通用实现形态");
-        }
-    }
-    catch (e) {
-        hardFail("CODE_OBSERVABILITY_EXECUTION_ERROR", `problem-68: 可观测性行为检查执行失败: ${e.message}`, ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "契约模块必须可运行并返回确定结果", "修复运行时异常");
-    }
-    // 主链路消费检查 — sf_verify 必须调用 verifyChangedFilesObservability
-    const toolsText = safeRead(path.join(rootDir, "src", "adapters", "claude_code", "tools.ts")) ?? "";
-    const requiredHooks = [
-        "lazyCodeObservability", "reviewCodeObservability",
-        "hasBlockingObservabilityFindings", "requiresCodeObservabilityContract",
-        "evaluateCodeObservabilityGate", "evaluateDeliveryBlock",
-        "verifyChangedFilesObservability",
-    ];
-    for (const hook of requiredHooks) {
-        if (!toolsText.includes(hook)) {
-            hardFail("CODE_OBSERVABILITY_MAINPATH_MISSING", `problem-68: MCP 主链路缺少真实消费点 ${hook}`, ["src/adapters/claude_code/tools.ts"], "problem-68", "只实现引擎函数不能证明用户路径受约束", "接入 sf_expand/sf_review/sf_verify/sf_deliver");
-        }
-    }
-    // 行为验证: sf_verify 必须真实消费 verifyChangedFilesObservability — 编译后检查
-    try {
-        const toolsJsPath = path.join(rootDir, "dist", "adapters", "claude_code", "tools.js");
-        if (fs.existsSync(toolsJsPath)) {
-            const toolsJs = safeRead(toolsJsPath) ?? "";
-            const hasObsVerifyCall = toolsJs.includes("codeObservabilityFinding")
-                && toolsJs.includes("verifyChangedFilesObservability");
-            if (!hasObsVerifyCall) {
-                hardFail("CODE_OBSERVABILITY_SF_VERIFY_NOT_CONSUMING", "problem-68: sf_verify 编译产物未包含可观测性诊断常量或 verifyChangedFilesObservability 调用", ["src/adapters/claude_code/tools.ts"], "problem-68", "字符串引用不能证明 sf_verify 真实消费可观测性检查", "在 sf_verify implementationFiles 分支中调用 verifyChangedFilesObservability 并处理结果");
-            }
-        }
-    }
-    catch {
-        // 编译产物不存在时由 build 门禁处理
-    }
-    // 行为验证: sf_verify 必须能阻断 — 敏感信息 + 支付写操作必须产生 hard_fail
-    try {
-        const mustFailFindings = obs.verifyChangedFilesObservability({
-            changed_files: ["PaymentService.ts"],
-            file_contents: {
-                "PaymentService.ts": `const api_key = "sk_live_abcdef123456";
-async function processPayment(order) { order.save(); }`,
-            },
-            intent: "添加支付退款日志和脱敏处理",
-        });
-        if (!obs.hasBlockingObservabilityFindings(mustFailFindings)) {
-            hardFail("CODE_OBSERVABILITY_VERIFY_MUST_FAIL_PASS", "problem-68: sf_verify 未对敏感信息泄漏+支付无日志场景产生阻断", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "verifyChangedFilesObservability 必须对支付敏感信息场景 hard_fail", "修复 verifyChangedFilesObservability 检测逻辑");
-        }
-        // sf_verify 必须允许合规代码通过
-        const mustPassFindings = obs.verifyChangedFilesObservability({
-            changed_files: ["RefundService.ts"],
-            file_contents: {
-                "RefundService.ts": `const logger = require('./logger');
-async function processRefund(orderId: string) {
-  await db.refund(orderId);
-  logger.info("退款成功 orderId=" + orderId);
-}`,
-            },
-            intent: "添加支付退款日志和脱敏处理",
-        });
-        if (obs.hasBlockingObservabilityFindings(mustPassFindings)) {
-            hardFail("CODE_OBSERVABILITY_VERIFY_FALSE_BLOCK", "problem-68: sf_verify 对合规代码错误阻断", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "合规代码不应被阻断", "修复 verifyChangedFilesObservability 检测逻辑");
-        }
-        // 行为验证: logger.info("退款成功") 无可定位字段必须 hard_fail
-        const unlocatableFailFindings = obs.verifyChangedFilesObservability({
-            changed_files: ["RefundService.ts"],
-            file_contents: {
-                "RefundService.ts": `const logger = require('./logger');
-async function refund(order) { order.save(); logger.info("退款成功"); }`,
-            },
-            intent: "添加支付退款日志和脱敏处理",
-        });
-        const unlocatableHardFails = unlocatableFailFindings.filter((f) => f.category === "unlocatable_log" && f.severity === "hard_fail");
-        if (unlocatableHardFails.length === 0) {
-            hardFail("CODE_OBSERVABILITY_UNLOCATABLE_LOG_PASS", "problem-68: logger.info('退款成功') 无可定位字段未被阻断", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "仅含事件词的日志不可通过支付写操作检查", "修复可定位字段判断逻辑");
-        }
-        // 行为验证: logger.info("退款成功 orderId=" + orderId) 必须通过
-        const unlocatablePassFindings = obs.verifyChangedFilesObservability({
-            changed_files: ["RefundService.ts"],
-            file_contents: {
-                "RefundService.ts": `const logger = require('./logger');
-async function refund(order) { order.save(); logger.info("退款成功 orderId=" + orderId); }`,
-            },
-            intent: "添加支付退款日志和脱敏处理",
-        });
-        const unlocatableBlockers = unlocatablePassFindings.filter((f) => f.category === "unlocatable_log" && f.severity === "hard_fail");
-        if (unlocatableBlockers.length > 0) {
-            hardFail("CODE_OBSERVABILITY_LOCATABLE_FALSE_BLOCK", "problem-68: logger.info('退款成功 orderId=...') 含可定位字段被错误阻断", ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "包含对象 ID 的日志不应被阻断", "修复可定位字段判断逻辑");
-        }
-    }
-    catch (e) {
-        hardFail("CODE_OBSERVABILITY_VERIFY_EXECUTION_ERROR", `problem-68: sf_verify 行为检查执行失败: ${e.message}`, ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "verifyChangedFilesObservability 必须可运行并返回确定结果", "修复运行时异常");
-    }
-    _info("  problem-68 代码可维护性与可观测性行为验证完成");
-}
-// ── 21. 模板卫生与用户项目知识消费验证 ──
-async function checkTemplateAndProjectKnowledgeHygiene(rootDir, hardFail, _info) {
-    try {
-        const matrix = await import(path.join(rootDir, "dist", "engine", "project_knowledge_system_regression_matrix.js"));
-        const report = matrix.validateProjectKnowledgeSystemMatrix?.();
-        if (!report?.passed) {
-            const messages = (report?.findings ?? []).map((finding) => `${finding.code}: ${finding.message}`).join("; ");
-            hardFail("PROJECT_KNOWLEDGE_SYSTEM_MATRIX_INCOMPLETE", `problem-69: 知识资产与项目规则消费体系 20 项防回归矩阵不完整: ${messages || "未知缺口"}`, ["src/engine/project_knowledge_system_regression_matrix.ts", "docs/SoloForge-Batch8问题集.md"], "problem-69", "旧门禁只检查部分项目知识行为，未覆盖用户讨论的 20 项完整细节", "补齐 20 项矩阵、生产入口、must-fail/must-pass 与文档引用");
-        }
-    }
-    catch (e) {
-        hardFail("PROJECT_KNOWLEDGE_SYSTEM_MATRIX_EXCEPTION", `problem-69: 知识资产与项目规则消费体系矩阵执行失败: ${e.message}`, ["src/engine/project_knowledge_system_regression_matrix.ts"], "problem-69", "项目知识体系矩阵必须可执行", "修复矩阵模块或编译产物");
-    }
-    const scaffoldDir = path.join(rootDir, "templates", "scaffolds");
-    const scaffoldFindings = [];
-    function scanScaffolds(dir) {
-        if (!fs.existsSync(dir))
-            return;
-        for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-            const full = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                scanScaffolds(full);
-                continue;
-            }
-            if (!entry.isFile())
-                continue;
-            const rel = path.relative(rootDir, full).replace(/\\/g, "/");
-            const lines = safeReadLines(full);
-            for (let i = 0; i < lines.length; i++) {
-                if (/\b(?:TODO|FIXME|HACK|XXX)\b/.test(lines[i])) {
-                    scaffoldFindings.push(`${rel}:${i + 1}`);
-                }
-            }
-        }
-    }
-    scanScaffolds(scaffoldDir);
-    for (const finding of scaffoldFindings) {
-        hardFail("TEMPLATE_SCAFFOLD_PLACEHOLDER_LEAK", `脚手架模板仍包含未落地占位标记: ${finding}`, [finding.split(":")[0]], "template-hygiene", "历史门禁只检查模板是否注册，不检查用户生成代码是否带 TODO/FIXME", "清理脚手架占位标记并补行为测试");
-    }
-    try {
-        const contractMod = await import(path.join(rootDir, "dist", "engine", "template_asset_contract_registry.js"));
-        const contracts = contractMod.listTemplateAssetContracts?.() ?? [];
-        const forbidden = /\b(?:Batch[1-8]|validate-batch|ReleaseFix|problem-\d+)\b/i;
-        for (const contract of contracts) {
-            if (!contract.user_visible)
-                continue;
-            if (!contract.path || !/\.(md|ya?ml|hbs|json)$/i.test(contract.path))
-                continue;
-            const abs = path.join(rootDir, contract.path);
-            const content = safeRead(abs);
-            if (!content || !forbidden.test(content))
-                continue;
-            hardFail("USER_VISIBLE_TEMPLATE_INTERNAL_TRACE", `用户可见模板泄漏内部施工语义: ${contract.path}`, [contract.path], "template-hygiene", "旧门禁只检查内置资产可见性，不检查用户可见模板内容是否混入内部批次/问题编号", "清理用户可见模板内部语义");
-        }
-    }
-    catch (e) {
-        hardFail("TEMPLATE_CONTRACT_AUDIT_FAILED", `无法执行用户可见模板内容审计: ${e.message}`, ["src/engine/template_asset_contract_registry.ts"], "template-hygiene", "模板内容卫生必须可运行审计", "修复模板合同注册表或编译产物");
-    }
-    try {
-        const obs = await import(path.join(rootDir, "dist", "engine", "code_maintainability_observability_contract.js"));
-        const ordinaryApiImplementationTriggers = obs.requiresCodeObservabilityContract?.("实现业务端业务办理列表接口", "code_change") === true;
-        if (!ordinaryApiImplementationTriggers) {
-            hardFail("CODE_OBSERVABILITY_BUSINESS_API_NOT_TRIGGERED", "problem-68: 普通业务接口实现未触发代码注释与日志契约，真实项目会绕过问题六十八", ["src/engine/code_maintainability_observability_contract.ts", "src/adapters/claude_code/tools.ts"], "problem-68", "旧行为只覆盖支付/安全等关键词，未覆盖普通 Controller/API/Service 编码", "扩展触发条件并在 sf_expand 聚合返回工作包");
-        }
-    }
-    catch (e) {
-        hardFail("CODE_OBSERVABILITY_TRIGGER_AUDIT_FAILED", `问题六十八触发审计执行失败: ${e.message}`, ["src/engine/code_maintainability_observability_contract.ts"], "problem-68", "触发判断必须可运行", "修复编译或导出");
-    }
-    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "soloforge-project-knowledge-"));
-    try {
-        const goodDir = path.join(tmp, ".soloforge", "knowledge", "rules");
-        fs.mkdirSync(goodDir, { recursive: true });
-        fs.writeFileSync(path.join(goodDir, "API响应规则.md"), `---
-id: demo-api-response-rule
-asset_kind: hard_rule
-routes:
-  - code_change
-  - artifact_generation
-primary_triggers:
-  - API
-  - 接口
-  - 响应
-tech_stack:
-  - spring
-enforcement:
-  level: hard_rule
----
-# API 响应规则
-
-必须使用项目统一响应结构，错误码、字段表和 OpenAPI 保持一致。
-`, "utf-8");
-        const projectKnowledge = await import(path.join(rootDir, "dist", "engine", "project_knowledge_contract.js"));
-        const lifecycleKnowledge = await import(path.join(rootDir, "dist", "engine", "lifecycle_knowledge_contract.js"));
-        const report = projectKnowledge.auditProjectKnowledge(tmp);
-        if (report.hard_fail_count !== 0 || report.injectable < 1) {
-            hardFail("PROJECT_KNOWLEDGE_RULE_NOT_CONSUMABLE", "用户项目 .soloforge/knowledge hard rule 未被识别为可消费规则", ["src/engine/project_knowledge_contract.ts"], "project-knowledge-consumption", "旧链路只同步/索引内置模板，未证明用户项目自定义规则可被承载消费", "修复项目知识合同审计与选择逻辑");
-        }
-        const selected = projectKnowledge.selectProjectKnowledgeForTaskWithReasons(report, {
-            intent: "实现业务端 API 接口统一响应",
-            route: "code_change",
-            tech_stack: ["spring"],
-        });
-        if (!selected.selected.some((decision) => decision.asset.id === "demo-api-response-rule")) {
-            hardFail("PROJECT_KNOWLEDGE_RULE_NOT_SELECTED", "用户项目自定义 hard rule 未按意图/路由/技术栈被选中", ["src/engine/project_knowledge_contract.ts"], "project-knowledge-consumption", "索引存在不等于任务会消费", "补齐 selectProjectKnowledgeForTask 行为和门禁");
-        }
-        const selection = projectKnowledge.selectProjectKnowledgeForTaskWithReasons(report, {
-            intent: "实现业务端 API 接口统一响应 PHASE-001 SLICE-001 DD-A001 AC-001",
-            route: "code_change",
-            tech_stack: ["spring"],
-            lifecycle_stage: "implementation",
-            changed_files: ["backend/web/src/main/java/com/example/web/tenant/TenantUserController.java"],
-            traceability_ids: ["PHASE-001", "SLICE-001", "DD-A001", "AC-001"],
-        });
-        const selectedDecision = selection.selected.find((decision) => decision.asset.id === "demo-api-response-rule");
-        if (!selectedDecision || !selectedDecision.reason_zh || !Array.isArray(selectedDecision.matched_signals)) {
-            hardFail("PROJECT_KNOWLEDGE_SELECTION_REASON_MISSING", "用户项目规则选择缺少 why selected / matched_signals 结构化解释", ["src/engine/project_knowledge_contract.ts", "src/engine/intent_expander.ts"], "project-knowledge-consumption", "用户不知道为什么规则被选中就无法判断必须确认和修复路径", "让项目知识选择返回 SelectionDecision 而不是裸资产");
-        }
-        const unifiedDecision = lifecycleKnowledge.evaluateLifecycleKnowledgeDecision({
-            projectPath: tmp,
-            consumer: "sf_expand",
-            intent: "实现业务端 API 接口统一响应 PHASE-001 SLICE-001 DD-A001 AC-001",
-            route: "code_change",
-            lifecycle_stage: "implementation",
-            changed_files: ["backend/web/src/main/java/com/example/web/tenant/TenantUserController.java"],
-            verified_files: ["backend/web/src/main/java/com/example/web/tenant/TenantUserController.java"],
-            traceability_ids: ["PHASE-001", "SLICE-001", "DD-A001", "AC-001"],
-            tech_stack: ["spring"],
-            generation_traces: [
-                { tool_name: "sf_classify", status: "passed", evidence_kind: "result" },
-                { tool_name: "sf_expand", status: "passed", evidence_kind: "result" },
-            ],
-            record_trace: true,
-        });
-        if (unifiedDecision.contract_id !== "lifecycle_knowledge_contract/v1" ||
-            !unifiedDecision.knowledge_selection.selected.some((decision) => decision.asset.id === "demo-api-response-rule") ||
-            !unifiedDecision.authoritative_paths.traceability_matrix ||
-            !Array.isArray(unifiedDecision.recovery_commands)) {
-            hardFail("LIFECYCLE_KNOWLEDGE_DECISION_BUNDLE_INVALID", "统一生命周期知识决策包未同时携带权威路径、SelectionDecision、恢复命令和消费 trace", ["src/engine/lifecycle_knowledge_contract.ts", "src/engine/project_knowledge_contract.ts"], "project-knowledge-consumption", "next/expand/verify/deliver 如果不消费同一决策包，会再次产生局部口径", "修复 evaluateLifecycleKnowledgeDecision 返回结构和入口消费");
-        }
-        const expander = await import(path.join(rootDir, "dist", "engine", "intent_expander.js"));
-        const expandResult = await expander.expand({
-            intent: "实现业务端 API 接口统一响应",
-            classification: {
-                task_type: "feature",
-                risk: "low",
-                complexity: "low",
-                ambiguity: "low",
-                affected_repos: ["backend"],
-                mode: "autonomous",
-                strategy: "full_pipeline",
-            },
-            projectPath: tmp,
-            config: {
-                name: "release-gate-project-knowledge",
-                tech_stack: {
-                    backend: { lang: "java", framework: "spring-boot", version: "3" },
-                    frontend: { lang: "typescript", framework: "react", version: "18" },
-                },
-                product_profile: "saas",
-                repos: [{ name: "backend", path: "backend", lang: "java", framework: "spring-boot", scope: ["backend/src/"] }],
-                build_commands: {
-                    backend: { build: "mvn compile", test: "mvn test", full: "mvn verify" },
-                    frontend: { build: "npm run build", test: "npm test", full: "npm test" },
-                },
-                scope: { backend: ["backend/src/"], frontend: ["src/"] },
-                _projectPath: tmp,
-            },
-            knowledgeIndex: { query: () => [], markUsed: () => { } },
-            route_decision: {
-                route: "code_change",
-                execution_shape: "code_execution",
-                mutation_allowed: true,
-                input_materials: [],
-                missing_required_inputs: [],
-                scope: { read_only: false },
-                constraints: [],
-                language_policy: { primary: "zh" },
-                confidence: 0.9,
-                evidence: [],
-                rejected_routes: [],
-                conflicts: [],
-                decision_version: 1,
-            },
-        });
-        if (!expandResult.project_knowledge?.selected?.some((asset) => asset.id === "demo-api-response-rule")
-            || !String(expandResult.prompt).includes("## 用户项目规则")
-            || !String(expandResult.prompt).includes("选中原因")
-            || !expandResult.project_knowledge?.selection_decisions?.some((decision) => decision.id === "demo-api-response-rule" && decision.reason_zh)) {
-            hardFail("PROJECT_KNOWLEDGE_NOT_IN_EXPAND_MAINPATH", "用户项目规则未进入 sf_expand 真实 prompt 和结构化结果", ["src/engine/intent_expander.ts", "src/engine/project_knowledge_contract.ts"], "project-knowledge-consumption", "审计/选择通过不等于 MCP 主链路会消费", "将项目规则接入 sf_expand 并补主链路测试");
-        }
-        const nextPlanner = await import(path.join(rootDir, "dist", "engine", "next_action_planner.js"));
-        const nextPlan = await nextPlanner.planNextAction(tmp);
-        if (!nextPlan.project_knowledge_context || nextPlan.project_knowledge_context.total < 1) {
-            hardFail("PROJECT_KNOWLEDGE_NOT_IN_NEXT", "soloforge next 未携带项目知识上下文，用户无法知道下一步会应用哪些项目规则", ["src/engine/next_action_planner.ts", "src/bin/soloforge.ts"], "project-knowledge-consumption", "旧导航只看阶段，不看项目规则", "将项目知识上下文接入 next JSON 和人类输出");
-        }
-        if (nextPlan.project_knowledge_context?.selected?.length
-            && !nextPlan.project_knowledge_context.selected.some((item) => item.reason_zh && item.enforcement)) {
-            hardFail("PROJECT_KNOWLEDGE_NEXT_REASON_MISSING", "soloforge next 项目规则上下文缺少选中原因或强制级别", ["src/engine/next_action_planner.ts", "src/bin/soloforge.ts"], "project-knowledge-consumption", "next 只列规则名不能支撑用户确认哪些必须满足", "在 next 中展示 SelectionDecision 的 reason/enforcement/verification");
-        }
-        const badTmp = fs.mkdtempSync(path.join(os.tmpdir(), "soloforge-project-knowledge-bad-"));
-        try {
-            const badDir = path.join(badTmp, ".soloforge", "knowledge", "rules");
-            fs.mkdirSync(badDir, { recursive: true });
-            fs.writeFileSync(path.join(badDir, "未路由强规则.md"), `---
-id: unrouted-hard-rule
-asset_kind: hard_rule
-enforcement:
-  level: hard_rule
----
-# 未路由强规则
-
-必须使用统一响应。
-`, "utf-8");
-            const badReport = projectKnowledge.auditProjectKnowledge(badTmp);
-            if (badReport.hard_fail_count === 0) {
-                hardFail("PROJECT_KNOWLEDGE_UNROUTED_RULE_FALSE_PASS", "用户项目 hard rule 缺少 routes/primary_triggers 时错误放行", ["src/engine/project_knowledge_contract.ts"], "project-knowledge-consumption", "规则文件存在不等于可稳定消费", "对未路由 hard rule fail-closed");
-            }
-        }
-        finally {
-            fs.rmSync(badTmp, { recursive: true, force: true });
-        }
-        const conflictTmp = fs.mkdtempSync(path.join(os.tmpdir(), "soloforge-project-knowledge-conflict-"));
-        try {
-            const conflictDir = path.join(conflictTmp, ".soloforge", "knowledge", "rules");
-            fs.mkdirSync(conflictDir, { recursive: true });
-            fs.writeFileSync(path.join(conflictDir, "响应A.md"), `---
-id: response-a
-asset_kind: hard_rule
-routes: [code_change]
-primary_triggers: [API]
-conflict_group: api_response_format
-rule_value: ApiResponse
-enforcement:
-  level: hard_rule
----
-# 响应 A
-
-必须使用 ApiResponse。
-`, "utf-8");
-            fs.writeFileSync(path.join(conflictDir, "响应B.md"), `---
-id: response-b
-asset_kind: hard_rule
-routes: [code_change]
-primary_triggers: [API]
-conflict_group: api_response_format
-rule_value: Result
-enforcement:
-  level: hard_rule
----
-# 响应 B
-
-必须使用 Result。
-`, "utf-8");
-            const conflictReport = projectKnowledge.auditProjectKnowledge(conflictTmp);
-            if (!conflictReport.assets.some((asset) => asset.findings.some((finding) => finding.code === "PROJECT_KNOWLEDGE_RULE_CONFLICT"))) {
-                hardFail("PROJECT_KNOWLEDGE_CONFLICT_FALSE_PASS", "项目 API 响应等规则冲突未进入用户确认", ["src/engine/project_knowledge_contract.ts"], "project-knowledge-consumption", "旧项目知识审计只看是否可选中，不看项目规则之间互斥", "补冲突组/显式 conflicts_with 检测");
-            }
-        }
-        finally {
-            fs.rmSync(conflictTmp, { recursive: true, force: true });
-        }
-        const semanticConflictTmp = fs.mkdtempSync(path.join(os.tmpdir(), "soloforge-project-knowledge-semantic-conflict-"));
-        try {
-            const semanticDir = path.join(semanticConflictTmp, ".soloforge", "knowledge", "rules");
-            fs.mkdirSync(semanticDir, { recursive: true });
-            fs.writeFileSync(path.join(semanticDir, "响应ApiResponse.md"), `---
-id: response-api-response
-asset_kind: hard_rule
-routes: [code_change]
-primary_triggers: [API响应]
-enforcement:
-  level: hard_rule
----
-# API 响应
-
-必须使用 ApiResponse。
-`, "utf-8");
-            fs.writeFileSync(path.join(semanticDir, "响应Result.md"), `---
-id: response-result
-asset_kind: hard_rule
-routes: [code_change]
-primary_triggers: [接口响应]
-enforcement:
-  level: hard_rule
----
-# 接口响应
-
-必须使用 Result。
-`, "utf-8");
-            const semanticConflictReport = projectKnowledge.auditProjectKnowledge(semanticConflictTmp);
-            if (!semanticConflictReport.assets.some((asset) => asset.findings.some((finding) => finding.code === "PROJECT_KNOWLEDGE_RULE_CONFLICT"))) {
-                hardFail("PROJECT_KNOWLEDGE_SEMANTIC_CONFLICT_FALSE_PASS", "API 响应格式语义冲突依赖手写 conflict_group，未自动进入用户确认", ["src/engine/project_knowledge_contract.ts"], "project-knowledge-consumption", "项目规则冲突不能要求用户预先正确标注才能发现", "补 API 响应/分页/日志/DB/权限语义冲突检测");
-            }
-        }
-        finally {
-            fs.rmSync(semanticConflictTmp, { recursive: true, force: true });
-        }
-    }
-    catch (e) {
-        hardFail("PROJECT_KNOWLEDGE_AUDIT_FAILED", `用户项目知识消费行为审计执行失败: ${e.message}`, ["src/engine/project_knowledge_contract.ts"], "project-knowledge-consumption", "项目知识消费必须有可执行行为门禁", "修复项目知识合同模块和编译产物");
-    }
-    finally {
-        fs.rmSync(tmp, { recursive: true, force: true });
-    }
-    _info("  模板卫生与项目知识消费验证完成");
-}
-async function checkLongTermMechanization(rootDir, hardFail, _info) {
-    try {
-        const matrix = await import("./historical_issue_mechanization_matrix.js");
-        const report = matrix.validateHistoricalIssueMechanizationMatrix?.();
-        if (!report?.passed) {
-            const messages = (report?.findings ?? []).map((finding) => `${finding.code}: ${finding.message}`).join("; ");
-            hardFail("HISTORICAL_FIRST_PRINCIPLES_MATRIX_INCOMPLETE", `历史问题第一性原理机制化矩阵不完整: ${messages || "未知缺口"}`, ["src/engine/historical_issue_mechanization_matrix.ts", "docs/SoloForge-Batch8问题集.md"], "problem-70", "旧复审只统计 mechanized/partial/not，不强制每个历史问题归入长期机制族", "补齐历史问题机制族、生产入口、must-fail/must-pass 和发布门禁");
-        }
-    }
-    catch (e) {
-        hardFail("HISTORICAL_FIRST_PRINCIPLES_MATRIX_EXCEPTION", `历史问题第一性原理矩阵检查异常: ${e.message}`, ["src/engine/historical_issue_mechanization_matrix.ts"], "problem-70", "旧 gate 不执行历史问题矩阵", "修复历史问题机制化矩阵模块");
-    }
-    try {
-        const health = await import("./mechanism_health_check.js");
-        const report = health.runFullHealthCheck(rootDir);
-        for (const finding of report.findings.filter((f) => f.severity === "hard_fail")) {
-            hardFail("LONGTERM_MECHANISM_HEALTH", finding.message_zh, [finding.target], "历史问题长期机制化", "旧 gate 不检查机制死代码/未消费资产", "修复机制消费链路");
-        }
-    }
-    catch (e) {
-        hardFail("LONGTERM_MECHANISM_HEALTH_EXCEPTION", `机制运行时健康度检查异常: ${e.message}`, ["src/engine/mechanism_health_check.ts"], "历史问题长期机制化", "旧 gate 不执行机制健康检查", "修复检查模块");
-    }
-    try {
-        const kg = await import("./knowledge_governance_gate.js");
-        const report = kg.runKnowledgeGovernanceCheck({
-            project_language: "zh",
-            contents: [{ id: "release-gate", domain: "user_feedback", content: "发布门禁保持中文语义优先" }],
-        });
-        if (report.hard_fail_count > 0) {
-            hardFail("LONGTERM_KNOWLEDGE_GOVERNANCE", `知识治理存在 ${report.hard_fail_count} 个 hard_fail`, ["src/engine/knowledge_governance_gate.ts"], "历史问题长期机制化", "旧 gate 只跑历史知识场景，不接统一治理入口", "修复知识治理检查");
-        }
-    }
-    catch (e) {
-        hardFail("LONGTERM_KNOWLEDGE_GOVERNANCE_EXCEPTION", `知识治理检查异常: ${e.message}`, ["src/engine/knowledge_governance_gate.ts"], "历史问题长期机制化", "旧 gate 不执行知识治理入口", "修复检查模块");
-    }
-    try {
-        const logGov = await import("./log_governance.js");
-        const clean = logGov.enforceLogGovernance("用户可见输出保持中文且无内部噪音");
-        const noisy = logGov.enforceLogGovernance("[soloForge] internal trace validate-release");
-        if (!clean.passed || noisy.passed) {
-            hardFail("LONGTERM_LOG_GOVERNANCE_BEHAVIOR", "日志治理 must-pass/must-fail 行为不成立", ["src/engine/log_governance.ts"], "历史问题长期机制化", "旧 gate 只扫描 console，不验证输出治理行为", "修复 log_governance 行为");
-        }
-    }
-    catch (e) {
-        hardFail("LONGTERM_LOG_GOVERNANCE_EXCEPTION", `日志治理检查异常: ${e.message}`, ["src/engine/log_governance.ts"], "历史问题长期机制化", "旧 gate 不执行日志治理入口", "修复检查模块");
-    }
-    try {
-        const cfg = await import("./config_write_boundary.js");
-        const runtimeCtx = cfg.classifyConfigContext(rootDir, { runtime_inference: true });
-        const runtimeDecision = cfg.isWriteAllowed(runtimeCtx, path.join(rootDir, ".soloforge", "config.yaml"));
-        const greenfieldDecision = cfg.isWriteAllowed({ kind: "greenfield", project_path: rootDir, evidence: ["empty_project"], confirmed: false }, path.join(rootDir, ".soloforge", "config.yaml"));
-        if (runtimeDecision.allowed || !greenfieldDecision.allowed) {
-            hardFail("LONGTERM_CONFIG_BOUNDARY_BEHAVIOR", "配置落盘边界 must-pass/must-fail 行为不成立", ["src/engine/config_write_boundary.ts"], "历史问题长期机制化", "旧 gate 不区分运行时推断与空项目写入", "修复配置写入边界");
-        }
-    }
-    catch (e) {
-        hardFail("LONGTERM_CONFIG_BOUNDARY_EXCEPTION", `配置落盘边界检查异常: ${e.message}`, ["src/engine/config_write_boundary.ts"], "历史问题长期机制化", "旧 gate 不执行配置落盘边界", "修复检查模块");
-    }
-    _info("  历史问题长期机制化行为验证完成");
-}
-async function checkDiagnosticCentralization(rootDir, hardFail) {
-    const toolsPath = path.join(rootDir, "src", "adapters", "claude_code", "tools.ts");
-    const toolsText = safeRead(toolsPath) ?? "";
-    const literalMatches = [...toolsText.matchAll(/["'`]SF-[A-Z]+-\d{4}["'`]/g)];
-    if (literalMatches.length > 0) {
-        hardFail("DIAGNOSTIC_CODE_HARDCODED_IN_TOOLS", `tools.ts 仍有 ${literalMatches.length} 个硬编码诊断码字面量`, ["src/adapters/claude_code/tools.ts"], "problem-36", "旧 gate 不检查诊断码集中治理", "改用 diagnostic_registry 导出的 TOOL_DIAGNOSTIC_CODES");
-    }
-    const registry = await import("./diagnostic_registry.js");
-    const required = Object.values(registry.TOOL_DIAGNOSTIC_CODES);
-    const registered = new Set(registry.listAllDiagnostics().map((d) => d.code));
-    const missing = required.filter((code) => !registered.has(code));
-    if (missing.length > 0) {
-        hardFail("DIAGNOSTIC_CODE_REGISTRY_MISSING", `诊断码常量未在注册表登记: ${missing.join(", ")}`, ["src/engine/diagnostic_registry.ts"], "problem-36", "旧 gate 不检查诊断码注册完整性", "补齐 BUILTIN_DIAGNOSTICS");
-    }
-}
-async function checkControlPlaneTrustBehavior(rootDir, hardFail) {
-    try {
-        const control = await import("./control_plane_contract.js");
-        const toolContracts = await import("./tool_invocation_contract_registry.js");
-        const matrix = control.CONTROL_PLANE_MATRIX ?? [];
-        const branchDetails = control.CONTROL_PLANE_BRANCH_DETAILS ?? [];
-        if (matrix.length !== 15) {
-            hardFail("CONTROL_PLANE_MATRIX_INCOMPLETE", `控制面矩阵数量应为 15，实际为 ${matrix.length}`, ["src/engine/control_plane_contract.ts"], "problem-72", "旧 gate 不覆盖 MCP 控制面可用性与旁路", "补齐控制面矩阵");
-        }
-        if (branchDetails.length < 30) {
-            hardFail("CONTROL_PLANE_BRANCH_DETAILS_INCOMPLETE", `控制面枝叶细节至少 30 条，实际为 ${branchDetails.length}`, ["src/engine/control_plane_contract.ts"], "problem-72", "旧 gate 不覆盖枝叶防回归细节", "补齐枝叶细节");
-        }
-        if (!control.isSoloforgeStateBypassCommand("rm -rf .soloforge/state/current-task.json")) {
-            hardFail("CONTROL_PLANE_BYPASS_GUARD_FALSE_NEGATIVE", "Bash 直接删除 .soloforge/state 未被识别为旁路", ["src/engine/control_plane_contract.ts", "src/bin/soloforge.ts"], "problem-72", "旧 gate 不验证 Bash/Edit/Write 旁路", "修复旁路拦截");
-        }
-        if (control.isSoloforgeStateBypassCommand("cat .soloforge/state/current-task.json")) {
-            hardFail("CONTROL_PLANE_BYPASS_GUARD_FALSE_POSITIVE", "只读查看 .soloforge/state 被误判为写旁路", ["src/engine/control_plane_contract.ts"], "problem-72", "旧 gate 不检查旁路误拦", "修复旁路判断");
-        }
-        const contractFindings = control.validateControlPlaneToolContracts(toolContracts.listToolInvocationContracts());
-        const hardContractFindings = contractFindings.filter((finding) => finding.severity === "hard_fail");
-        if (hardContractFindings.length > 0) {
-            hardFail("CONTROL_PLANE_TOOL_CONTRACT_INVALID", `工具控制面契约存在 ${hardContractFindings.length} 个 hard_fail: ${hardContractFindings.map((f) => f.code).join(", ")}`, ["src/engine/tool_invocation_contract_registry.ts"], "problem-72", "旧 gate 不检查工具错标和死链路", "修复工具契约");
-        }
-        const fakeContractFindings = control.validateControlPlaneToolContracts([{
-                tool_name: "sf_fake_readonly_writer",
-                category: "read_only_bypass",
-                side_effects: ["task_context_write"],
-                requires_authorization: false,
-                requires_workflow: false,
-                description: "错误契约",
-                default_next_tools: [],
-                forbidden_next_tools: [],
-            }]);
-        if (!fakeContractFindings.some((finding) => finding.code === "CONTROL_PLANE_READ_ONLY_HAS_SIDE_EFFECT")) {
-            hardFail("CONTROL_PLANE_TOOL_CONTRACT_FALSE_PASS", "read_only_bypass 写状态的假契约未被阻断", ["src/engine/control_plane_contract.ts"], "problem-72", "旧 gate 不验证契约错标 must-fail", "修复工具契约验证");
-        }
-        const bypassAssessment = control.assessControlledGenerationChain({
-            changed_files: ["src/Foo.java"],
-            verified_files: ["src/Foo.java"],
-            traces: [{ tool_name: "Bash", status: "passed", evidence_kind: "command_execution" }],
-            delivery_status: "delivered",
-        });
-        if (bypassAssessment.accepted || !bypassAssessment.findings.some((finding) => finding.code === "CONTROLLED_GENERATION_MISSING_MCP_PROVENANCE")) {
-            hardFail("CONTROLLED_GENERATION_BYPASS_FALSE_PASS", "非 MCP 生成代码被错误接受为完整可信交付", ["src/engine/control_plane_contract.ts"], "problem-72", "旧 gate 不验证来源归因", "修复受控生成链路");
-        }
-        const partialAssessment = control.assessControlledGenerationChain({
-            changed_files: ["src/Foo.java", "src/Bar.java"],
-            verified_files: ["src/Foo.java"],
-            traces: [
-                { tool_name: "sf_classify", task_id: "t1", status: "passed" },
-                { tool_name: "sf_expand", task_id: "t1", status: "passed" },
-                { tool_name: "sf_verify", task_id: "t1", status: "passed", evidence_kind: "command_execution" },
-            ],
-            delivery_status: "delivered",
-        });
-        if (partialAssessment.accepted || !partialAssessment.findings.some((finding) => finding.code === "CONTROLLED_GENERATION_CHANGED_FILE_UNVERIFIED")) {
-            hardFail("CONTROLLED_GENERATION_SCOPE_FALSE_PASS", "changed_files 子集验证被错误接受", ["src/engine/control_plane_contract.ts"], "problem-72", "旧 gate 不验证范围完整性", "修复验证范围对账");
-        }
-        const passAssessment = control.assessControlledGenerationChain({
-            changed_files: ["src/Foo.java"],
-            verified_files: ["src/Foo.java"],
-            traces: [
-                { tool_name: "sf_classify", task_id: "t1", status: "passed" },
-                { tool_name: "sf_expand", task_id: "t1", status: "passed" },
-                { tool_name: "sf_verify", task_id: "t1", status: "passed", evidence_kind: "command_execution" },
-                { tool_name: "sf_deliver", task_id: "t1", status: "passed" },
-            ],
-            delivery_status: "delivered",
-        });
-        if (!passAssessment.accepted || passAssessment.confidence !== "full") {
-            hardFail("CONTROLLED_GENERATION_VALID_CHAIN_BLOCKED", "完整 MCP 受控生成链路被误阻断", ["src/engine/control_plane_contract.ts"], "problem-72", "旧 gate 不验证 must-pass", "修复受控生成链路");
-        }
-        const cliText = safeRead(path.join(rootDir, "src", "bin", "soloforge.ts")) ?? "";
-        if (!cliText.includes("case \"doctor\"") || !cliText.includes("auditControlPlaneProject")) {
-            hardFail("CONTROL_PLANE_DOCTOR_MISSING", "CLI 未提供 soloforge doctor 控制面诊断入口", ["src/bin/soloforge.ts"], "problem-72", "旧 gate 没有 MCP 控制面恢复入口", "补 soloforge doctor");
-        }
-        if (!cliText.includes("仍处于 ${currentTask.status}") ||
-            !cliText.includes("缺少 design_artifact_pack") ||
-            !cliText.includes("没有受控 SoloForge 任务") ||
-            !cliText.includes("不得取消/归档当前任务后改用 Bash/Edit/Write") ||
-            !cliText.includes("禁止通过 Bash 直接写业务实现文件")) {
-            hardFail("CONTROLLED_IMPLEMENTATION_WRITE_GATE_MISSING", "check-write/check-bash 未覆盖 expanding 卡死、设计产物存在但缺 design_artifact_pack、无受控任务和 Bash 直接编码旁路", ["src/bin/soloforge.ts"], "problem-72", "旧 gate 只在交付层发现非 MCP 来源，未在写入入口阻断真实用户项目旁路", "在 check-write/check-bash 对业务实现文件增加受控任务与设计产物包前置门");
-        }
-        const assetManifestText = safeRead(path.join(rootDir, "src", "engine", "asset_manifest.ts")) ?? "";
-        const workflowRuleText = safeRead(path.join(rootDir, "templates", "knowledge", "rules", "工作流导航契约规则.md")) ?? "";
-        const lifecycleProcedureText = safeRead(path.join(rootDir, "templates", "knowledge", "procedures", "全生命周期工作流导航.md")) ?? "";
-        const antiBypassNeedles = [
-            "不得建议取消任务后直接写",
-            "不得建议“先用 Bash 直接修改业务代码”",
-            "不得手动删除 `.soloforge/state`",
-            "归档后仍必须重新 `sf_classify -> sf_expand`",
-        ];
-        const antiBypassText = `${assetManifestText}\n${workflowRuleText}\n${lifecycleProcedureText}`;
-        const missingAntiBypassNeedles = antiBypassNeedles.filter((needle) => !antiBypassText.includes(needle));
-        if (missingAntiBypassNeedles.length > 0) {
-            hardFail("CONTROL_PLANE_BLOCKED_RECOVERY_PROMPT_MISSING", `适配器/知识规则缺少阻断恢复反旁路硬规则: ${missingAntiBypassNeedles.join(", ")}`, ["src/engine/asset_manifest.ts", "templates/knowledge/rules/工作流导航契约规则.md", "templates/knowledge/procedures/全生命周期工作流导航.md"], "problem-72", "运行时 hook 能拦截写入，但模型仍可能口头建议取消任务、Bash 直写或手动清状态", "把阻断恢复反旁路协议注入 adapter workflow 和工作流导航知识资产");
-        }
-    }
-    catch (e) {
-        hardFail("CONTROL_PLANE_BEHAVIOR_EXCEPTION", `控制面可信行为验证异常: ${e.message}`, ["src/engine/control_plane_contract.ts"], "problem-72", "旧 gate 不验证控制面可信", "修复控制面契约模块");
-    }
-}
-// ── 主入口 ──
-export async function runReleaseReadinessGate(rootDir) {
-    const hardFails = [];
-    const phases = [];
-    let capturedNoiseCount = 0;
-    // 初始化日志器为静默模式，防止 debug/internalWarn 输出
-    const { initLogger, resetLogger } = await import("./logger.js");
-    initLogger({ silent: true });
-    // 兜底: 仍然拦截 console.error，捕获任何绕过日志器的直接调用
-    const origConsoleError = console.error;
-    const noiseLogs = [];
-    console.error = (...args) => { noiseLogs.push(args.join(" ")); };
-    function hardFail(code, message, files, issueOrMech, oldGateMissed, nextStep) {
-        hardFails.push({ code, message, files, issueOrMech, oldGateMissed, nextStep });
-    }
-    function _info(_msg) { }
-    function beginPhase(name) {
-        phases.push({ name, hard_fail_count: -1 }); // -1 标记进行中
-    }
-    function endPhase(name) {
-        const phase = phases.find(p => p.name === name && p.hard_fail_count === -1);
-        if (phase)
-            phase.hard_fail_count = hardFails.length - (phases.filter(p => p.hard_fail_count >= 0).reduce((s, p) => s + p.hard_fail_count, 0));
-        else
-            phases.push({ name, hard_fail_count: 0 });
-    }
-    // 0
-    beginPhase("dist 旧产物风险");
-    checkDistFreshness(rootDir, hardFail);
-    endPhase("dist 旧产物风险");
-    // 1
-    beginPhase("Batch 施工痕迹泄漏");
-    checkBatchTraceLeakage(rootDir, hardFail, _info);
-    endPhase("Batch 施工痕迹泄漏");
-    // 2
-    beginPhase("双层模型语义归位");
-    await checkDualLayerSemantics(rootDir, hardFail, _info);
-    endPhase("双层模型语义归位");
-    // 3
-    beginPhase("主链路真实消费");
-    checkMainlineConsumption(rootDir, hardFail, _info);
-    endPhase("主链路真实消费");
-    // 4
-    beginPhase("模板/adapter 更新空洞");
-    checkTemplateAdapterGaps(rootDir, hardFail);
-    endPhase("模板/adapter 更新空洞");
-    // 5
-    beginPhase("旧 gate 误导标记");
-    checkOldGateMisdirection(rootDir, hardFail, _info);
-    endPhase("旧 gate 误导标记");
-    // 6
-    beginPhase("测试污染初筛");
-    checkTestPollution(rootDir, hardFail, _info);
-    endPhase("测试污染初筛");
-    // 7
-    beginPhase("Batch 问题文档格式一致性");
-    await checkBatchIssueFormatConsistency(rootDir, hardFail, _info);
-    endPhase("Batch 问题文档格式一致性");
-    // 8
-    beginPhase("关键问题消费验证");
-    await checkCriticalProblemConsumption(rootDir, hardFail, _info);
-    endPhase("关键问题消费验证");
-    // 9
-    beginPhase("机制身份一致性");
-    await checkMechanismIdentityConsistency(rootDir, hardFail, _info);
-    endPhase("机制身份一致性");
-    // 10: P0/P1 知识资产 schema 完整性
-    beginPhase("P0/P1 知识资产 schema");
-    await checkKnowledgeAssetSchema(rootDir, hardFail, _info);
-    endPhase("P0/P1 知识资产 schema");
-    // 11: console.log 检查
-    beginPhase("engine console.log 检查");
-    checkEngineConsoleLog(rootDir, hardFail);
-    endPhase("engine console.log 检查");
-    // 12: 中文注释检查
-    beginPhase("中文注释检查");
-    checkChineseComments(rootDir, hardFail);
-    endPhase("中文注释检查");
-    // 13: 第五批文档↔roadmap↔scenario 一致性
-    beginPhase("第五批一致性校验");
-    await checkLastBatchConsistency(rootDir, hardFail, _info);
-    endPhase("第五批一致性校验");
-    // 14: 依赖漏洞扫描（在 console.error 恢复前执行以避免干扰）
-    beginPhase("依赖漏洞扫描");
-    checkDependencyAudit(rootDir, hardFail, _info);
-    endPhase("依赖漏洞扫描");
-    // 15: 发布问题全局合同（问题六十一至六十五）
-    beginPhase("发布问题全局合同");
-    await checkReleaseIssueDesignPath(rootDir, hardFail, _info);
-    endPhase("发布问题全局合同");
-    // 16: 工作流导航契约行为验证（问题六十五）
-    beginPhase("工作流导航契约行为验证");
-    await checkWorkflowNavigationBehavior(rootDir, hardFail, _info);
-    endPhase("工作流导航契约行为验证");
-    // 17: OOD/SOLID 与后端实现工程契约行为验证（问题六十六/六十七）
-    beginPhase("实现工程契约行为验证");
-    await checkImplementationContractBehavior(rootDir, hardFail, _info);
-    endPhase("实现工程契约行为验证");
-    // 18: 代码可维护性与可观测性契约行为验证（问题六十八）
-    beginPhase("代码可维护性与可观测性行为验证");
-    await checkCodeObservabilityBehavior(rootDir, hardFail, _info);
-    endPhase("代码可维护性与可观测性行为验证");
-    // 19: 历史问题长期机制化行为验证
-    beginPhase("历史问题长期机制化行为验证");
-    await checkLongTermMechanization(rootDir, hardFail, _info);
-    endPhase("历史问题长期机制化行为验证");
-    // 20: 诊断码集中治理检查
-    beginPhase("诊断码集中治理检查");
-    await checkDiagnosticCentralization(rootDir, hardFail);
-    endPhase("诊断码集中治理检查");
-    // 21: 模板卫生与用户项目知识消费验证
-    beginPhase("模板卫生与项目知识消费验证");
-    await checkTemplateAndProjectKnowledgeHygiene(rootDir, hardFail, _info);
-    endPhase("模板卫生与项目知识消费验证");
-    // 22: MCP 控制面可信与受控生成链路验证
-    beginPhase("MCP 控制面可信与受控生成链路验证");
-    await checkControlPlaneTrustBehavior(rootDir, hardFail);
-    endPhase("MCP 控制面可信与受控生成链路验证");
-    // 恢复 console.error 和日志器
-    console.error = origConsoleError;
-    resetLogger();
-    // 噪音检测: 捕获任何绕过日志器的直接 console.error("[soloForge]...") 调用
-    capturedNoiseCount = noiseLogs.filter(l => l.includes("[soloForge]")).length;
-    if (capturedNoiseCount > 0) {
-        hardFail("OUTPUT_NOISE", `发布门禁运行时产生 ${capturedNoiseCount} 条模块噪音日志`, ["src/engine/logger.ts"], "发布门禁输出质量", "旧 gate 不检查自身输出噪音", "日志治理");
-    }
-    return {
-        passed: hardFails.length === 0,
-        hard_fail_count: hardFails.length,
-        hard_fails: hardFails,
-        phases: phases.map(p => ({ name: p.name, hard_fail_count: p.hard_fail_count >= 0 ? p.hard_fail_count : 0 })),
-        noise_log_count: capturedNoiseCount,
-    };
-}
-//# sourceMappingURL=release_readiness_gate.js.map