soloforge 1.2.20 → 1.3.0

package/dist/engine/release_readiness_gate.js

@@ -0,0 +1,1050 @@
+/**
+ * 发布就绪门禁 — CLI 和 npm 共用的正式发布检查逻辑。
+ *
+ * 本模块是 validate-release 的唯一正式入口。
+ * 旧 validate-batch* gate 仅代表历史施工检查，不代表正式发布通过。
+ *
+ * 检查项：
+ * 0. dist 旧产物风险
+ * 1. Batch 施工痕迹泄漏
+ * 2. 双层模型语义归位
+ * 3. 主链路真实消费
+ * 4. 模板/adapter 更新空洞
+ * 5. 旧 gate 误导标记
+ * 6. 测试污染初筛
+ * 7. Batch 问题文档格式一致性
+ */
+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/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 hasImport = staticImportPattern.test(consumerContent) || dynamicImportPattern.test(consumerContent);
+                    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) ──
+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 消费验证完成");
+}
+// ── 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: 5 };
+    const requiredPerProblemSections = [
+        "问题背景", "用户反馈 / 触发场景", "根因分析", "解决方案", "方案细节",
+        "硬规则", "非目标", "影响范围", "落地文件", "验收标准", "回归风险",
+        "与其他问题的关联", "发布门禁要求",
+    ];
+    for (let batch = 1; batch <= 5; 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;
+}
+// ── 主入口 ──
+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("关键问题消费验证");
+    checkCriticalProblemConsumption(rootDir, hardFail, _info);
+    endPhase("关键问题消费验证");
+    // 9
+    beginPhase("机制身份一致性");
+    await checkMechanismIdentityConsistency(rootDir, hardFail, _info);
+    endPhase("机制身份一致性");
+    // 恢复 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