soloforge 1.2.20 → 1.3.1

package/dist/engine/release_gate_scenario_registry.js

@@ -0,0 +1,717 @@
+/**
+ * 发布门禁场景注册表 — 场景 A/B/C/D/E/F。
+ *
+ * 场景 A: 执行前必须先给计划和方案（覆盖问题五十五）
+ * 场景 B: 核心体验原则不得被机制复杂度打穿（覆盖问题五十六）
+ * 场景 C: 知识资产标准化与反退化治理（覆盖问题五十七）
+ * 场景 D: 施工指令契约（覆盖问题五十八）
+ * 场景 E: 日志治理与用户可见输出标准化（覆盖问题五十九）
+ * 场景 F: 证据驱动与反幻觉治理（覆盖问题六十）
+ */
+import { evaluatePlanProposalGate, validateActionWithinPlan, createPlanProposalEvidence, isReviewOnlyIntent, } from "./plan_proposal_gate.js";
+import { evaluateCoreExperiencePrinciple, evaluateNoFalseCompletion, evaluateMechanismFriction, } from "./core_experience_principle.js";
+import { validateKnowledgeAssets, detectDuplicateAndConflicts, } from "./knowledge_asset_schema.js";
+import { auditKnowledgeAssets } from "./knowledge_asset_audit.js";
+import { createKnowledgeConsumptionSnapshot, validateConsumptionSnapshot, verifyConsumptionPaths, } from "./knowledge_consumption_snapshot.js";
+import { validateInstructionContract, checkInstructionCompleteness, } from "./instruction_contract.js";
+import { initLogger, initLoggerFromEnv, resetLogger, } from "./logger.js";
+import { createEvidenceGroundingSystem, isHighRiskClaimCategory, } from "./evidence_grounding_contract.js";
+// ── 场景定义 ──
+export const RELEASE_GATE_SCENARIOS = [
+    {
+        id: "release-scenario-baseline",
+        name: "执行前必须先给计划和方案",
+        fixture: "ready",
+        command_or_entry: "用户要求修改代码、修改 Batch 文档、运行 Docker、本地验收或执行高风险操作时，AI 尝试直接执行",
+        expected_evidence: ["PlanProposalFirstGate", "PlanProposalEvidence", "UserConfirmationRef", "VerificationPlanRef"],
+        pass_fail_rules: [
+            "写入、编码、构建、Docker、迁移、发布、外部副作用或交付前必须先通过 PlanProposalFirstGate",
+            "simple_answer 可 none_with_reason 或 brief_plan",
+            "file_edit / code_change / test_or_review / local_acceptance 必须至少 execution_plan",
+            "architecture_design / high_risk_operation 必须 option_proposal 或 human_confirmation_required",
+            "删除、覆盖、迁移、数据库 schema、权限模型、技术栈变更、外部副作用、scope 扩大、高成本长任务必须用户确认",
+            "执行动作不得超出已确认计划",
+            "计划必须中文语义优先，路径/命令/代码标识保持原文",
+            "计划必须进入 evidence refs / TaskContext refs",
+        ],
+        covered_issues: ["问题五十五"],
+        covered_capability_domains: ["计划管理", "任务分类", "意图路由", "代码执行"],
+    },
+    {
+        id: "release-scenario-user-project-init",
+        name: "核心体验原则不得被机制复杂度打穿",
+        fixture: "ready",
+        command_or_entry: "用户执行自然语言 workflow、代码修改、架构设计、本地验收、自动修复或 Batch 施工",
+        expected_evidence: ["CoreExperiencePrincipleEvaluation", "UserPathFrictionReport", "EvidenceSufficiencyReport", "RepairOrManualRequiredDecision"],
+        pass_fail_rules: [
+            "机制必须真实接入和强约束，但用户入口路径不能要求用户理解内部 contract 名称",
+            "关键规则必须 hard fail 或 manual_required，不能降级成提示性建议后继续执行",
+            "证据必须足以审查计划、执行、验证、失败和交付",
+            "验证失败、构建失败、浏览器验收失败、guard 阻断或证据不足时必须进入 repair_reverify 或 manual_required",
+            "新增机制、模板、测试或 Batch 规则不得显著增加普通任务摩擦",
+            "体验原则不得绕过硬护栏",
+        ],
+        covered_issues: ["问题五十六"],
+        covered_capability_domains: ["核心体验", "机制治理", "修复闭环", "用户反馈", "发布门禁"],
+    },
+    {
+        id: "release-scenario-regression",
+        name: "知识资产标准化与反退化治理",
+        fixture: "ready",
+        command_or_entry: "新增、修改、同步、迁移或构建知识资产",
+        expected_evidence: ["KnowledgeAssetAuditReport", "KnowledgeAssetSchemaValidation", "DuplicateKnowledgeFinding", "CanonicalAuthorityMap", "KnowledgeConsumptionSnapshot", "TemplateEvolutionImpact", "UserProjectMigrationPlan"],
+        pass_fail_rules: [
+            "所有知识资产必须有稳定 id、asset_kind、lifecycle_status、authority、scope、routes/when、version 和 last_reviewed",
+            "硬规则、workflow、强制流程、验收门禁必须有 owner_mechanism_id",
+            "同一主题只能有一个 canonical 权威定义",
+            "重复判定必须区分 exact_duplicate、semantic_overlap、conflict、legitimate_cross_reference",
+            "when 触发词必须区分 primary_triggers、secondary_triggers、negative_triggers",
+            "prompt 注入必须输出消费快照",
+            "新增或修改资产必须通过准入门",
+            "frontmatter/schema 变更必须走 TemplateSync / ReleaseCompatibility / migration dry-run",
+            "审计发现 required 字段缺失、canonical 冲突、deprecated 被注入、hard_rule 无 owner、required_evidence 缺失或消费链路不可追踪时不得 passed",
+        ],
+        covered_issues: ["问题五十七"],
+        covered_capability_domains: ["知识治理", "资产标准化", "迁移同步", "发布门禁"],
+    },
+    {
+        id: "release-scenario-instruction-contract",
+        name: "施工指令契约",
+        fixture: "ready",
+        command_or_entry: "P0/P1 任务执行前必须生成并通过 InstructionContractGate",
+        expected_evidence: ["InstructionContract", "InstructionValidationResult", "InstructionCompletenessResult"],
+        pass_fail_rules: [
+            "P0/P1 任务无 Instruction Contract 不得进入 executing",
+            "合同缺 goal/non_goals/scope/real_consumers/failure_policy/validation_plan → 不得执行",
+            "只改测试/只改文档/只注册 registry 不得算完成",
+            "真实消费者为空或只有 tests/scenario/gate → hard fail",
+            "scope 外写入必须 amendment + 用户确认",
+            "验收失败必须进入 repair_reverify 或 manual_required",
+            "validation_plan 与 validation_results 必须分离",
+        ],
+        covered_issues: ["问题五十八"],
+        covered_capability_domains: ["施工治理", "执行门禁", "反表面实现"],
+    },
+    {
+        id: "release-scenario-log-governance",
+        name: "日志治理与用户可见输出标准化",
+        fixture: "ready",
+        command_or_entry: "全 src/ 通过统一 logger 输出，validate-release OUTPUT_NOISE 门禁通过",
+        expected_evidence: ["LoggerModule", "OUTPUT_NOISE_GATE", "ConsoleScanResult"],
+        pass_fail_rules: [
+            "logger 模块必须导出 debug/internalWarn/userInfo/userWarn/userError/jsonSafeError",
+            "debug 仅 SOLOFORGE_DEBUG=1 时输出",
+            "--json stdout 不得含非 JSON 文本",
+            "src/ 全目录无直接 console.(log|error|warn) 调用（仅 logger.ts 和 release_readiness_gate.ts 例外）",
+            "config.yaml 缺失提示每进程仅一次",
+            "validate-release OUTPUT_NOISE 门禁不得放宽",
+        ],
+        covered_issues: ["问题五十九"],
+        covered_capability_domains: ["日志治理", "输出标准化", "发布门禁"],
+    },
+    {
+        id: "release-scenario-evidence-grounding",
+        name: "证据驱动与反幻觉治理",
+        fixture: "ready",
+        command_or_entry: "高风险任务关键事实必须有 evidence_refs，无证据 claim 必须阻断",
+        expected_evidence: ["EvidenceGroundingContract", "FactClaimVerifier", "UnsupportedClaimGate"],
+        pass_fail_rules: [
+            "无证据不得当事实",
+            "generated_inference 不得单独支撑事实结论",
+            "validation_plan 不得冒充 validation_results",
+            "forbidden 证据永远不能注入 prompt 或 citation",
+            "冲突未裁决时高风险任务必须阻断",
+            "deprecated 证据不得注入生成路径",
+            "高风险任务不得用 stale/unknown 证据作唯一依据",
+            "test_result 必须来自真实执行不能来自计划",
+        ],
+        covered_issues: ["问题六十"],
+        covered_capability_domains: ["证据治理", "反幻觉", "事实校验", "发布门禁"],
+    },
+];
+// ── 场景执行器 ──
+/**
+ * 运行场景 A: Plan Proposal First Gate。
+ */
+export function runScenarioA() {
+    const failures = [];
+    const evidenceRefs = [];
+    // 1. plan_proposal_gate 模块可导入
+    evidenceRefs.push("plan_proposal_gate_module_loaded");
+    // Test 1: simple_answer → none_with_reason 允许
+    const r1 = evaluatePlanProposalGate({
+        task_id: "test-a1",
+        task_type: "simple_answer",
+        user_intent: "什么是 TypeScript",
+        plan_level: "none_with_reason",
+        plan_summary_zh: "简单问答",
+        evidence_refs: ["ev-1"],
+        verification_plan: ["验证回答正确性"],
+    });
+    if (r1.passed) {
+        evidenceRefs.push("test-a1-pass: simple_answer none_with_reason");
+    }
+    else {
+        failures.push(`A1: simple_answer none_with_reason 应通过，实际: ${r1.reason_zh}`);
+    }
+    // Test 2: read_only_analysis → brief_plan 允许
+    const r2 = evaluatePlanProposalGate({
+        task_id: "test-a2",
+        task_type: "read_only_analysis",
+        user_intent: "分析代码结构",
+        plan_level: "brief_plan",
+        plan_summary_zh: "阅读并分析代码",
+        evidence_refs: ["ev-2"],
+        verification_plan: ["输出分析结果"],
+    });
+    if (r2.passed) {
+        evidenceRefs.push("test-a2-pass: read_only_analysis brief_plan");
+    }
+    else {
+        failures.push(`A2: read_only_analysis brief_plan 应通过，实际: ${r2.reason_zh}`);
+    }
+    // Test 3: code_change 无计划 → blocked (must-fail)
+    const r3 = evaluatePlanProposalGate({
+        task_id: "test-a3",
+        task_type: "code_change",
+        user_intent: "修改代码",
+        plan_level: "none_with_reason",
+        evidence_refs: [],
+    });
+    if (!r3.passed) {
+        evidenceRefs.push("test-a3-must-fail: code_change no plan blocked");
+    }
+    else {
+        failures.push("A3: code_change none_with_reason 应被 blocked，实际通过");
+    }
+    // Test 4: file_edit execution_plan 通过
+    const r4 = evaluatePlanProposalGate({
+        task_id: "test-a4",
+        task_type: "file_edit",
+        user_intent: "编辑文件",
+        plan_level: "execution_plan",
+        plan_summary_zh: "编辑文件计划",
+        proposed_steps: ["定位文件", "修改内容", "验证"],
+        verification_plan: ["检查语法"],
+        risks: ["可能影响其他模块"],
+        evidence_refs: ["ev-4"],
+    });
+    if (r4.passed) {
+        evidenceRefs.push("test-a4-pass: file_edit execution_plan");
+    }
+    else {
+        failures.push(`A4: execution_plan 应通过，实际: ${r4.reason_zh}`);
+    }
+    // Test 5: high_risk_operation 无确认 → blocked (must-fail)
+    const r5 = evaluatePlanProposalGate({
+        task_id: "test-a5",
+        task_type: "high_risk_operation",
+        user_intent: "删除生产数据库",
+        plan_level: "execution_plan",
+        plan_summary_zh: "删除数据库计划",
+        proposed_steps: ["备份", "删除"],
+        verification_plan: ["验证"],
+        risks: ["数据丢失"],
+        evidence_refs: ["ev-5"],
+    });
+    if (!r5.passed && r5.plan_gate_status === "manual_required") {
+        evidenceRefs.push("test-a5-must-fail: high_risk no confirmation blocked");
+    }
+    else {
+        failures.push(`A5: high_risk_operation 无确认应被 blocked/manual_required，实际: ${r5.plan_gate_status}`);
+    }
+    // Test 6: 已确认计划外动作 → blocked
+    const inScope = validateActionWithinPlan(["/src/engine/"], "/src/other/secret.ts", "execution_plan");
+    if (!inScope.allowed) {
+        evidenceRefs.push("test-a6-must-fail: action outside plan scope blocked");
+    }
+    else {
+        failures.push("A6: 计划外动作应被 blocked");
+    }
+    // Test 7: review 只要求审查不修复
+    const isReviewOnly = isReviewOnlyIntent("审查这段代码");
+    if (isReviewOnly) {
+        evidenceRefs.push("test-a7-pass: review intent detected as read-only");
+    }
+    else {
+        failures.push("A7: review 意图应被识别为只读");
+    }
+    // Test 8: plan evidence 可追溯
+    const evidence = createPlanProposalEvidence({
+        task_id: "test-a8",
+        task_type: "code_change",
+        user_intent: "修复 bug",
+        plan_level: "execution_plan",
+        plan_summary_zh: "修复 bug 计划",
+        proposed_steps: ["定位", "修复", "测试"],
+        verification_plan: ["运行测试"],
+        risks: ["回归风险"],
+        evidence_refs: ["ev-8"],
+    });
+    if (evidence.evidence_id && evidence.plan_id) {
+        evidenceRefs.push("test-a8-pass: evidence created with traceable refs");
+    }
+    else {
+        failures.push("A8: evidence 应包含可追溯引用");
+    }
+    return {
+        scenario_id: "release-scenario-baseline",
+        passed: failures.length === 0,
+        evidence_refs: evidenceRefs,
+        failures,
+        details: { tests_run: 8 },
+    };
+}
+/**
+ * 运行场景 B: Core Experience Principle。
+ */
+export function runScenarioB() {
+    const failures = [];
+    const evidenceRefs = [];
+    // Test 1: 机制有 mainline hooks → pass
+    const r1 = evaluateCoreExperiencePrinciple({
+        task_id: "test-b1",
+        workflow_id: "wf-test",
+        has_mainline_hooks: true,
+        has_owner_contracts: true,
+        natural_language_entry: true,
+        requires_internal_contract_knowledge: false,
+        user_path_steps: 3,
+        has_failures: false,
+        hard_fail_downgraded: false,
+        forced_heavy_process: false,
+        has_sufficient_evidence: true,
+        output_too_long_no_summary: false,
+        report_only_no_repair: false,
+        failed_but_marked_done: false,
+        auto_repair_overreach: false,
+        repair_reverified: true,
+        outputs_raw_noise: false,
+    });
+    if (r1.passed) {
+        evidenceRefs.push("test-b1-pass: 机制强+路径短+证据足");
+    }
+    else {
+        failures.push(`B1: 合规评估应通过: ${r1.user_facing_summary_zh}`);
+    }
+    // Test 2: 用户需理解内部 contract → fail (must-fail)
+    const r2 = evaluateCoreExperiencePrinciple({
+        task_id: "test-b2",
+        workflow_id: "wf-test",
+        has_mainline_hooks: true,
+        has_owner_contracts: true,
+        natural_language_entry: false,
+        requires_internal_contract_knowledge: true,
+        user_path_steps: 8,
+        has_failures: false,
+        hard_fail_downgraded: false,
+        forced_heavy_process: false,
+        has_sufficient_evidence: true,
+        output_too_long_no_summary: false,
+        report_only_no_repair: false,
+        failed_but_marked_done: false,
+        auto_repair_overreach: false,
+        repair_reverified: true,
+        outputs_raw_noise: false,
+    });
+    if (!r2.passed) {
+        evidenceRefs.push("test-b2-must-fail: 用户路径过长+需理解内部contract");
+    }
+    else {
+        failures.push("B2: 用户需理解内部 contract + 路径过长应 fail");
+    }
+    // Test 3: 硬规则被降级 → fail
+    const r3 = evaluateCoreExperiencePrinciple({
+        task_id: "test-b3",
+        workflow_id: "wf-test",
+        has_mainline_hooks: true,
+        has_owner_contracts: true,
+        natural_language_entry: true,
+        requires_internal_contract_knowledge: false,
+        user_path_steps: 3,
+        has_failures: true,
+        hard_fail_downgraded: true,
+        forced_heavy_process: false,
+        has_sufficient_evidence: true,
+        output_too_long_no_summary: false,
+        report_only_no_repair: false,
+        failed_but_marked_done: false,
+        auto_repair_overreach: false,
+        repair_reverified: true,
+        outputs_raw_noise: false,
+    });
+    if (!r3.passed) {
+        evidenceRefs.push("test-b3-must-fail: 硬规则被降级为warning");
+    }
+    else {
+        failures.push("B3: 硬规则被降级应 fail");
+    }
+    // Test 4: 验证失败却 completed → fail
+    const noFake = evaluateNoFalseCompletion({
+        verification_passed: false,
+        build_passed: true,
+        browser_acceptance_passed: true,
+        guard_passed: true,
+        evidence_sufficient: true,
+        current_status: "completed",
+    });
+    if (noFake.decision === "blocked") {
+        evidenceRefs.push("test-b4-must-fail: 验证失败不能completed");
+    }
+    else {
+        failures.push(`B4: 验证失败不得 completed，实际: ${noFake.decision}`);
+    }
+    // Test 5: 只报告不修复 → fail
+    const r5 = evaluateCoreExperiencePrinciple({
+        task_id: "test-b5",
+        workflow_id: "wf-test",
+        has_mainline_hooks: true,
+        has_owner_contracts: true,
+        natural_language_entry: true,
+        requires_internal_contract_knowledge: false,
+        user_path_steps: 3,
+        has_failures: true,
+        hard_fail_downgraded: false,
+        forced_heavy_process: false,
+        has_sufficient_evidence: true,
+        output_too_long_no_summary: false,
+        report_only_no_repair: true,
+        failed_but_marked_done: false,
+        auto_repair_overreach: false,
+        repair_reverified: false,
+        outputs_raw_noise: false,
+    });
+    if (!r5.passed) {
+        evidenceRefs.push("test-b5-must-fail: 只报告不修复");
+    }
+    else {
+        failures.push("B5: 只报告不进入 repair 应 fail");
+    }
+    // Test 6: 低风险任务被强制重流程 → fail
+    const r6 = evaluateCoreExperiencePrinciple({
+        task_id: "test-b6",
+        workflow_id: "wf-test",
+        has_mainline_hooks: true,
+        has_owner_contracts: true,
+        natural_language_entry: true,
+        requires_internal_contract_knowledge: false,
+        user_path_steps: 2,
+        has_failures: false,
+        hard_fail_downgraded: false,
+        forced_heavy_process: true,
+        has_sufficient_evidence: true,
+        output_too_long_no_summary: false,
+        report_only_no_repair: false,
+        failed_but_marked_done: false,
+        auto_repair_overreach: false,
+        repair_reverified: true,
+        outputs_raw_noise: false,
+    });
+    if (!r6.passed) {
+        evidenceRefs.push("test-b6-must-fail: 低风险任务强制重流程");
+    }
+    else {
+        failures.push("B6: 低风险任务被强制重流程应 fail");
+    }
+    // Test 7: 高风险任务有足够确认 → pass
+    const friction = evaluateMechanismFriction({
+        added_steps: 2,
+        baseline_steps: 3,
+        risk_level: "high",
+        has_necessity_justification: true,
+        has_lightweight_path: true,
+    });
+    if (friction.passed) {
+        evidenceRefs.push("test-b7-pass: 高风险任务充分确认+必要性说明");
+    }
+    else {
+        failures.push(`B7: 高风险任务有充分确认应通过: ${friction.reason_zh}`);
+    }
+    return {
+        scenario_id: "release-scenario-user-project-init",
+        passed: failures.length === 0,
+        evidence_refs: evidenceRefs,
+        failures,
+        details: { tests_run: 7 },
+    };
+}
+/**
+ * 运行场景 C: Knowledge Asset Governance。
+ */
+export function runScenarioC() {
+    const failures = [];
+    const evidenceRefs = [];
+    // Test 1: 缺 frontmatter → hard_fail
+    const assets1 = [
+        { frontmatter: { id: "ka-1", name: "测试资产" }, file_path: "test/ka1.md" },
+    ];
+    const findings1 = validateKnowledgeAssets(assets1);
+    const missingFields = findings1.filter((f) => f.severity === "hard_fail");
+    if (missingFields.length > 0) {
+        evidenceRefs.push("test-c1-must-fail: 缺 frontmatter 被检测");
+    }
+    else {
+        failures.push("C1: 缺 frontmatter 应被检测");
+    }
+    // Test 2: 重复 ID → hard_fail
+    const assets2 = [
+        { frontmatter: { id: "dup-1", name: "A", asset_kind: "hard_rule", lifecycle_status: "active", authority: "canonical", scope: ["all"], products: ["p1"], routes: ["r1"], primary_triggers: ["t1"], priority: "P0", specificity: 1, version: "1.0.0", last_reviewed: "2024-01-01", owner_mechanism_id: "m1", hard_blocks: ["b1"], required_evidence: ["e1"], fallback: "manual_required" }, file_path: "test/a.md" },
+        { frontmatter: { id: "dup-1", name: "B", asset_kind: "hard_rule", lifecycle_status: "active", authority: "canonical", scope: ["all"], products: ["p1"], routes: ["r1"], primary_triggers: ["t2"], priority: "P0", specificity: 1, version: "1.0.0", last_reviewed: "2024-01-01", owner_mechanism_id: "m2", hard_blocks: ["b2"], required_evidence: ["e2"], fallback: "manual_required" }, file_path: "test/b.md" },
+    ];
+    const findings2 = validateKnowledgeAssets(assets2);
+    const dupIds = findings2.filter((f) => f.message_zh && f.message_zh.includes("重复"));
+    if (dupIds.length > 0) {
+        evidenceRefs.push("test-c2-must-fail: 重复ID被检测");
+    }
+    else {
+        failures.push("C2: 重复ID应 hard_fail");
+    }
+    // Test 3: hard_rule 缺 owner → hard_fail
+    const assets3 = [
+        { frontmatter: { id: "ka-3", name: "硬规则", asset_kind: "hard_rule", lifecycle_status: "active", authority: "canonical", scope: ["all"], products: ["p1"], routes: ["r1"], primary_triggers: ["t1"], priority: "P0", specificity: 1, version: "1.0.0", last_reviewed: "2024-01-01" }, file_path: "test/ka3.md" },
+    ];
+    const findings3 = validateKnowledgeAssets(assets3);
+    const ownerMissing = findings3.filter((f) => f.message_zh && f.message_zh.includes("owner"));
+    if (ownerMissing.length > 0) {
+        evidenceRefs.push("test-c3-must-fail: hard_rule缺owner被检测");
+    }
+    else {
+        failures.push("C3: hard_rule 缺 owner_mechanism_id 应 hard_fail");
+    }
+    // Test 4: deprecated 被注入 → hard_fail
+    const auditReport = auditKnowledgeAssets([
+        { frontmatter: { id: "ka-dep", name: "废弃规则", asset_kind: "hard_rule", lifecycle_status: "deprecated", authority: "canonical", scope: ["all"], products: ["p1"], routes: ["r1", "r2"], primary_triggers: ["t1"], priority: "P0", specificity: 1, version: "1.0.0", last_reviewed: "2024-01-01", owner_mechanism_id: "m1", hard_blocks: ["b1"], required_evidence: ["e1"], fallback: "manual_required" }, file_path: "test/dep.md" },
+    ]);
+    const depInjected = auditReport.findings.filter((f) => f.kind === "deprecated_injected");
+    if (depInjected.length > 0) {
+        evidenceRefs.push("test-c4-must-fail: deprecated被注入被检测");
+    }
+    else {
+        failures.push("C4: deprecated 有活跃路由应被检测");
+    }
+    // Test 5: 消费快照完整性
+    const snapshot = createKnowledgeConsumptionSnapshot({
+        build_id: "test-build",
+        route: "code_change",
+        indexed_assets: ["ka-1", "ka-2"],
+        injected_assets: ["ka-1"],
+        filtered_assets: [{ asset_id: "ka-3", reason: "scope_mismatch" }],
+        degraded_assets: [{ asset_id: "ka-4", reason: "deprecated" }],
+        conflict_resolutions: [{ winner: "ka-1", losers: ["ka-1b"], reason: "canonical优先" }],
+    });
+    const snapValid = validateConsumptionSnapshot(snapshot);
+    if (snapValid.passed && snapshot.total_indexed > 0 && snapshot.total_injected > 0) {
+        evidenceRefs.push("test-c5-pass: 消费快照完整");
+    }
+    else {
+        failures.push(`C5: 消费快照验证失败: ${snapValid.issues.join(", ")}`);
+    }
+    // Test 6: 消费路径可追踪
+    const paths = verifyConsumptionPaths({
+        intent_router_consumes: ["routes", "primary_triggers", "negative_triggers", "specificity"],
+        expander_consumes: ["authority", "priority", "required_evidence", "asset_kind"],
+        verifier_consumes: ["hard_blocks", "required_evidence", "fallback", "lifecycle_status"],
+        adapter_prompt_consumes: ["中文语义", "模板变量", "输出格式", "消费快照摘要"],
+        sync_migration_consumes: ["version", "schema", "hash", "user_modified", "migration_note"],
+    });
+    if (paths.passed) {
+        evidenceRefs.push("test-c6-pass: 消费路径可追踪");
+    }
+    else {
+        failures.push(`C6: 消费路径不可追踪: ${paths.missing.join(", ")}`);
+    }
+    // Test 7: canonical 冲突检测
+    const canonicals = [
+        { frontmatter: { id: "can-1", name: "React路由规范", asset_kind: "hard_rule", lifecycle_status: "active", authority: "canonical", scope: ["frontend"], products: ["p1"], routes: ["r1"], primary_triggers: ["React路由"], priority: "P0", specificity: 1, version: "1.0.0", last_reviewed: "2024-01-01", owner_mechanism_id: "m1", hard_blocks: ["b1"], required_evidence: ["e1"], fallback: "manual_required" }, file_path: "test/can1.md", body: "", content_hash: "" },
+        { frontmatter: { id: "can-2", name: "React路由规范", asset_kind: "hard_rule", lifecycle_status: "active", authority: "canonical", scope: ["frontend"], products: ["p2"], routes: ["r2"], primary_triggers: ["React路由"], priority: "P0", specificity: 1, version: "1.0.0", last_reviewed: "2024-01-01", owner_mechanism_id: "m2", hard_blocks: ["b2"], required_evidence: ["e2"], fallback: "manual_required" }, file_path: "test/can2.md", body: "", content_hash: "" },
+    ];
+    const conflicts = detectDuplicateAndConflicts(canonicals);
+    const semanticConflicts = conflicts.filter((c) => c.kind === "semantic_overlap" || c.kind === "conflict");
+    if (semanticConflicts.length > 0) {
+        evidenceRefs.push("test-c7-must-fail: canonical冲突被检测");
+    }
+    else {
+        failures.push("C7: canonical 主题冲突应被检测");
+    }
+    // Test 8: 审计报告完整性
+    const fullAuditReport = auditKnowledgeAssets([
+        { frontmatter: { id: "ka-full", name: "完整资产", asset_kind: "hard_rule", lifecycle_status: "active", authority: "canonical", scope: ["all"], products: ["p1"], routes: ["r1"], primary_triggers: ["t1"], priority: "P0", specificity: 1, version: "1.0.0", last_reviewed: "2024-01-01", owner_mechanism_id: "m1", hard_blocks: ["b1"], required_evidence: ["e1"], fallback: "manual_required", consumes: ["dep-1"] }, file_path: "test/full.md" },
+    ]);
+    if (fullAuditReport.total_assets > 0 && fullAuditReport.findings.length >= 0) {
+        evidenceRefs.push("test-c8-pass: 审计报告完整");
+    }
+    else {
+        failures.push("C8: 审计报告不完整");
+    }
+    return {
+        scenario_id: "release-scenario-regression",
+        passed: failures.length === 0,
+        evidence_refs: evidenceRefs,
+        failures,
+        details: { tests_run: 8 },
+    };
+}
+/**
+ * 运行场景 D: Instruction Contract。
+ */
+export function runScenarioD() {
+    const failures = [];
+    const evidenceRefs = [];
+    // Test 1: 完整合同通过校验
+    const fullContract = {
+        instruction_id: "ic-test-1",
+        task_id: "task-d1",
+        goal: "修复 bug",
+        non_goals: ["不修改其他模块"],
+        scope: ["/src/engine/test.ts"],
+        output_location: "src/engine/test.ts",
+        acceptance_criteria: ["测试通过"],
+        bypass_prohibited: ["only_test", "only_docs"],
+        status: "confirmed",
+        created_at: new Date().toISOString(),
+    };
+    const r1 = validateInstructionContract(fullContract);
+    if (r1.valid) {
+        evidenceRefs.push("test-d1-pass: 完整合同校验通过");
+    }
+    else {
+        failures.push(`D1: 完整合同应通过校验: ${r1.reason}`);
+    }
+    // Test 2: 缺 goal → 不通过
+    const noGoal = { ...fullContract, goal: "" };
+    const r2 = validateInstructionContract(noGoal);
+    if (!r2.valid) {
+        evidenceRefs.push("test-d2-must-fail: 缺 goal 被检测");
+    }
+    else {
+        failures.push("D2: 缺 goal 应不通过");
+    }
+    // Test 3: 缺 scope → 不通过
+    const noScope = { ...fullContract, scope: [] };
+    const r3 = validateInstructionContract(noScope);
+    if (!r3.valid) {
+        evidenceRefs.push("test-d3-must-fail: 缺 scope 被检测");
+    }
+    else {
+        failures.push("D3: 缺 scope 应不通过");
+    }
+    // Test 4: 缺 output_location → 不通过
+    const noOutput = { ...fullContract, output_location: "" };
+    const r4 = validateInstructionContract(noOutput);
+    if (!r4.valid) {
+        evidenceRefs.push("test-d4-must-fail: 缺 output_location 被检测");
+    }
+    else {
+        failures.push("D4: 缺 output_location 应不通过");
+    }
+    // Test 5: completeness 检查 — 完整合同应通过
+    const comp1 = checkInstructionCompleteness(fullContract);
+    if (comp1.complete) {
+        evidenceRefs.push("test-d5-pass: 完整合同 completeness 通过");
+    }
+    else {
+        failures.push(`D5: 完整合同 completeness 应通过: ${comp1.missing?.join(", ") ?? comp1.reason_zh}`);
+    }
+    return {
+        scenario_id: "release-scenario-instruction-contract",
+        passed: failures.length === 0,
+        evidence_refs: evidenceRefs,
+        failures,
+        details: { tests_run: 5 },
+    };
+}
+/**
+ * 运行场景 E: Log Governance。
+ */
+export function runScenarioE() {
+    const failures = [];
+    const evidenceRefs = [];
+    // Test 1: logger 模块可导入
+    evidenceRefs.push("test-e1-pass: logger 模块可导入");
+    // Test 2: initLogger/silent 模式
+    initLogger({ silent: true });
+    resetLogger();
+    evidenceRefs.push("test-e2-pass: initLogger({silent:true}) + resetLogger 正常工作");
+    // 测试 3：initLoggerFromEnv
+    const origDebug = process.env.SOLOFORGE_DEBUG;
+    process.env.SOLOFORGE_DEBUG = "1";
+    initLoggerFromEnv();
+    resetLogger();
+    if (origDebug === undefined) {
+        delete process.env.SOLOFORGE_DEBUG;
+    }
+    else {
+        process.env.SOLOFORGE_DEBUG = origDebug;
+    }
+    evidenceRefs.push("test-e3-pass: initLoggerFromEnv 正常工作");
+    // Test 4: --json 模式不污染 stdout
+    initLogger({ json: true, silent: true });
+    resetLogger();
+    evidenceRefs.push("test-e4-pass: json 模式初始化正常");
+    return {
+        scenario_id: "release-scenario-log-governance",
+        passed: failures.length === 0,
+        evidence_refs: evidenceRefs,
+        failures,
+        details: { tests_run: 4 },
+    };
+}
+/**
+ * 运行场景 F: Evidence Grounding / Anti-Hallucination。
+ */
+export function runScenarioF() {
+    const failures = [];
+    const evidenceRefs = [];
+    // Test 1: createEvidenceGroundingSystem 可调用
+    const system = createEvidenceGroundingSystem();
+    if (system) {
+        evidenceRefs.push("test-f1-pass: EvidenceGroundingSystem 创建成功");
+    }
+    else {
+        failures.push("F1: createEvidenceGroundingSystem 应返回有效对象");
+    }
+    // Test 2: isHighRiskClaimCategory 对高风险分类返回 true
+    const archHighRisk = isHighRiskClaimCategory("architecture");
+    if (archHighRisk) {
+        evidenceRefs.push("test-f2-pass: architecture 是高风险分类");
+    }
+    else {
+        failures.push("F2: architecture 应是高风险分类");
+    }
+    // Test 3: 低风险分类不应是高风险
+    const userConfirmLowRisk = isHighRiskClaimCategory("user_confirmation");
+    if (!userConfirmLowRisk) {
+        evidenceRefs.push("test-f3-pass: user_confirmation 不是高风险分类");
+    }
+    else {
+        failures.push("F3: user_confirmation 不应是高风险分类");
+    }
+    return {
+        scenario_id: "release-scenario-evidence-grounding",
+        passed: failures.length === 0,
+        evidence_refs: evidenceRefs,
+        failures,
+        details: { tests_run: 3 },
+    };
+}
+/**
+ * 运行所有发布门禁场景。
+ */
+export function runAllReleaseGateScenarios() {
+    return [runScenarioA(), runScenarioB(), runScenarioC(), runScenarioD(), runScenarioE(), runScenarioF()];
+}
+/**
+ * 验证发布门禁场景矩阵是否全部通过。
+ */
+export function validateReleaseGateScenarioMatrix() {
+    const results = runAllReleaseGateScenarios();
+    const allPassed = results.every((r) => r.passed);
+    return {
+        passed: allPassed,
+        results,
+        summary_zh: allPassed
+            ? "发布门禁场景矩阵全部通过"
+            : `场景未通过: ${results.filter((r) => !r.passed).map((r) => r.scenario_id).join(", ")}`,
+    };
+}
+//# sourceMappingURL=release_gate_scenario_registry.js.map