soloforge 1.2.20 → 1.3.1

package/dist/engine/release_readiness_gate.js

@@ -0,0 +1,1660 @@
+/**
+ * 发布就绪门禁 — 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. Batch6 架构决策与设计产物真实消费
+ */
+import fs from "node:fs";
+import path from "node:path";
+// ── 辅助函数 ──
+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 consumerContent.includes(`import("../../engine/${moduleName}.js")`)
+                            || consumerContent.includes(`import("../engine/${moduleName}.js")`)
+                            || consumerContent.includes(`import("./${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 && srcContent.includes(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 (!content.includes("printHistoricalNotice")) {
+            issues.push("缺少 printHistoricalNotice 调用");
+        }
+        // 3. 必须包含 historical_only: true（JSON 输出场景）
+        if (!content.includes("historical_only") && !content.includes("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);
+                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 || !sfContent.includes("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 || !tcContent.includes("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 && !tcContent.includes("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;
+    try {
+        const mod = await import(scriptPath);
+        loadBatchIssueDetails = mod.loadBatchIssueDetails;
+    }
+    catch (e) {
+        hardFail("BATCH_ISSUE_FORMAT_INCONSISTENT", `无法加载共享解析脚本: ${e.message}`, ["scripts/batch_issue_details.mjs"], "构建系统", "共享解析脚本不可用", "修复脚本");
+        return;
+    }
+    if (!loadBatchIssueDetails) {
+        hardFail("BATCH_ISSUE_FORMAT_INCONSISTENT", "loadBatchIssueDetails 导出未找到", ["scripts/batch_issue_details.mjs"], "构建系统", "共享解析脚本导出不正确", "修复脚本");
+        return;
+    }
+    const expectedCounts = { 1: 19, 2: 12, 3: 9, 4: 13, 5: 6, 6: 2 };
+    const requiredPerProblemSections = [
+        "问题背景", "用户反馈 / 触发场景", "根因分析", "解决方案", "方案细节",
+        "硬规则", "非目标", "影响范围", "落地文件", "验收标准", "回归风险",
+        "与其他问题的关联", "发布门禁要求",
+    ];
+    for (let batch = 1; batch <= 6; batch++) {
+        const details = loadBatchIssueDetails(batch, rootDir);
+        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} 个问题)`);
+    }
+    _info("  说明: 本检查不修改文档。格式不一致问题将在第 3 步统一处理。");
+}
+// ── 机制身份一致性 ──
+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.log 检查 ──
+function checkEngineConsoleLog(rootDir, hardFail) {
+    const targets = ["src/engine/", "src/index.ts"];
+    for (const target of targets) {
+        const fullTarget = path.join(rootDir, target);
+        if (!fs.existsSync(fullTarget))
+            continue;
+        const isDir = fs.statSync(fullTarget).isDirectory();
+        const files = isDir
+            ? findFilesRecursive(fullTarget, ".ts")
+            : [fullTarget];
+        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 封装允许 console.log
+                if (/logger\.ts$/.test(file) && /^\s*console\.log\(/.test(line))
+                    continue;
+                if (/console\.log\s*\(/.test(line)) {
+                    const rel = path.relative(rootDir, file);
+                    hardFail("ENGINE_CONSOLE_LOG", `${rel}:${i + 1} 使用 console.log（应使用 logger 或 console.error 写 stderr）`, [rel], "发布门禁 console 检查", "旧 gate 不检查 engine console.log", "替换为 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");
+    }
+}
+// ── 15. Batch6 架构决策与设计产物真实消费 ──
+async function checkBatch6DesignPath(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")) ?? "";
+    if (!toolsText.includes("checkArchitectureDecisionWorkshopGate({") ||
+        !toolsText.includes("projectContext: detectedArchitectureContext")) {
+        hardFail("BATCH6_MAINLINE_MISSING", "问题六十一未接入 sf_expand 架构研讨阻断路径", ["src/adapters/claude_code/tools.ts"], "problem-61", "仅有合同或模板不能证明主链路消费", "在 sf_expand 真实路由调用架构研讨门");
+    }
+    if (!toolsText.includes("verifyDesignArtifactPack(projectPath, designPack)") ||
+        !toolsText.includes("ctx.design_artifact_pack.status !== \"implementation_ready\"") ||
+        !toolsText.includes("checkDesignArtifactWriteGate({ ctx, toolName: name, sideEffects: effectiveSideEffects })")) {
+        hardFail("BATCH6_MAINLINE_MISSING", "问题六十二未同时接入真实 sf_verify、实现写入与 sf_deliver 就绪阻断", ["src/adapters/claude_code/tools.ts"], "problem-62", "仅有文档校验函数不能阻断用户编码/交付", "在验证、写入与交付路径消费设计产物包状态");
+    }
+    if (!cliText.includes("cmdAuditDesignArtifacts") ||
+        !cliText.includes("cmdUpgradeDesignArtifacts") ||
+        !cliText.includes("currentTask?.design_artifact_pack")) {
+        hardFail("BATCH6_USER_CLI_MISSING", "问题六十二缺少用户 CLI 审计/升级或 Claude Code 写入 hook 阻断路径", ["src/bin/soloforge.ts"], "problem-62", "MCP 内部调用不能覆盖用户现有文档升级与直接 Edit/Write 路径", "接入 audit/upgrade CLI 与 check-write 设计产物门");
+    }
+    if (!workflowText.includes("wf-architecture-workshop-first") || !workflowText.includes("wf-design-artifact-pack")) {
+        hardFail("BATCH6_USER_INJECTION_MISSING", "用户项目工作流模板未注入 Batch6 薄硬协议", ["src/adapters/shared/workflow_template.ts"], "problem-61/problem-62", "运行时有门但用户不可预期会造成体验断裂", "向 workflow template 注入硬规则");
+    }
+    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 draft = workshop.createArchitectureDecisionWorkshop("release-batch6", "new_system");
+        if (workshop.evaluateArchitectureDecisionWorkshop(draft).allowed) {
+            hardFail("BATCH6_BEHAVIOR_FALSE_PASS", "问题六十一未确认六域的草稿错误放行", ["src/engine/architecture_decision_workshop.ts"], "problem-61", "必须有负向行为证据", "修复研讨生成门");
+        }
+        const missingPackResult = designPack.verifyDesignArtifactPack(rootDir, designPack.createDesignArtifactPack("release-batch6"));
+        if (missingPackResult.passed) {
+            hardFail("BATCH6_BEHAVIOR_FALSE_PASS", "问题六十二缺少用户项目设计产物时错误放行", ["src/engine/design_artifact_pack.ts"], "problem-62", "必须读取真实资产并阻断缺失", "修复设计产物复验门");
+        }
+    }
+    catch (error) {
+        hardFail("BATCH6_MODULE_LOAD_FAILED", `无法执行 Batch6 行为复验: ${error?.message ?? error}`, ["src/engine/architecture_decision_workshop.ts", "src/engine/design_artifact_pack.ts"], "Batch6", "模块不可执行", "修复构建或导出");
+    }
+    _info("  Batch6 架构决策与设计产物真实消费复验完成");
+}
+// ── 主入口 ──
+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: Batch6 新增真实用户路径
+    beginPhase("Batch6 架构决策与设计产物真实消费");
+    await checkBatch6DesignPath(rootDir, hardFail, _info);
+    endPhase("Batch6 架构决策与设计产物真实消费");
+    // 恢复 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