soloforge 1.2.8 → 1.2.10

package/dist/engine/dual_layer_mechanism_registry.js

@@ -0,0 +1,1077 @@
+/**
+ * Dual-Layer Mechanism Registry
+ *
+ * 每个机制都必须有"模板层 + 机制层"双层承载:
+ * - 模板层: 告诉 AI 应该怎么做
+ * - 机制层: 验证 AI 是否真的做到
+ *
+ * 模板层降低走偏概率；机制层负责发现、阻断、记录证据并驱动回到修复。
+ *
+ * 完成定义:
+ * Mechanism Done = template_declared + template_consumable
+ *                + code_enforced + evidence_recorded + regression_guarded
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { listBuiltinConsumableAssets } from "./consumable_asset_registry.js";
+import { listMechanismContracts } from "./mechanism_contract_registry.js";
+import { listWorkflowContracts } from "./workflow_contract_registry.js";
+import { getAllCapabilities } from "./capability_registry.js";
+// ── 已知注册表名称 ──
+const KNOWN_REGISTRIES = new Set([
+    "mechanism_contract_registry",
+    "workflow_contract_registry",
+    "tool_invocation_contract_registry",
+    "consumable_asset_registry",
+    "capability_registry",
+    "implementation_roadmap_registry",
+    "artifact_contract_registry",
+    "input_material_contract_registry",
+    "main_path_integration_contract",
+    "command_execution_contract",
+    "config_precedence_contract",
+    "privacy_secret_contract",
+    "user_feedback_contract",
+    "decision_contract",
+    "dual_layer_mechanism_registry",
+]);
+// ── 契约到 LayerMap 的转换 ──
+function contractToLayerMap(c) {
+    return {
+        mechanism_id: c.mechanism_id,
+        mechanism_name: c.mechanism_name,
+        owner_issue_id: c.owner_issue_id,
+        priority: c.priority,
+        template_assets: c.template_layer.assets,
+        template_consumers: c.template_layer.injected_routes,
+        code_enforcers: c.enforcement_layer.enforcers,
+        code_entrypoints: c.enforcement_layer.entrypoints,
+        registries: c.enforcement_layer.registries,
+        evidence_outputs: c.evidence_layer.outputs,
+        diagnostics: c.evidence_layer.diagnostic_codes,
+        tests: c.verification_layer.tests,
+        status: c.status,
+        layer_status: c.status,
+        injected_routes: c.template_layer.injected_routes,
+        injected_workflows: c.template_layer.injected_workflows,
+        target_hosts: c.template_layer.target_hosts,
+        language_policy: c.template_layer.language_policy,
+        state_effects: c.enforcement_layer.state_effects,
+        hard_fail_conditions: c.enforcement_layer.hard_fail_conditions,
+        degradation_behavior: c.enforcement_layer.degradation_behavior,
+        reports: c.evidence_layer.reports,
+        task_context_facts: c.evidence_layer.task_context_facts,
+        runtime_checks: c.verification_layer.runtime_checks,
+        regression_cases: c.verification_layer.regression_cases,
+        drift_checks: c.verification_layer.drift_checks,
+    };
+}
+// ── Dual-Layer Mechanism Contracts (P0/P1/P2) ──
+const MECHANISM_CONTRACTS = [
+    // ── 1. 意图路由 ──
+    {
+        mechanism_id: "mc-intent-router",
+        mechanism_name: "意图路由",
+        owner_issue_id: "问题九",
+        priority: "P0",
+        template_layer: {
+            required: true,
+            assets: [
+                { path: "templates/knowledge/rules/意图路由规则.md", asset_kind: "knowledge_rule", consumption_mode: "required" },
+                { path: "templates/knowledge/procedures/意图路由流程.md", asset_kind: "pipeline_procedure", consumption_mode: "supporting" },
+            ],
+            injected_routes: ["code_execution", "read_only_analysis", "single_artifact", "source_extraction", "multi_stage_plan"],
+            injected_workflows: ["code_change", "planning", "review"],
+            target_hosts: ["claude_code"],
+            language_policy: "zh_first",
+        },
+        enforcement_layer: {
+            required: true,
+            enforcers: ["src/engine/intent_router.ts"],
+            registries: ["mechanism_contract_registry"],
+            entrypoints: ["routeIntent", "selectPromptTemplate"],
+            state_effects: ["route_decision → workflow selection", "execution_shape → template selection"],
+            hard_fail_conditions: ["route 未确定就进入 expand", "route 与 execution_shape 矛盾"],
+            degradation_behavior: "route 未命中时降级为 code_execution，不阻断主链路",
+        },
+        evidence_layer: {
+            outputs: ["route_decision", "execution_shape"],
+            reports: ["WorkflowTrace"],
+            diagnostic_codes: ["route-mismatch", "degraded-route"],
+            task_context_facts: ["route", "execution_shape"],
+        },
+        verification_layer: {
+            tests: ["tests/engine/intent_router.test.ts"],
+            runtime_checks: ["route_mismatch_check"],
+            regression_cases: ["unknown_route_defaults_safely", "route_template_consistency"],
+            drift_checks: ["route_decision_matches_workflow_template"],
+        },
+        status: "dual_layer_enforced",
+    },
+    // ── 2. 工作流契约 ──
+    {
+        mechanism_id: "mc-workflow-contract",
+        mechanism_name: "工作流契约",
+        owner_issue_id: "问题九",
+        priority: "P0",
+        template_layer: {
+            required: true,
+            assets: [
+                { path: "templates/knowledge/rules/工作流契约规则.md", asset_kind: "knowledge_rule", consumption_mode: "required" },
+                { path: "templates/knowledge/checklists/工作流验收清单.md", asset_kind: "checklist", consumption_mode: "supporting" },
+            ],
+            injected_routes: ["code_execution", "multi_stage_plan", "single_artifact"],
+            injected_workflows: ["code_change", "verification", "delivery"],
+            target_hosts: ["claude_code"],
+            language_policy: "zh_first",
+        },
+        enforcement_layer: {
+            required: true,
+            enforcers: ["src/engine/workflow_contract_registry.ts"],
+            registries: ["workflow_contract_registry"],
+            entrypoints: ["resolveWorkflow", "validateWorkflowContracts"],
+            state_effects: ["workflow_id → mechanism binding", "required_mechanisms → guard check"],
+            hard_fail_conditions: ["workflow 缺失 required_mechanism", "workflow 与 route 不匹配"],
+            degradation_behavior: "workflow 未命中时降级为默认 workflow，不阻断",
+        },
+        evidence_layer: {
+            outputs: ["WorkflowTrace", "governance_findings"],
+            reports: ["WorkflowValidationReport"],
+            diagnostic_codes: ["workflow-regression", "missing-required-mechanism"],
+            task_context_facts: ["workflow_id", "mutation_allowed", "required_mechanisms"],
+        },
+        verification_layer: {
+            tests: ["tests/engine/workflow_contract_registry.test.ts"],
+            runtime_checks: ["workflow_contract_validation"],
+            regression_cases: ["all_workflows_have_required_mechanisms", "workflow_route_coverage"],
+            drift_checks: ["workflow_template_matches_route"],
+        },
+        status: "dual_layer_enforced",
+    },
+    // ── 3. 知识注入边界 ──
+    {
+        mechanism_id: "mc-knowledge-injection-boundary",
+        mechanism_name: "知识注入边界",
+        owner_issue_id: "问题八",
+        priority: "P0",
+        template_layer: {
+            required: true,
+            assets: [
+                { path: "templates/knowledge/rules/知识注入边界规则.md", asset_kind: "knowledge_rule", consumption_mode: "required" },
+                { path: "templates/knowledge/checklists/知识注入验收清单.md", asset_kind: "checklist", consumption_mode: "supporting" },
+            ],
+            injected_routes: ["code_execution", "read_only_analysis", "multi_stage_plan"],
+            injected_workflows: ["code_change", "planning"],
+            target_hosts: ["claude_code"],
+            language_policy: "zh_first",
+        },
+        enforcement_layer: {
+            required: true,
+            enforcers: ["src/engine/knowledge_injection_boundary.ts"],
+            registries: ["mechanism_contract_registry"],
+            entrypoints: ["enforceKnowledgeInjectionBoundary", "validateInjectionReport"],
+            state_effects: ["required knowledge 缺失 → blocked prompt", "injection_report → governance_findings"],
+            hard_fail_conditions: ["required knowledge 缺失且无法回退", "注入校验 hard_fail"],
+            degradation_behavior: "knowledge 未命中时降级为空注入，标记 degraded",
+        },
+        evidence_layer: {
+            outputs: ["KnowledgeInjectionReport", "missing_required_knowledge"],
+            reports: ["InjectionBoundaryReport"],
+            diagnostic_codes: ["boundary-violation", "route-template-mismatch"],
+            task_context_facts: ["injected_ids", "missing_required"],
+        },
+        verification_layer: {
+            tests: ["tests/engine/knowledge_injection_boundary.test.ts", "tests/engine/intent_expander_integration.test.ts"],
+            runtime_checks: ["injection_boundary_gate"],
+            regression_cases: ["required_knowledge_blocks_when_missing", "degraded_route_still_works"],
+            drift_checks: ["injection_report_matches_filtered_entries"],
+        },
+        status: "dual_layer_enforced",
+    },
+    // ── 4. 工具调用契约 ──
+    {
+        mechanism_id: "mc-tool-invocation-contract",
+        mechanism_name: "工具调用契约",
+        owner_issue_id: "问题二十二",
+        priority: "P0",
+        template_layer: {
+            required: true,
+            assets: [
+                { path: "templates/knowledge/rules/工具调用规则.md", asset_kind: "knowledge_rule", consumption_mode: "required" },
+                { path: "templates/knowledge/procedures/工具调用流程.md", asset_kind: "pipeline_procedure", consumption_mode: "supporting" },
+            ],
+            injected_routes: ["code_execution", "multi_stage_plan"],
+            injected_workflows: ["code_change", "verification", "delivery"],
+            target_hosts: ["claude_code"],
+            language_policy: "zh_first",
+        },
+        enforcement_layer: {
+            required: true,
+            enforcers: ["src/engine/tool_invocation_contract_registry.ts"],
+            registries: ["tool_invocation_contract_registry"],
+            entrypoints: ["validateToolInvocation"],
+            state_effects: ["forbidden tool → blocked", "strict tool → requires approval"],
+            hard_fail_conditions: ["forbidden tool transition", "strict tool without approval"],
+            degradation_behavior: "tool contract 未命中时降级为 normal，不阻断",
+        },
+        evidence_layer: {
+            outputs: ["ToolInvocationFinding", "forbidden_transition"],
+            reports: ["ToolInvocationReport"],
+            diagnostic_codes: ["forbidden-tool-transition", "strict-tool-without-approval"],
+            task_context_facts: ["next_allowed_tools", "forbidden_tools"],
+        },
+        verification_layer: {
+            tests: ["tests/engine/tool_invocation_contract_registry.test.ts"],
+            runtime_checks: ["tool_transition_gate"],
+            regression_cases: ["no_forbidden_transition_allowed", "strict_tools_require_confirm"],
+            drift_checks: ["tool_contract_matches_adapter_tools"],
+        },
+        status: "dual_layer_enforced",
+    },
+    // ── 5. 验证契约 ──
+    {
+        mechanism_id: "mc-verifier",
+        mechanism_name: "验证契约",
+        owner_issue_id: "问题十二",
+        priority: "P0",
+        template_layer: {
+            required: true,
+            assets: [
+                { path: "templates/knowledge/rules/验证契约规则.md", asset_kind: "knowledge_rule", consumption_mode: "required" },
+                { path: "templates/knowledge/checklists/验证验收清单.md", asset_kind: "checklist", consumption_mode: "supporting" },
+            ],
+            injected_routes: ["code_execution", "multi_stage_plan"],
+            injected_workflows: ["verification", "delivery"],
+            target_hosts: ["claude_code"],
+            language_policy: "zh_first",
+        },
+        enforcement_layer: {
+            required: true,
+            enforcers: ["src/engine/verifier.ts"],
+            registries: ["mechanism_contract_registry"],
+            entrypoints: ["generateVerifyCommands"],
+            state_effects: ["verify → learn", "main_path_integration_failed → retrying"],
+            hard_fail_conditions: ["build failed", "tests failed", "integration check failed"],
+            degradation_behavior: "无 build/test 命令时降级为 plan_only，不阻断",
+        },
+        evidence_layer: {
+            outputs: ["VerifyResult", "evidence"],
+            reports: ["VerificationReport", "CorePrinciplesReport"],
+            diagnostic_codes: ["verification-strategy-mismatch", "evidence-level-insufficient"],
+            task_context_facts: ["verification_result", "build_passed", "tests_passed"],
+        },
+        verification_layer: {
+            tests: ["tests/engine/verifier_phase25.test.ts"],
+            runtime_checks: ["verification_gate"],
+            regression_cases: ["verify_generates_correct_commands", "verify_handles_no_build_gracefully"],
+            drift_checks: ["verify_output_matches_acceptance"],
+        },
+        status: "dual_layer_enforced",
+    },
+    // ── 6. 主链路接入 ──
+    {
+        mechanism_id: "mc-main-path-integration",
+        mechanism_name: "主链路接入防孤岛",
+        owner_issue_id: "问题四十四",
+        priority: "P0",
+        template_layer: {
+            required: true,
+            assets: [
+                { path: "templates/knowledge/rules/防孤岛实现规则.md", asset_kind: "knowledge_rule", consumption_mode: "required" },
+                { path: "templates/knowledge/procedures/主链路接入验证流程.md", asset_kind: "pipeline_procedure", consumption_mode: "required" },
+                { path: "templates/knowledge/checklists/主链路接入验收清单.md", asset_kind: "checklist", consumption_mode: "supporting" },
+            ],
+            injected_routes: ["code_execution", "multi_stage_plan"],
+            injected_workflows: ["verification", "delivery"],
+            target_hosts: ["claude_code"],
+            language_policy: "zh_first",
+        },
+        enforcement_layer: {
+            required: true,
+            enforcers: ["src/engine/main_path_integration_contract.ts"],
+            registries: ["main_path_integration_contract"],
+            entrypoints: ["orphanGate", "auditIntegration", "validateMainPathIntegration"],
+            state_effects: ["orphan detected → retrying", "integration_passed → done"],
+            hard_fail_conditions: ["orphan module detected", "integration test missing for non-trivial module"],
+            degradation_behavior: "integration check 不可用时降级为 advisory",
+        },
+        evidence_layer: {
+            outputs: ["IntegrationAuditReport", "IntegrationFinding", "orphan_id"],
+            reports: ["IntegrationReport"],
+            diagnostic_codes: ["orphan-module", "test-only-module", "unreachable-capability"],
+            task_context_facts: ["integration_result", "orphan_modules"],
+        },
+        verification_layer: {
+            tests: ["tests/adapters/main_path_integration_gate.test.ts"],
+            runtime_checks: ["orphan_scan", "reachability_scan"],
+            regression_cases: ["new_module_must_have_integration_test", "no_orphan_allowed"],
+            drift_checks: ["integration_coverage_matches_registry"],
+        },
+        status: "dual_layer_enforced",
+    },
+    // ── 7. 隐私边界 ──
+    {
+        mechanism_id: "mc-privacy-boundary",
+        mechanism_name: "隐私/敏感信息边界",
+        owner_issue_id: "问题三十二",
+        priority: "P1",
+        template_layer: {
+            required: true,
+            assets: [
+                { path: "templates/knowledge/rules/敏感信息处理规则.md", asset_kind: "knowledge_rule", consumption_mode: "required" },
+                { path: "templates/knowledge/checklists/隐私审查清单.md", asset_kind: "checklist", consumption_mode: "supporting" },
+            ],
+            injected_routes: ["code_execution", "source_extraction", "read_only_analysis"],
+            injected_workflows: ["code_change", "review"],
+            target_hosts: ["claude_code"],
+            language_policy: "zh_first",
+        },
+        enforcement_layer: {
+            required: true,
+            enforcers: ["src/engine/privacy_secret_contract.ts", "src/engine/scope_controller.ts"],
+            registries: ["privacy_secret_contract", "capability_registry"],
+            entrypoints: ["scanTextSensitivity", "evaluatePrivacyGate", "redactSensitiveText"],
+            state_effects: ["secret detected → read blocked", "redaction applied to prompt"],
+            hard_fail_conditions: ["secret in prompt", "PII not redacted", "forbidden source read"],
+            degradation_behavior: "privacy scanner 不可用时保守阻断",
+        },
+        evidence_layer: {
+            outputs: ["RedactionRecord", "PrivacyFinding"],
+            reports: ["PrivacyBoundaryReport"],
+            diagnostic_codes: ["secret-leak", "pii-exposure"],
+            task_context_facts: ["sensitivity_labels", "redaction_records"],
+        },
+        verification_layer: {
+            tests: ["tests/engine/privacy_secret_contract.test.ts"],
+            runtime_checks: ["secret_scan", "pii_detection"],
+            regression_cases: ["env_file_blocked", "token_redacted", ".ssh_forbidden"],
+            drift_checks: ["privacy_rules_match_code_patterns"],
+        },
+        status: "dual_layer_enforced",
+    },
+    // ── 8. 命令执行契约 ──
+    {
+        mechanism_id: "mc-command-execution",
+        mechanism_name: "命令执行契约",
+        owner_issue_id: "问题三十三",
+        priority: "P1",
+        template_layer: {
+            required: true,
+            assets: [
+                { path: "templates/knowledge/rules/命令执行规则.md", asset_kind: "knowledge_rule", consumption_mode: "required" },
+                { path: "templates/knowledge/procedures/命令执行流程.md", asset_kind: "pipeline_procedure", consumption_mode: "supporting" },
+            ],
+            injected_routes: ["code_execution"],
+            injected_workflows: ["verification"],
+            target_hosts: ["claude_code"],
+            language_policy: "zh_first",
+        },
+        enforcement_layer: {
+            required: true,
+            enforcers: ["src/engine/command_execution_contract.ts"],
+            registries: ["command_execution_contract"],
+            entrypoints: ["classifyCommand", "validateCommandExecution"],
+            state_effects: ["destructive command → must_confirm", "unclassified command → blocked"],
+            hard_fail_conditions: ["destructive command without confirmation", "unclassified command"],
+            degradation_behavior: "command classifier 不可用时降级为 advisory",
+        },
+        evidence_layer: {
+            outputs: ["CommandClassification", "CommandExecutionResult"],
+            reports: ["CommandExecutionReport"],
+            diagnostic_codes: ["destructive-command", "unclassified-command"],
+            task_context_facts: ["command_tier", "command_classification"],
+        },
+        verification_layer: {
+            tests: ["tests/engine/command_execution_contract.test.ts"],
+            runtime_checks: ["command_classification_gate"],
+            regression_cases: ["destructive_commands_blocked", "unclassified_command_rejected"],
+            drift_checks: ["command_rules_match_classifier"],
+        },
+        status: "dual_layer_enforced",
+    },
+    // ── 9. 核心工程执行原则 ──
+    {
+        mechanism_id: "mc-core-engineering-principles",
+        mechanism_name: "核心工程执行原则",
+        owner_issue_id: "问题四十六",
+        priority: "P0",
+        template_layer: {
+            required: true,
+            assets: [
+                { path: "templates/knowledge/rules/核心工程执行原则.md", asset_kind: "knowledge_rule", consumption_mode: "required" },
+                { path: "templates/knowledge/checklists/核心工程执行验收清单.md", asset_kind: "checklist", consumption_mode: "supporting" },
+                { path: "templates/knowledge/procedures/编码前澄清流程.md", asset_kind: "pipeline_procedure", consumption_mode: "supporting" },
+            ],
+            injected_routes: ["code_execution", "multi_stage_plan", "single_artifact"],
+            injected_workflows: ["code_change", "verification", "review"],
+            target_hosts: ["claude_code"],
+            language_policy: "zh_first",
+        },
+        enforcement_layer: {
+            required: true,
+            enforcers: ["src/engine/core_engineering_principles.ts"],
+            registries: ["mechanism_contract_registry"],
+            entrypoints: ["checkCorePrinciples", "validateAntiCircumvention"],
+            state_effects: ["principles_failed → repair_reverify", "principles_passed → advance"],
+            hard_fail_conditions: ["required principle failed at L2+", "pseudo-satisfaction detected"],
+            degradation_behavior: "principles module 不可用时降级为 advisory，不阻断",
+        },
+        evidence_layer: {
+            outputs: ["CorePrinciplesReport", "ClarificationNeed", "AssumptionRecord", "GoalDefinition"],
+            reports: ["CorePrinciplesCheckResult"],
+            diagnostic_codes: ["principle-violation", "pseudo-satisfaction", "missing-goal-definition"],
+            task_context_facts: ["core_principles_result", "task_level"],
+        },
+        verification_layer: {
+            tests: ["tests/engine/core_engineering_principles.test.ts"],
+            runtime_checks: ["principle_gate_at_verify"],
+            regression_cases: ["L2_requires_all_principles", "anti_circumvention_catches_pseudo"],
+            drift_checks: ["principle_rules_match_code_checks"],
+        },
+        status: "dual_layer_enforced",
+    },
+    // ── 10. 交付门禁（补齐） ──
+    {
+        mechanism_id: "mc-delivery-gate",
+        mechanism_name: "交付门禁",
+        owner_issue_id: "问题十二",
+        priority: "P0",
+        template_layer: {
+            required: true,
+            assets: [
+                { path: "templates/knowledge/procedures/验证计划流程.md", asset_kind: "pipeline_procedure", consumption_mode: "required" },
+            ],
+            injected_routes: ["code_execution", "multi_stage_plan"],
+            injected_workflows: ["delivery"],
+            target_hosts: ["claude_code"],
+            language_policy: "zh_first",
+        },
+        enforcement_layer: {
+            required: true,
+            enforcers: ["src/engine/delivery.ts"],
+            registries: ["mechanism_contract_registry"],
+            entrypoints: ["deliver", "generateChangelogEntry"],
+            state_effects: ["delivery_ready → deliver", "delivery_blocked → retrying"],
+            hard_fail_conditions: ["delivery without verification", "active write lease conflict"],
+            degradation_behavior: "delivery module 不可用时降级为 manual_required",
+        },
+        evidence_layer: {
+            outputs: ["DeliveryResult", "ArtifactVerificationResult"],
+            reports: ["DeliveryReadinessReport"],
+            diagnostic_codes: ["delivery-without-verify", "lease-conflict"],
+            task_context_facts: ["delivery_status", "artifact_status"],
+        },
+        verification_layer: {
+            tests: ["tests/engine/delivery.test.ts"],
+            runtime_checks: ["delivery_readiness_gate"],
+            regression_cases: ["cannot_deliver_without_verify", "lease_conflict_blocks_delivery"],
+            drift_checks: ["delivery_contract_matches_verifier_output"],
+        },
+        status: "dual_layer_enforced",
+    },
+    // ── 11. 任务上下文生命周期（补齐） ──
+    {
+        mechanism_id: "mc-task-context-lifecycle",
+        mechanism_name: "任务上下文生命周期",
+        owner_issue_id: "问题十七",
+        priority: "P1",
+        template_layer: {
+            required: false,
+            assets: [
+                { path: "templates/knowledge/patterns/core/任务上下文生命周期.md", asset_kind: "capability_knowledge_doc", consumption_mode: "supporting" },
+            ],
+            injected_routes: ["code_execution", "multi_stage_plan", "read_only_analysis"],
+            injected_workflows: ["code_change", "verification", "delivery"],
+            target_hosts: ["claude_code"],
+            language_policy: "zh_first",
+        },
+        enforcement_layer: {
+            required: true,
+            enforcers: ["src/engine/task_context.ts"],
+            registries: ["mechanism_contract_registry"],
+            entrypoints: ["create", "updateStatus", "load"],
+            state_effects: ["status transitions", "fact accumulation"],
+            hard_fail_conditions: ["invalid status transition", "stdout/stderr in TaskContext"],
+            degradation_behavior: "TaskContext 不可用时降级为无状态模式",
+        },
+        evidence_layer: {
+            outputs: ["TaskContext"],
+            reports: ["TaskContextSnapshot"],
+            diagnostic_codes: ["invalid-transition", "forbidden-field"],
+            task_context_facts: ["status", "verification_result", "injection_report"],
+        },
+        verification_layer: {
+            tests: ["tests/engine/task_context.test.ts"],
+            runtime_checks: ["status_transition_gate"],
+            regression_cases: ["no_invalid_transition", "no_stdout_in_context"],
+            drift_checks: ["context_fields_match_spec"],
+        },
+        status: "dual_layer_enforced",
+    },
+    // ── 12. 执行守卫评估（补齐） ──
+    {
+        mechanism_id: "mc-guard-evaluation",
+        mechanism_name: "执行守卫评估",
+        owner_issue_id: "问题十一",
+        priority: "P2",
+        template_layer: {
+            required: true,
+            assets: [
+                { path: "templates/knowledge/rules/执行守卫评估规则.md", asset_kind: "knowledge_rule", consumption_mode: "required" },
+            ],
+            injected_routes: ["code_execution", "multi_stage_plan"],
+            injected_workflows: ["code_change", "verification"],
+            target_hosts: ["claude_code"],
+            language_policy: "zh_first",
+        },
+        enforcement_layer: {
+            required: true,
+            enforcers: ["src/engine/verifier.ts"],
+            registries: ["mechanism_contract_registry"],
+            entrypoints: ["generateVerifyCommands"],
+            state_effects: ["guard_evaluation_executed"],
+            hard_fail_conditions: ["guard_bypass"],
+            degradation_behavior: "guard 评估集成在各契约内，无独立降级",
+        },
+        evidence_layer: {
+            outputs: ["VerifyResult"],
+            reports: ["GuardEvaluationReport"],
+            diagnostic_codes: ["guard-failure"],
+            task_context_facts: ["guard_status"],
+        },
+        verification_layer: {
+            tests: ["tests/engine/verifier_phase25.test.ts"],
+            runtime_checks: ["guard_evaluation_gate"],
+            regression_cases: ["guard_blocks_execution"],
+            drift_checks: ["guard_rules_match_verifier"],
+        },
+        status: "dual_layer_enforced",
+    },
+    // ── 13. 注册表基础设施（补齐） ──
+    {
+        mechanism_id: "mc-registry-infrastructure",
+        mechanism_name: "注册表基础设施",
+        owner_issue_id: "问题五",
+        priority: "P2",
+        template_layer: {
+            required: true,
+            assets: [
+                { path: "templates/knowledge/rules/注册表基础设施规则.md", asset_kind: "knowledge_rule", consumption_mode: "required" },
+            ],
+            injected_routes: ["operation"],
+            injected_workflows: ["init"],
+            target_hosts: ["claude_code"],
+            language_policy: "zh_first",
+        },
+        enforcement_layer: {
+            required: true,
+            enforcers: [
+                "src/engine/mechanism_contract_registry.ts",
+                "src/engine/consumable_asset_registry.ts",
+            ],
+            registries: ["mechanism_contract_registry", "consumable_asset_registry"],
+            entrypoints: ["listMechanismContracts", "listBuiltinConsumableAssets"],
+            state_effects: ["contract registration", "asset discovery"],
+            hard_fail_conditions: ["registry entry missing lifecycle test"],
+            degradation_behavior: "registry 不可用时整体降级",
+        },
+        evidence_layer: {
+            outputs: ["MechanismContract[]", "ConsumableAssetRef[]"],
+            reports: ["RegistryHealthReport"],
+            diagnostic_codes: ["missing-lifecycle-test"],
+            task_context_facts: [],
+        },
+        verification_layer: {
+            tests: ["tests/engine/mechanism_contract_registry.test.ts", "tests/engine/consumable_asset_registry.test.ts"],
+            runtime_checks: ["registry_health_check"],
+            regression_cases: ["all_contracts_have_lifecycle_tests"],
+            drift_checks: ["registry_entries_match_code_modules"],
+        },
+        status: "dual_layer_enforced",
+    },
+    // ── 14. 零配置初始化 ──
+    {
+        mechanism_id: "mc-zero-config-init",
+        mechanism_name: "零配置初始化",
+        owner_issue_id: "问题六",
+        priority: "P1",
+        template_layer: {
+            required: true,
+            assets: [
+                { path: "templates/knowledge/rules/零配置初始化规则.md", asset_kind: "knowledge_rule", consumption_mode: "required" },
+            ],
+            injected_routes: ["operation"],
+            injected_workflows: ["init"],
+            target_hosts: ["claude_code"],
+            language_policy: "zh_first",
+        },
+        enforcement_layer: {
+            required: true,
+            enforcers: ["src/engine/zero_config_init.ts"],
+            registries: ["mechanism_contract_registry"],
+            entrypoints: ["detectFingerprint", "generateConfigDraft", "validateConfigDraft"],
+            state_effects: ["config_initialized"],
+            hard_fail_conditions: ["init without config validation"],
+            degradation_behavior: "降级为手动配置",
+        },
+        evidence_layer: {
+            outputs: ["ProjectConfig"],
+            reports: ["InitReport"],
+            diagnostic_codes: ["config-missing-field"],
+            task_context_facts: ["init_status"],
+        },
+        verification_layer: {
+            tests: ["tests/engine/zero_config_init.test.ts"],
+            runtime_checks: ["init_config_valid"],
+            regression_cases: ["init_without_interactive"],
+            drift_checks: ["init_fields_match_config"],
+        },
+        status: "dual_layer_enforced",
+    },
+    // ── 15. 输入材料契约 ──
+    {
+        mechanism_id: "mc-input-material-contract",
+        mechanism_name: "输入材料契约",
+        owner_issue_id: "问题二十三",
+        priority: "P0",
+        template_layer: {
+            required: true,
+            assets: [
+                { path: "templates/knowledge/rules/输入材料契约规则.md", asset_kind: "knowledge_rule", consumption_mode: "required" },
+            ],
+            injected_routes: ["code_execution", "read_only_analysis", "source_extraction"],
+            injected_workflows: ["expand", "privacy_gate"],
+            target_hosts: ["claude_code"],
+            language_policy: "zh_first",
+        },
+        enforcement_layer: {
+            required: true,
+            enforcers: ["src/engine/input_material_contract_registry.ts"],
+            registries: ["mechanism_contract_registry"],
+            entrypoints: ["canSupportStrongConclusion", "isWriteAllowed"],
+            state_effects: ["material_validated"],
+            hard_fail_conditions: ["unregistered material source"],
+            degradation_behavior: "降级为宽松模式",
+        },
+        evidence_layer: {
+            outputs: ["InputMaterialContract[]"],
+            reports: ["MaterialValidationReport"],
+            diagnostic_codes: ["unregistered-material"],
+            task_context_facts: ["material_status"],
+        },
+        verification_layer: {
+            tests: ["tests/engine/input_material_contract_registry.test.ts"],
+            runtime_checks: ["material_contract_valid"],
+            regression_cases: ["unregistered_source_blocked"],
+            drift_checks: ["material_types_match_registry"],
+        },
+        status: "dual_layer_enforced",
+    },
+    // ── 16. 用户反馈契约（/四十四） ──
+    {
+        mechanism_id: "mc-user-feedback",
+        mechanism_name: "用户反馈契约",
+        owner_issue_id: "问题二十九",
+        priority: "P1",
+        template_layer: {
+            required: true,
+            assets: [
+                { path: "templates/knowledge/rules/用户反馈契约规则.md", asset_kind: "knowledge_rule", consumption_mode: "required" },
+            ],
+            injected_routes: ["code_execution"],
+            injected_workflows: ["verify", "deliver"],
+            target_hosts: ["claude_code"],
+            language_policy: "zh_first",
+        },
+        enforcement_layer: {
+            required: true,
+            enforcers: ["src/engine/user_feedback_contract.ts"],
+            registries: ["mechanism_contract_registry"],
+            entrypoints: ["createUserFeedbackMessage", "validateUserFeedbackContract", "getAllowedFeedbackKinds"],
+            state_effects: ["feedback_generated"],
+            hard_fail_conditions: ["forbidden wording in feedback", "verification_summary masking"],
+            degradation_behavior: "降级为简单消息",
+        },
+        evidence_layer: {
+            outputs: ["UserFeedbackMessage[]", "UserFeedbackGovernanceFinding[]"],
+            reports: ["FeedbackValidationReport"],
+            diagnostic_codes: ["forbidden-wording", "severity-mismatch"],
+            task_context_facts: ["feedback_status"],
+        },
+        verification_layer: {
+            tests: ["tests/engine/user_feedback_contract.test.ts"],
+            runtime_checks: ["feedback_contract_valid"],
+            regression_cases: ["blocked_kind_for_verify"],
+            drift_checks: ["feedback_kinds_match_tools"],
+        },
+        status: "dual_layer_enforced",
+    },
+    // ── 17. 产物契约 ──
+    {
+        mechanism_id: "mc-artifact-contract",
+        mechanism_name: "产物契约",
+        owner_issue_id: "问题二十四",
+        priority: "P1",
+        template_layer: {
+            required: true,
+            assets: [
+                { path: "templates/knowledge/rules/产物契约规则.md", asset_kind: "knowledge_rule", consumption_mode: "required" },
+            ],
+            injected_routes: ["code_execution", "single_artifact"],
+            injected_workflows: ["expand", "deliver"],
+            target_hosts: ["claude_code"],
+            language_policy: "zh_first",
+        },
+        enforcement_layer: {
+            required: true,
+            enforcers: ["src/engine/artifact_contract_registry.ts"],
+            registries: ["mechanism_contract_registry"],
+            entrypoints: ["canTransition", "transitionRequiresVerification"],
+            state_effects: ["artifact_created"],
+            hard_fail_conditions: ["artifact without contract", "overwrite without policy"],
+            degradation_behavior: "降级为手动产物管理",
+        },
+        evidence_layer: {
+            outputs: ["ArtifactContract[]", "OutputArtifact"],
+            reports: ["ArtifactValidationReport"],
+            diagnostic_codes: ["missing-contract", "overwrite-violation"],
+            task_context_facts: ["artifact_status"],
+        },
+        verification_layer: {
+            tests: ["tests/engine/artifact_contract_registry.test.ts"],
+            runtime_checks: ["artifact_contract_valid"],
+            regression_cases: ["no_artifact_without_contract"],
+            drift_checks: ["artifact_types_match_registry"],
+        },
+        status: "dual_layer_enforced",
+    },
+    // ── 18. 配置优先级契约 ──
+    {
+        mechanism_id: "mc-config-precedence",
+        mechanism_name: "配置优先级契约",
+        owner_issue_id: "问题三十七",
+        priority: "P1",
+        template_layer: {
+            required: true,
+            assets: [
+                { path: "templates/knowledge/rules/配置优先级规则.md", asset_kind: "knowledge_rule", consumption_mode: "required" },
+            ],
+            injected_routes: ["operation"],
+            injected_workflows: ["init", "config"],
+            target_hosts: ["claude_code"],
+            language_policy: "zh_first",
+        },
+        enforcement_layer: {
+            required: true,
+            enforcers: ["src/engine/config_precedence_contract.ts"],
+            registries: ["mechanism_contract_registry"],
+            entrypoints: ["listPrecedenceRules", "getPrecedenceRank"],
+            state_effects: ["config_resolved"],
+            hard_fail_conditions: ["invalid source override", "circular dependency"],
+            degradation_behavior: "降级为默认配置",
+        },
+        evidence_layer: {
+            outputs: ["ConfigPrecedenceResult"],
+            reports: ["PrecedenceReport"],
+            diagnostic_codes: ["invalid-override", "circular-dep"],
+            task_context_facts: ["config_source"],
+        },
+        verification_layer: {
+            tests: ["tests/engine/config_precedence_contract.test.ts"],
+            runtime_checks: ["precedence_valid"],
+            regression_cases: ["no_circular_deps"],
+            drift_checks: ["precedence_rules_match_config"],
+        },
+        status: "dual_layer_enforced",
+    },
+];
+// ── 查询函数 ──
+/**
+ * 列出所有机制的层级映射。
+ * @returns 机制层级映射列表
+ */
+export function listMechanismLayerMaps() {
+    console.error("[soloForge] 双层机制: listMechanismLayerMaps() — 共", MECHANISM_CONTRACTS.length, "个契约");
+    return MECHANISM_CONTRACTS.map(contractToLayerMap);
+}
+/**
+ * 根据机制 ID 查找层级映射。
+ * @param id - 机制 ID
+ * @returns 机制层级映射，未找到时返回 undefined
+ */
+export function findLayerMapByMechanismId(id) {
+    console.error("[soloForge] 双层机制: findLayerMapByMechanismId() — id:", id);
+    return MECHANISM_CONTRACTS.map(contractToLayerMap).find((m) => m.mechanism_id === id);
+}
+/**
+ * 按优先级列出机制层级映射。
+ * @param priority - 优先级（P0/P1/P2/P3）
+ * @returns 指定优先级的机制层级映射列表
+ */
+export function listLayerMapsByPriority(priority) {
+    console.error("[soloForge] 双层机制: listLayerMapsByPriority() — priority:", priority);
+    return MECHANISM_CONTRACTS.map(contractToLayerMap).filter((m) => m.priority === priority);
+}
+/**
+ * 按状态列出机制层级映射。
+ * @param status - 双层机制状态
+ * @returns 指定状态的机制层级映射列表
+ */
+export function listLayerMapsByStatus(status) {
+    console.error("[soloForge] 双层机制: listLayerMapsByStatus() — status:", status);
+    return MECHANISM_CONTRACTS.map(contractToLayerMap).filter((m) => m.status === status);
+}
+/**
+ * 检查机制的双层完整性。
+ * 验证模板层、代码层、证据、测试和注册表是否齐全。
+ * @param map - 机制层级映射
+ * @returns 双层完整性检查结果
+ */
+export function checkDualLayerCompleteness(map) {
+    console.error("[soloForge] 双层机制: checkDualLayerCompleteness() — mechanism_id:", map.mechanism_id);
+    const missing = [];
+    const has_template_layer = map.template_assets.length > 0;
+    const has_code_layer = map.code_enforcers.length > 0;
+    const has_evidence = map.evidence_outputs.length > 0;
+    const has_tests = map.tests.length > 0;
+    const has_registries = map.registries.length > 0;
+    if (!has_template_layer)
+        missing.push("template_layer");
+    if (!has_code_layer)
+        missing.push("code_layer");
+    if (!has_evidence)
+        missing.push("evidence");
+    if (!has_tests)
+        missing.push("tests");
+    if (!has_registries)
+        missing.push("registries");
+    if (missing.length > 0) {
+        console.error("[soloForge] 双层机制: 完整性缺失 —", map.mechanism_id, "missing:", missing.join(", "));
+    }
+    return {
+        mechanism_id: map.mechanism_id,
+        has_template_layer,
+        has_code_layer,
+        has_evidence,
+        has_tests,
+        has_registries,
+        is_complete: missing.length === 0,
+        missing,
+    };
+}
+// ── 基础设施文件豁免（这些是注册表本身，不在其他注册表中追踪） ──
+const INFRASTRUCTURE_EXCEPTIONS = new Set([
+    "src/engine/dual_layer_mechanism_registry.ts",
+    "src/engine/mechanism_contract_registry.ts",
+    "src/engine/consumable_asset_registry.ts",
+]);
+// ── 治理验证 ──
+/**
+ * 验证机制层级映射的合规性。
+ * 检查 ID 唯一性、模板/代码缺口、文件存在性、入口点等。
+ * @param maps - 机制层级映射列表（默认使用所有契约）
+ * @param rootDir - 项目根目录（默认当前目录）
+ * @param options.batch1_mode - 是否启用 batch1 模式（可选）
+ * @returns 治理发现列表
+ */
+export function validateMechanismLayerMaps(maps = MECHANISM_CONTRACTS.map(contractToLayerMap), rootDir = process.cwd(), options) {
+    const findings = [];
+    const seenIds = new Set();
+    console.error(`[soloForge] 双层机制: 开始治理验证 — 共 ${maps.length} 个机制`);
+    // 预加载消费资产路径用于交叉验证
+    const consumablePaths = new Set(listBuiltinConsumableAssets().map((a) => a.path));
+    // 预加载已知机制 ID 用于孤立执行器检查
+    const knownMechanismIds = new Set(listMechanismContracts().map((c) => c.id));
+    const knownCapabilityIds = new Set(getAllCapabilities().map((c) => c.id));
+    for (const m of maps) {
+        // 重复 ID
+        if (seenIds.has(m.mechanism_id)) {
+            findings.push({
+                severity: "hard_fail",
+                mechanism_id: m.mechanism_id,
+                finding_type: "drift_gap",
+                message: `Duplicate mechanism_id: ${m.mechanism_id}`,
+            });
+        }
+        seenIds.add(m.mechanism_id);
+        // 模板缺口: 有代码执行器但无模板资产
+        if (m.code_enforcers.length > 0 && m.template_assets.length === 0) {
+            findings.push({
+                severity: m.status === "code_only_enforced" ? "advisory" : "hard_fail",
+                mechanism_id: m.mechanism_id,
+                finding_type: "template_gap",
+                message: `机制 ${m.mechanism_id} 有代码执行器但无模板资产 (template_gap)`,
+            });
+        }
+        // 代码缺口: 有模板资产但无代码执行器
+        if (m.template_assets.length > 0 && m.code_enforcers.length === 0) {
+            findings.push({
+                severity: "hard_fail",
+                mechanism_id: m.mechanism_id,
+                finding_type: "code_gap",
+                message: `机制 ${m.mechanism_id} 有模板资产但无代码执行器 (code_gap)`,
+            });
+        }
+        // 证据缺口
+        if (m.code_enforcers.length > 0 && m.evidence_outputs.length === 0) {
+            findings.push({
+                severity: "advisory",
+                mechanism_id: m.mechanism_id,
+                finding_type: "evidence_gap",
+                message: `机制 ${m.mechanism_id} 有代码执行器但无证据输出`,
+            });
+        }
+        // 测试缺口: 未声明测试
+        if (m.code_enforcers.length > 0 && m.tests.length === 0) {
+            findings.push({
+                severity: "hard_fail",
+                mechanism_id: m.mechanism_id,
+                finding_type: "test_gap",
+                message: `机制 ${m.mechanism_id} 有代码执行器但无测试`,
+            });
+        }
+        // 模板资产: 检查文件是否存在 + 消费资产注册表交叉验证
+        for (const ta of m.template_assets) {
+            // P0/P1/dual_layer_enforced 的资产文件必须存在
+            if (!fs.existsSync(path.join(rootDir, ta.path))) {
+                const severity = (m.priority === "P0" || m.priority === "P1" || m.status === "dual_layer_enforced")
+                    ? "hard_fail" : "advisory";
+                findings.push({
+                    severity,
+                    mechanism_id: m.mechanism_id,
+                    finding_type: "asset_unconsumed",
+                    message: `模板资产文件不存在: ${ta.path}${severity === "hard_fail" ? " (P0/P1/dual_layer_enforced 必须)" : ""}`,
+                });
+            }
+            // 与消费资产注册表交叉验证
+            if (!consumablePaths.has(ta.path)) {
+                findings.push({
+                    severity: "hard_fail",
+                    mechanism_id: m.mechanism_id,
+                    finding_type: "asset_unconsumed",
+                    message: `模板资产 ${ta.path} 存在但未在 Consumable Asset Registry 中注册`,
+                });
+            }
+        }
+        // 检查代码执行器文件是否存在于磁盘
+        for (const ce of m.code_enforcers) {
+            if (!fs.existsSync(path.join(rootDir, ce))) {
+                findings.push({
+                    severity: "hard_fail",
+                    mechanism_id: m.mechanism_id,
+                    finding_type: "code_gap",
+                    message: `代码执行器文件不存在: ${ce}`,
+                });
+            }
+        }
+        // 检查测试文件是否存在于磁盘 — dual_layer_enforced 为 hard_fail
+        for (const t of m.tests) {
+            if (!fs.existsSync(path.join(rootDir, t))) {
+                const severity = m.status === "dual_layer_enforced" ? "hard_fail" : "advisory";
+                findings.push({
+                    severity,
+                    mechanism_id: m.mechanism_id,
+                    finding_type: "test_gap",
+                    message: `测试文件不存在: ${t}${severity === "hard_fail" ? " (dual_layer_enforced 必须)" : ""}`,
+                });
+            }
+        }
+        // 检查代码入口点是否存在于执行器文件中
+        if (m.code_entrypoints.length > 0 && m.code_enforcers.length > 0) {
+            for (const ep of m.code_entrypoints) {
+                let found = false;
+                for (const enforcer of m.code_enforcers) {
+                    const enforcerPath = path.join(rootDir, enforcer);
+                    if (fs.existsSync(enforcerPath)) {
+                        const content = fs.readFileSync(enforcerPath, "utf-8");
+                        if (content.includes(ep) && /export\s+(function|const|async\s+function|class)\s+/.test(content.split(ep)[0].slice(-50) + "export " + ep)) {
+                            found = true;
+                            break;
+                        }
+                        // 简单检查: 仅查找导出名称
+                        const exportPattern = new RegExp(`export\\s+(async\\s+)?(function|const|class|type|interface)\\s+${ep}\\b`);
+                        if (exportPattern.test(content)) {
+                            found = true;
+                            break;
+                        }
+                        // 更简单: 仅检查名称是否作为导出存在
+                        if (content.includes(ep)) {
+                            found = true;
+                            break;
+                        }
+                    }
+                }
+                if (!found) {
+                    findings.push({
+                        severity: "hard_fail",
+                        mechanism_id: m.mechanism_id,
+                        finding_type: "entrypoint_not_found",
+                        message: `代码入口点 ${ep} 在所有强制层文件中未找到`,
+                    });
+                }
+            }
+        }
+        // 注册表名称验证: 注册表必须是已知名称
+        for (const reg of m.registries) {
+            if (!KNOWN_REGISTRIES.has(reg)) {
+                findings.push({
+                    severity: "hard_fail",
+                    mechanism_id: m.mechanism_id,
+                    finding_type: "drift_gap",
+                    message: `registry "${reg}" 不是已知 registry，机制 ${m.mechanism_id} 声明了不存在的 registry`,
+                });
+            }
+        }
+        // 孤立执行器检查: 不可达的代码执行器文件
+        // 来自机制契约注册表、能力注册表或工作流注册表
+        const workflowMechanismIds = new Set(listWorkflowContracts().flatMap((w) => w.required_mechanisms));
+        for (const ce of m.code_enforcers) {
+            const ceNorm = ce.replace(/\\/g, "/");
+            const isKnown = knownMechanismIds.size > 0 && listMechanismContracts().some((mc) => mc.owner_module.replace(/\\/g, "/") === ceNorm);
+            const isCapKnown = knownCapabilityIds.size > 0 && getAllCapabilities().some((cap) => cap.code_files.some((cf) => cf.replace(/\\/g, "/") === ceNorm));
+            // 检查此机制是否被任何工作流的 required_mechanisms 引用
+            const isWorkflowKnown = workflowMechanismIds.has(m.mechanism_id);
+            // 如果执行器文件存在但未在任何注册表中找到，则为孤立
+            if (fs.existsSync(path.join(rootDir, ce)) && !isKnown && !isCapKnown && !isWorkflowKnown && !INFRASTRUCTURE_EXCEPTIONS.has(ceNorm)) {
+                const orphanSeverity = (m.priority === "P0" || m.priority === "P1" || m.status === "dual_layer_enforced")
+                    ? "hard_fail" : "advisory";
+                findings.push({
+                    severity: orphanSeverity,
+                    mechanism_id: m.mechanism_id,
+                    finding_type: "orphan_enforcer",
+                    message: `代码执行器 ${ce} 不在 Mechanism Contract Registry、Capability Registry 或 Workflow Registry 中${orphanSeverity === "hard_fail" ? " (P0/P1/dual_layer_enforced 必须)" : ""}`,
+                });
+            }
+        }
+        // P0/P1 必须为 dual_layer_enforced
+        if ((m.priority === "P0" || m.priority === "P1") && m.status !== "dual_layer_enforced") {
+            findings.push({
+                severity: "hard_fail",
+                mechanism_id: m.mechanism_id,
+                finding_type: "p0_not_dual_layer",
+                message: `P0/P1 机制 ${m.mechanism_id} 必须为 dual_layer_enforced，当前: ${m.status}`,
+            });
+        }
+        // template_only_advisory 不能有代码执行器
+        if (m.status === "template_only_advisory" && m.code_enforcers.length > 0) {
+            findings.push({
+                severity: "hard_fail",
+                mechanism_id: m.mechanism_id,
+                finding_type: "template_mechanism_drift",
+                message: `机制 ${m.mechanism_id} 状态为 template_only_advisory 但存在代码执行器，状态与实际不一致`,
+            });
+        }
+        // code_only_enforced 必须产生 template_gap 发现
+        if (m.status === "code_only_enforced") {
+            findings.push({
+                severity: "advisory",
+                mechanism_id: m.mechanism_id,
+                finding_type: "template_gap",
+                message: `机制 ${m.mechanism_id} 为 code_only_enforced，必须补充模板层`,
+            });
+        }
+    }
+    console.error(`[soloForge] 双层机制: 治理验证完成 — 发现 ${findings.length} 个问题`);
+    return findings;
+}
+//# sourceMappingURL=dual_layer_mechanism_registry.js.map