soloforge 1.4.15 → 1.5.0

package/dist/engine/gate_checks/checkControlPlaneTrust.js

@@ -0,0 +1,111 @@
+/**
+ * 门禁检查模块 — Phase 22: MCP 控制面可信与受控生成链路验证。
+ *
+ * 验证控制面矩阵完整性、旁路拦截、工具契约有效性、
+ * 受控生成链路 must-pass/must-fail、CLI 入口与反旁路硬规则。
+ */
+import path from "node:path";
+import { safeReadCached } from "./helpers.js";
+export async function check(ctx, hardFail) {
+    try {
+        const control = await import("../control_plane_contract.js");
+        const toolContracts = await import("../tool_invocation_contract_registry.js");
+        const matrix = control.CONTROL_PLANE_MATRIX ?? [];
+        const branchDetails = control.CONTROL_PLANE_BRANCH_DETAILS ?? [];
+        if (matrix.length !== 15) {
+            hardFail("CONTROL_PLANE_MATRIX_INCOMPLETE", `控制面矩阵数量应为 15，实际为 ${matrix.length}`, ["src/engine/control_plane_contract.ts"], "problem-72", "旧 gate 不覆盖 MCP 控制面可用性与旁路", "补齐控制面矩阵");
+        }
+        if (branchDetails.length < 30) {
+            hardFail("CONTROL_PLANE_BRANCH_DETAILS_INCOMPLETE", `控制面枝叶细节至少 30 条，实际为 ${branchDetails.length}`, ["src/engine/control_plane_contract.ts"], "problem-72", "旧 gate 不覆盖枝叶防回归细节", "补齐枝叶细节");
+        }
+        if (!control.isSoloforgeStateBypassCommand("rm -rf .soloforge/state/current-task.json")) {
+            hardFail("CONTROL_PLANE_BYPASS_GUARD_FALSE_NEGATIVE", "Bash 直接删除 .soloforge/state 未被识别为旁路", ["src/engine/control_plane_contract.ts", "src/bin/soloforge.ts"], "problem-72", "旧 gate 不验证 Bash/Edit/Write 旁路", "修复旁路拦截");
+        }
+        if (control.isSoloforgeStateBypassCommand("cat .soloforge/state/current-task.json")) {
+            hardFail("CONTROL_PLANE_BYPASS_GUARD_FALSE_POSITIVE", "只读查看 .soloforge/state 被误判为写旁路", ["src/engine/control_plane_contract.ts"], "problem-72", "旧 gate 不检查旁路误拦", "修复旁路判断");
+        }
+        const contractFindings = control.validateControlPlaneToolContracts(toolContracts.listToolInvocationContracts());
+        const hardContractFindings = contractFindings.filter((finding) => finding.severity === "hard_fail");
+        if (hardContractFindings.length > 0) {
+            hardFail("CONTROL_PLANE_TOOL_CONTRACT_INVALID", `工具控制面契约存在 ${hardContractFindings.length} 个 hard_fail: ${hardContractFindings.map((f) => f.code).join(", ")}`, ["src/engine/tool_invocation_contract_registry.ts"], "problem-72", "旧 gate 不检查工具错标和死链路", "修复工具契约");
+        }
+        const fakeContractFindings = control.validateControlPlaneToolContracts([{
+                tool_name: "sf_fake_readonly_writer",
+                category: "read_only_bypass",
+                side_effects: ["task_context_write"],
+                requires_authorization: false,
+                requires_workflow: false,
+                description: "错误契约",
+                default_next_tools: [],
+                forbidden_next_tools: [],
+            }]);
+        if (!fakeContractFindings.some((finding) => finding.code === "CONTROL_PLANE_READ_ONLY_HAS_SIDE_EFFECT")) {
+            hardFail("CONTROL_PLANE_TOOL_CONTRACT_FALSE_PASS", "read_only_bypass 写状态的假契约未被阻断", ["src/engine/control_plane_contract.ts"], "problem-72", "旧 gate 不验证契约错标 must-fail", "修复工具契约验证");
+        }
+        const bypassAssessment = control.assessControlledGenerationChain({
+            changed_files: ["src/Foo.java"],
+            verified_files: ["src/Foo.java"],
+            traces: [{ tool_name: "Bash", status: "passed", evidence_kind: "command_execution" }],
+            delivery_status: "delivered",
+        });
+        if (bypassAssessment.accepted || !bypassAssessment.findings.some((finding) => finding.code === "CONTROLLED_GENERATION_MISSING_MCP_PROVENANCE")) {
+            hardFail("CONTROLLED_GENERATION_BYPASS_FALSE_PASS", "非 MCP 生成代码被错误接受为完整可信交付", ["src/engine/control_plane_contract.ts"], "problem-72", "旧 gate 不验证来源归因", "修复受控生成链路");
+        }
+        const partialAssessment = control.assessControlledGenerationChain({
+            changed_files: ["src/Foo.java", "src/Bar.java"],
+            verified_files: ["src/Foo.java"],
+            traces: [
+                { tool_name: "sf_classify", task_id: "t1", status: "passed" },
+                { tool_name: "sf_expand", task_id: "t1", status: "passed" },
+                { tool_name: "sf_verify", task_id: "t1", status: "passed", evidence_kind: "command_execution" },
+            ],
+            delivery_status: "delivered",
+        });
+        if (partialAssessment.accepted || !partialAssessment.findings.some((finding) => finding.code === "CONTROLLED_GENERATION_CHANGED_FILE_UNVERIFIED")) {
+            hardFail("CONTROLLED_GENERATION_SCOPE_FALSE_PASS", "changed_files 子集验证被错误接受", ["src/engine/control_plane_contract.ts"], "problem-72", "旧 gate 不验证范围完整性", "修复验证范围对账");
+        }
+        const passAssessment = control.assessControlledGenerationChain({
+            changed_files: ["src/Foo.java"],
+            verified_files: ["src/Foo.java"],
+            traces: [
+                { tool_name: "sf_classify", task_id: "t1", status: "passed" },
+                { tool_name: "sf_expand", task_id: "t1", status: "passed" },
+                { tool_name: "sf_verify", task_id: "t1", status: "passed", evidence_kind: "command_execution" },
+                { tool_name: "sf_deliver", task_id: "t1", status: "passed" },
+            ],
+            delivery_status: "delivered",
+        });
+        if (!passAssessment.accepted || passAssessment.confidence !== "full") {
+            hardFail("CONTROLLED_GENERATION_VALID_CHAIN_BLOCKED", "完整 MCP 受控生成链路被误阻断", ["src/engine/control_plane_contract.ts"], "problem-72", "旧 gate 不验证 must-pass", "修复受控生成链路");
+        }
+        const cliText = safeReadCached(path.join(ctx.rootDir, "src", "bin", "soloforge.ts"), ctx.readCache) ?? "";
+        if (!cliText.includes("case \"doctor\"") || !cliText.includes("auditControlPlaneProject")) {
+            hardFail("CONTROL_PLANE_DOCTOR_MISSING", "CLI 未提供 soloforge doctor 控制面诊断入口", ["src/bin/soloforge.ts"], "problem-72", "旧 gate 没有 MCP 控制面恢复入口", "补 soloforge doctor");
+        }
+        if (!cliText.includes("仍处于 ${currentTask.status}") ||
+            !cliText.includes("缺少 design_artifact_pack") ||
+            !cliText.includes("没有受控 SoloForge 任务") ||
+            !cliText.includes("不得取消/归档当前任务后改用 Bash/Edit/Write") ||
+            !cliText.includes("禁止通过 Bash 直接写业务实现文件")) {
+            hardFail("CONTROLLED_IMPLEMENTATION_WRITE_GATE_MISSING", "check-write/check-bash 未覆盖 expanding 卡死、设计产物存在但缺 design_artifact_pack、无受控任务和 Bash 直接编码旁路", ["src/bin/soloforge.ts"], "problem-72", "旧 gate 只在交付层发现非 MCP 来源，未在写入入口阻断真实用户项目旁路", "在 check-write/check-bash 对业务实现文件增加受控任务与设计产物包前置门");
+        }
+        const assetManifestText = safeReadCached(path.join(ctx.rootDir, "src", "engine", "asset_manifest.ts"), ctx.readCache) ?? "";
+        const workflowRuleText = safeReadCached(path.join(ctx.rootDir, "templates", "internal", "rules", "工作流导航契约规则.md"), ctx.readCache) ?? "";
+        const lifecycleProcedureText = safeReadCached(path.join(ctx.rootDir, "templates", "procedures", "全生命周期工作流导航.md"), ctx.readCache) ?? "";
+        const antiBypassNeedles = [
+            "不得建议取消任务后直接写",
+            "不得建议\u201C先用 Bash 直接修改业务代码\u201D",
+            "不得手动删除 `.soloforge/state`",
+            "归档后仍必须重新 `sf_classify -> sf_expand`",
+        ];
+        const antiBypassText = `${assetManifestText}\n${workflowRuleText}\n${lifecycleProcedureText}`;
+        const missingAntiBypassNeedles = antiBypassNeedles.filter((needle) => !antiBypassText.includes(needle));
+        if (missingAntiBypassNeedles.length > 0) {
+            hardFail("CONTROL_PLANE_BLOCKED_RECOVERY_PROMPT_MISSING", `适配器/知识规则缺少阻断恢复反旁路硬规则: ${missingAntiBypassNeedles.join(", ")}`, ["src/engine/asset_manifest.ts", "templates/internal/rules/工作流导航契约规则.md", "templates/procedures/全生命周期工作流导航.md"], "problem-72", "运行时 hook 能拦截写入，但模型仍可能口头建议取消任务、Bash 直写或手动清状态", "把阻断恢复反旁路协议注入 adapter workflow 和工作流导航知识资产");
+        }
+    }
+    catch (e) {
+        hardFail("CONTROL_PLANE_BEHAVIOR_EXCEPTION", `控制面可信行为验证异常: ${e.message}`, ["src/engine/control_plane_contract.ts"], "problem-72", "旧 gate 不验证控制面可信", "修复控制面契约模块");
+    }
+}
+//# sourceMappingURL=checkControlPlaneTrust.js.map

package/dist/engine/gate_checks/checkControlPlaneTrust.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkControlPlaneTrust.js","sourceRoot":"","sources":["../../../src/engine/gate_checks/checkControlPlaneTrust.ts"],"names":[],"mappings":"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"}

package/dist/engine/gate_checks/checkCriticalProblemConsumption.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Phase 8: 关键问题消费验证 (problem-17/38/57/60)
+ */
+import type { GateContext, HardFailCallback, InfoCallback } from "./types.js";
+export declare function check(ctx: GateContext, hardFail: HardFailCallback, info?: InfoCallback): Promise<void>;
+//# sourceMappingURL=checkCriticalProblemConsumption.d.ts.map

package/dist/engine/gate_checks/checkCriticalProblemConsumption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkCriticalProblemConsumption.d.ts","sourceRoot":"","sources":["../../../src/engine/gate_checks/checkCriticalProblemConsumption.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,KAAK,EAAE,WAAW,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAI9E,wBAAsB,KAAK,CACzB,GAAG,EAAE,WAAW,EAChB,QAAQ,EAAE,gBAAgB,EAC1B,IAAI,CAAC,EAAE,YAAY,GAClB,OAAO,CAAC,IAAI,CAAC,CAomBf"}

package/dist/engine/gate_checks/checkCriticalProblemConsumption.js

@@ -0,0 +1,476 @@
+/**
+ * Phase 8: 关键问题消费验证 (problem-17/38/57/60)
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { safeReadCached } from "./helpers.js";
+import { sourceContainsIdentifier } from "../source_code_matcher.js";
+export async function check(ctx, hardFail, info) {
+    const rootDir = ctx.rootDir;
+    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 = safeReadCached(stateFactPath, ctx.readCache);
+        const tcContent = safeReadCached(taskContextPath, ctx.readCache);
+        if (!sfContent || !sourceContainsIdentifier(sfContent, "validateStateFactPartition")) {
+            hardFail("CRITICAL_PROBLEM_EXPORT_MISSING", "problem-17: state_fact_classifier.ts 未导出 validateStateFactPartition", ["src/engine/state_fact_classifier.ts"], "problem-17", "StateFact 分类器缺少核心导出函数", "添加 validateStateFactPartition 导出");
+        }
+        if (!tcContent || !sourceContainsIdentifier(tcContent, "validateStateFactPartition")) {
+            hardFail("CRITICAL_PROBLEM_NOT_CONSUMED", "problem-17: task_context.ts save() 未调用 validateStateFactPartition", ["src/engine/task_context.ts", "src/engine/state_fact_classifier.ts"], "problem-17", "StateFact 分区定义存在但未接入 TaskContext 保存路径", "在 task_context.ts save() 中接入 validateStateFactPartition");
+        }
+        else {
+            // 验证 hard_fail 时 throw（不是静默跳过）
+            const tcLines = tcContent.split("\n");
+            const vspLine = tcLines.findIndex(l => l.includes("validateStateFactPartition"));
+            if (vspLine === -1) {
+                hardFail("CRITICAL_PROBLEM_NOT_CONSUMED", "problem-17: task_context.ts save() 未调用 validateStateFactPartition", ["src/engine/task_context.ts"], "problem-17", "StateFact 分区定义存在但未接入 TaskContext 保存路径", "接入 validateStateFactPartition");
+            }
+            else {
+                // 检查调用后有 hard_fail throw 路径
+                const afterVsp = tcLines.slice(vspLine, vspLine + 15).join("\n");
+                if (!(afterVsp.includes("throw") || afterVsp.includes("hardFails") || afterVsp.includes("hard_fail"))) {
+                    hardFail("CRITICAL_PROBLEM_SOFT_ENFORCEMENT", "problem-17: task_context.ts 中 validateStateFactPartition 调用后缺少 hard_fail throw 路径", ["src/engine/task_context.ts"], "problem-17", "StateFact 校验结果被忽略而非阻断", "校验 hard_fail 时 throw Error");
+                }
+            }
+        }
+    }
+    // problem-38: Retention Policy — cleanup 必须调用 evaluateCleanup/checkForbiddenContent，存在 referenced evidence 保护
+    const retentionPath = path.join(rootDir, "src/engine/retention_policy.ts");
+    if (!fs.existsSync(retentionPath)) {
+        hardFail("CRITICAL_PROBLEM_FILE_MISSING", "problem-38: retention_policy.ts 不存在", ["src/engine/retention_policy.ts"], "problem-38", "发布门禁不检查 problem-38 实现", "创建 retention_policy.ts");
+    }
+    else {
+        const retContent = safeReadCached(retentionPath, ctx.readCache);
+        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 = safeReadCached(taskContextPath, ctx.readCache);
+        const cliContent = safeReadCached(cliPath, ctx.readCache);
+        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 = safeReadCached(kaAuditPath, ctx.readCache);
+        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 = safeReadCached(cliPath, ctx.readCache);
+        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 = safeReadCached(evidenceGroundingPath, ctx.readCache);
+        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 = safeReadCached(instrContractPath, ctx.readCache);
+        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 = safeReadCached(toolsPath, ctx.readCache);
+        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/internal/rules/证据驱动与反幻觉规则.md");
+        if (!fs.existsSync(kaRulePath)) {
+            hardFail("CRITICAL_PROBLEM_ASSET_MISSING", "problem-60: 缺少知识规则文件 证据驱动与反幻觉规则.md", ["templates/internal/rules/证据驱动与反幻觉规则.md"], "problem-60", "证据驱动知识规则缺失", "创建知识规则文件");
+        }
+        // 静态检查：workflow_template 或 workflow_rule_generator（规则已提取至 engine 层）
+        const wfPath = path.join(rootDir, "src/adapters/shared/workflow_template.ts");
+        const wrgPath = path.join(rootDir, "src/engine/workflow_rule_generator.ts");
+        const wfContent = (safeReadCached(wfPath, ctx.readCache) ?? "") + (safeReadCached(wrgPath, ctx.readCache) ?? "");
+        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/task.ts");
+        const typesContent = safeReadCached(typesPath, ctx.readCache);
+        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/task.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 = safeReadCached(tcPath, ctx.readCache);
+        if (tcContent && !sourceContainsIdentifier(tcContent, "setEvidenceGroundingResult")) {
+            hardFail("CRITICAL_PROBLEM_NO_WRITEBACK", "problem-60: task_context.ts 缺少 setEvidenceGroundingResult 写入方法", ["src/engine/task_context.ts"], "problem-60", "TaskContext 只有类型字段没有写入方法", "添加 setEvidenceGroundingResult 方法");
+        }
+        // 静态检查：tools.ts 主链路必须调用 setEvidenceGroundingResult
+        if (toolsContent && !toolsContent.includes("setEvidenceGroundingResult")) {
+            hardFail("CRITICAL_PROBLEM_NO_RUNTIME_WRITEBACK", "problem-60: tools.ts 未调用 setEvidenceGroundingResult 写回 TaskContext", ["src/adapters/claude_code/tools.ts"], "problem-60", "主链路不写回证据结果到 TaskContext", "在 sf_expand/sf_verify/sf_deliver 中调用 setEvidenceGroundingResult");
+        }
+        // 静态检查：tools.ts 不得出现 registry.query({}).map() 无差别证据绑定
+        if (toolsContent) {
+            const toolsLines = toolsContent.split("\n");
+            for (let i = 0; i < toolsLines.length; i++) {
+                if (/registry\.query\(\{\}\)\.map/.test(toolsLines[i])) {
+                    hardFail("CRITICAL_PROBLEM_INDISCRIMINATE_BINDING", `problem-60: tools.ts:${i + 1} 使用 registry.query({}).map() 无差别绑定证据到所有 claim`, ["src/adapters/claude_code/tools.ts"], "problem-60", "所有 registry 证据被无差别绑定到所有 claim，不区分语义", "按 claim 语义筛选 evidence_ids");
+                }
+            }
+        }
+        // 行为检查：setEvidenceGroundingResult 写入后 load 能读回
+        try {
+            const tcModule = await import(path.join(rootDir, "dist/engine/task_context.js"));
+            const tmpStateDir = path.join(rootDir, ".soloforge", "state");
+            const fsModule = await import("node:fs");
+            if (!fsModule.existsSync(tmpStateDir)) {
+                fsModule.mkdirSync(tmpStateDir, { recursive: true });
+            }
+            const tmpMgr = new tcModule.TaskContextManager(tmpStateDir);
+            const tmpCtx = await tmpMgr.create("gate-evidence-writeback-test", "test");
+            const testMatrix = {
+                task_id: tmpCtx.task_id, claims: [], evidence: [],
+                conflicts: [], unsupported_claims: ["test-claim"],
+                risk_summary: { low: 0, medium: 0, high: 1, critical: 0 },
+                created_at: new Date().toISOString(),
+            };
+            const testGate = {
+                allowed: false, reason_zh: "测试", diagnostic_code: "SF-EVIDENCE-TEST",
+                unsupported_claims: ["test-claim"], unresolved_conflicts: [],
+                missing_evidence: [], risk_level: "high",
+                requires_user_confirmation: [],
+            };
+            await tmpMgr.setEvidenceGroundingResult(tmpCtx.task_id, {
+                evidence_matrix: testMatrix,
+                evidence_gate_result: testGate,
+                unsupported_claims: ["test-claim"],
+            });
+            const loaded = await tmpMgr.load(tmpCtx.task_id);
+            if (!loaded?.evidence_matrix || !loaded?.evidence_gate_result) {
+                hardFail("CRITICAL_PROBLEM_WRITEBACK_FAILED", "problem-60: setEvidenceGroundingResult 写入后 load 无法读回", ["src/engine/task_context.ts"], "problem-60", "TaskContext 写入方法不工作", "修复 setEvidenceGroundingResult 或 save/load");
+            }
+            if (loaded.evidence_gate_result?.allowed !== false) {
+                hardFail("CRITICAL_PROBLEM_WRITEBACK_CORRUPT", "problem-60: setEvidenceGroundingResult 写入的 gate result 数据损坏", ["src/engine/task_context.ts"], "problem-60", "写入的 allowed=false 被读回为 true", "检查序列化逻辑");
+            }
+            // 清理测试任务
+            try {
+                fsModule.rmSync(path.join(tmpStateDir, `${tmpCtx.task_id}.json`), { force: true });
+            }
+            catch { }
+        }
+        catch (wbErr) {
+            hardFail("CRITICAL_PROBLEM_WRITEBACK_ERROR", `problem-60: setEvidenceGroundingResult 行为检查失败: ${wbErr?.message ?? wbErr}`, ["src/engine/task_context.ts"], "problem-60", "TaskContext 写入方法不可用", "修复 import 或方法实现");
+        }
+    }
+    info?.("  problem-60 证据驱动消费验证完成");
+}
+//# sourceMappingURL=checkCriticalProblemConsumption.js.map