soloforge 1.5.0 → 2.0.0

package/dist/adapters/claude_code/tools.js

@@ -1,4224 +1,10 @@
-import { debug, internalWarn } from "../../engine/logger.js";
-import { z } from "zod";
-import path from "node:path";
-import { promises as fsp } from "node:fs";
-import crypto from "node:crypto";
-import { normalizePathCandidate } from "../../engine/input_material_extractor.js";
-import { archiveStaleCurrentPointer, detectStaleCurrentTask } from "../../engine/stale_current_task_detector.js";
-import { verifyArtifact } from "../../engine/artifact_contract_registry.js";
-import { verifyRouteDecisionContract } from "../../engine/route_decision_contract_verifier.js";
-import { isSameOrDescendantPath } from "../../engine/path_scope_utils.js";
-import { findToolInvocationContractByName, createToolTrace, validateToolInvocation, hasWriteSideEffect, } from "../../engine/tool_invocation_contract_registry.js";
-import { TOOL_DIAGNOSTIC_CODES } from "../../engine/diagnostic_registry.js";
-function createLazy(loader) {
-    let mod = { loaded: null, promise: null };
-    return () => {
-        if (mod.loaded)
-            return Promise.resolve(mod.loaded);
-        if (!mod.promise)
-            mod.promise = loader().then(m => { mod.loaded = m; return m; });
-        return mod.promise;
-    };
-}
-const lazyClassifier = createLazy(() => import("../../engine/classifier.js"));
-const lazyIntentRouter = createLazy(() => import("../../engine/intent_router.js"));
-const lazyExpander = createLazy(() => import("../../engine/intent_expander.js"));
-const lazyVerifier = createLazy(() => import("../../engine/verifier.js"));
-const lazyEvolver = createLazy(() => import("../../engine/evolver.js"));
-const lazyPlanner = createLazy(() => import("../../engine/task_planner.js"));
-const lazyImpact = createLazy(() => import("../../engine/impact_analyzer.js"));
-const lazyReviewer = createLazy(() => import("../../engine/code_reviewer.js"));
-const lazyDebt = createLazy(() => import("../../engine/debt_tracker.js"));
-const lazyScaffolder = createLazy(() => import("../../engine/scaffolder.js"));
-const lazyDelivery = createLazy(() => import("../../engine/delivery.js"));
-const lazyChangeCoord = createLazy(() => import("../../engine/change_coordinator.js"));
-const lazyTeam = createLazy(() => import("../../engine/team_awareness.js"));
-const lazyContractGuard = createLazy(() => import("../../engine/contract_guard.js"));
-const lazyOnboarding = createLazy(() => import("../../engine/onboarding.js"));
-const lazyGitDeps = createLazy(() => import("../../engine/git_deps.js"));
-const lazyKnowledge = createLazy(() => import("../../engine/knowledge_manager.js"));
-const lazyFeasibility = createLazy(() => import("../../engine/feasibility_checker.js"));
-const lazyDebugger = createLazy(() => import("../../engine/debugger.js"));
-const lazyObservability = createLazy(() => import("../../engine/observability.js"));
-const lazyGovernance = createLazy(() => import("../../engine/governance_report.js"));
-const lazyMigration = createLazy(() => import("../../engine/migration_guard.js"));
-const lazyTestGen = createLazy(() => import("../../engine/test_generator.js"));
-const lazyTestQuality = createLazy(() => import("../../engine/test_quality.js"));
-const lazyDepScan = createLazy(() => import("../../engine/dependency_scanner.js"));
-const lazyDebtReport = createLazy(() => import("../../engine/debt_reporter.js"));
-const lazyExploration = createLazy(() => import("../../engine/exploration.js"));
-const lazyWorkspaceResumer = createLazy(() => import("../../engine/workspace_resumer.js"));
-const lazyLLM = createLazy(() => import("../../engine/llm_gateway.js"));
-const lazyIO = createLazy(() => import("../../engine/io_controller.js"));
-const lazyCapability = createLazy(() => import("../../engine/capability_registry.js"));
-const lazyDecision = createLazy(() => import("../../engine/decision_contract.js"));
-const lazyAnchor = createLazy(() => import("../../engine/cognitive_anchor.js"));
-const lazyJob = createLazy(() => import("../../engine/job_manager.js"));
-const lazyAuditPool = createLazy(() => import("../../engine/audit_pool.js"));
-const lazyEscape = createLazy(() => import("../../engine/escape_report.js"));
-const lazyAuditSampler = createLazy(() => import("../../engine/audit_sampler.js"));
-const lazyCapAdvisor = createLazy(() => import("../../engine/capability_action_advisor.js"));
-const lazyCapState = createLazy(() => import("../../engine/capability_state_store.js"));
-const lazyMainPath = createLazy(() => import("../../engine/main_path_integration_contract.js"));
-const lazyDualLayer = createLazy(() => import("../../engine/dual_layer_mechanism_registry.js"));
-const lazyInputMaterial = createLazy(() => import("../../engine/input_material_contract_registry.js"));
-const lazyConfigPrecedence = createLazy(() => import("../../engine/config_precedence_contract.js"));
-const lazyEnforcementGuard = createLazy(() => import("../../engine/enforcement_guard.js"));
-const lazyWorkspaceLease = createLazy(() => import("../../engine/workspace_lease.js"));
-const lazyDeliveryReadiness = createLazy(() => import("../../engine/delivery_readiness.js"));
-const lazyVerificationContract = createLazy(() => import("../../engine/verification_contract.js"));
-const lazyFailureReport = createLazy(() => import("../../engine/failure_report.js"));
-const lazyDegradation = createLazy(() => import("../../engine/degradation.js"));
-const lazyArchitectureDesign = createLazy(() => import("../../engine/architecture_design_contract.js"));
-const lazyExistingSystemAnalysis = createLazy(() => import("../../engine/existing_system_analysis.js"));
-const lazyCodingReadiness = createLazy(() => import("../../engine/coding_readiness_gate.js"));
-const lazyLocalAcceptance = createLazy(() => import("../../engine/local_docker_acceptance.js"));
-const lazyInstructionContract = createLazy(() => import("../../engine/instruction_contract.js"));
-const lazyTechnologyDecision = createLazy(() => import("../../engine/technology_decision.js"));
-const lazyDetailDiscipline = createLazy(() => import("../../engine/detail_discipline.js"));
-const lazyFirstPrinciples = createLazy(() => import("../../engine/first_principles.js"));
-const lazyBrainstormContract = createLazy(() => import("../../engine/brainstorm_contract.js"));
-const lazyArchitectureWorkshop = createLazy(() => import("../../engine/architecture_decision_workshop.js"));
-const lazyDesignArtifactPack = createLazy(() => import("../../engine/design_artifact_pack.js"));
-const lazyStandardAssetContract = createLazy(() => import("../../engine/standard_asset_contract.js"));
-const lazyDecisionWorkshop = createLazy(() => import("../../engine/decision_workshop.js"));
-const lazyNavigation = createLazy(() => import("../../engine/next_action_planner.js"));
-const lazyOodSolid = createLazy(() => import("../../engine/ood_solid_contract.js"));
-const lazyBackendImplementation = createLazy(() => import("../../engine/backend_implementation_contract.js"));
-const lazyCodeObservability = createLazy(() => import("../../engine/code_maintainability_observability_contract.js"));
-const lazyTraceability = createLazy(() => import("../../engine/traceability.js"));
-const ARCHITECTURE_CONTEXT_PATTERN = /架构|architecture|系统设计|技术方案|现有系统|差距分析|gap.?analysis/i;
-function stripPathLikeReferences(text) {
-    return text.replace(/(^|[\s"'(（])(?:~\/|\.{1,2}\/|\/|[A-Za-z0-9_.-]+\/)[^\s"'，。；,;：:)）]+/g, "$1 ");
-}
-function hasArchitectureIntentSignal(intent) {
-    return ARCHITECTURE_CONTEXT_PATTERN.test(stripPathLikeReferences(intent ?? ""));
-}
-function decodeIndexedJsonString(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return value;
-    const entries = Object.entries(value);
-    if (entries.length === 0)
-        return value;
-    const isIndexedChars = entries.every(([key, entryValue]) => /^\d+$/.test(key) && typeof entryValue === "string" && entryValue.length <= 1);
-    if (!isIndexedChars)
-        return value;
-    const serialized = entries
-        .sort(([a], [b]) => Number(a) - Number(b))
-        .map(([, entryValue]) => entryValue)
-        .join("")
-        .trim();
-    if (!serialized.startsWith("{"))
-        return value;
-    try {
-        return JSON.parse(serialized);
-    }
-    catch {
-        return value;
-    }
-}
 /**
- * 解析 MCP 输入中的契约对象。
- * @description 部分 MCP 客户端会把 z.unknown() 对象参数序列化为 JSON 字符串；
- *              入口层必须兼容字符串对象，避免后续机制访问数组字段时触发 JS 运行时错误。
+ * Backward-compatible re-export shim for tools.
+ *
+ * The MCP Server tools were extracted from this location to `src/server/tools/`.
+ * This shim preserves backward compatibility for any external consumers
+ * that imported from the old path.
  */
-function parseContractObject(value, fieldName) {
-    if (value === undefined || value === null)
-        return {};
-    // 字符串 → 尝试 JSON 解析（可能被 MCP 客户端序列化为 JSON 字符串）
-    let parsed;
-    if (typeof value === "string") {
-        try {
-            parsed = JSON.parse(value);
-        }
-        catch (parseErr) {
-            return { error: `${fieldName} 的 JSON 解析失败: ${parseErr.message}。请检查 JSON 格式是否正确` };
-        }
-    }
-    else {
-        parsed = value;
-    }
-    const candidate = decodeIndexedJsonString(parsed);
-    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
-        return { error: `${fieldName} 必须是 JSON 对象（当前类型: ${Array.isArray(candidate) ? "array" : typeof candidate}）。期望格式请参考 expected_schema` };
-    }
-    return { value: candidate };
-}
-/** 需要通过 parseContractObject 校验的契约字段列表 */
-const CONTRACT_OBJECT_FIELDS = [
-    "architecture_decision_workshop", "decision_workshop",
-    "technology_decision_contract", "technology_decision_record",
-    "detail_discipline_contract", "provided_details",
-    "first_principles_frame", "brainstorm_session",
-    "design_artifact_pack", "ood_solid_summary",
-    "backend_implementation_work_package", "code_observability_work_package",
-];
-/** 需要规范化的字段 */
-const NORMALIZED_FIELDS = {
-    decision_workshop: "decision_workshop",
-};
-// ── Zod Schema 定义 ──
-const ClassifySchema = {
-    intent: z.string().describe("开发者意图描述"),
-    project_path: z.string().optional().describe("项目路径（默认当前目录）"),
-};
-const ExpandSchema = {
-    task_id: z.string().describe("sf_classify 返回的任务 ID"),
-    clarification_answers: z.array(z.string()).optional().describe("对澄清问题的回答"),
-    input_material_confirmations: z.array(z.string()).optional().describe("已确认安全的输入材料路径列表"),
-    architecture_decision_workshop: z.record(z.unknown()).optional().describe("架构设计前六域决策记录。示例 {domains:[{domain:'backend',options:[{id:'opt-a',title:'...'}],recommended_option_id:'opt-a',user_confirmation_ref:'confirm:...'}],status:'confirmed'}"),
-    decision_workshop: z.record(z.unknown()).optional().describe("通用决策研讨合同。示例 {activated_packs:['delivery_validation'],domains:[{domain:'delivery_validation',options:[{id:'opt-a',title:'...'}],recommended_option_id:'opt-a',user_confirmation_ref:'confirm:...'}],status:'confirmed'}"),
-    technology_decision_contract: z.record(z.unknown()).optional().describe("技术决策主权契约。示例 {decision_id:'TECH-001',decision_scope:'architecture',options:[{option_id:'opt-a',title:'A',description:'...'}],recommended_option:'opt-a',rejected_options:[{option:'opt-b',reason:'...'}],evidence:[{claim:'...',supporting_facts:['...']}],falsification:['...'],failure_conditions:['...'],validation_plan:['...'],rollback_or_exit_plan:['...'],human_gate_required:true,human_gate_evidence:'confirm:...',executable_without_human:false}"),
-    technology_decision_record: z.record(z.unknown()).optional().describe("技术决策执行记录。示例 {decision_id:'TECH-001',selected_option:'opt-a',status:'approved',approved_by:'user',evidence_refs:['confirm:...']}"),
-    detail_discipline_contract: z.record(z.unknown()).optional().describe("细节纪律契约。示例 {contract_id:'detail-001',required_dimensions:['boundary','failure_path','rollback'],blocking_dimensions:['boundary'],status:'ready'}"),
-    provided_details: z.record(z.unknown()).optional().describe("细节纪律已提供证据。示例 {boundary:['只检查 readiness，不改代码'],failure_path:['unknown 时标记证据不足'],rollback:['无写入，无需回滚']}"),
-    first_principles_frame: z.record(z.unknown()).optional().describe("高影响任务第一性原理框架。示例 {fundamental_need:'...',known_facts:['...'],assumptions:['...'],candidate_solutions:[{solution_id:'s1',description:'...',complexity:'low'}],simplest_viable_solution:'s1',chosen_solution:'s1',falsification_questions:['...'],why_not_legacy_path:'...'}"),
-    brainstorm_session: z.record(z.unknown()).optional().describe("不确定项/方案选择会话。示例 {trigger:'uncertainty',options:[{option_id:'opt-a',title:'...',description:'...',pros:['...'],cons:['...']}],recommended_option_id:'opt-a',rejected_option_ids:['opt-b'],failure_conditions:['...'],brainstorm_status:'options_ready'}"),
-    design_artifact_pack: z.record(z.unknown()).optional().describe("设计产物包路径映射或复验状态。示例 {status:'implementation_ready',paths:{architecture_document:'docs/architecture/01-架构设计文档.md'},verification_refs:['verification:...']}"),
-    ood_solid_summary: z.record(z.unknown()).optional().describe("复杂编码任务 OOD/SOLID 摘要。示例 {status:'confirmed',responsibilities:['...'],interfaces:['...'],risks:['...'],evidence_refs:['...']}"),
-    backend_implementation_work_package: z.record(z.unknown()).optional().describe("后端接口实现工程工作包。示例 {status:'confirmed',api_boundary:['...'],transaction_boundary:['...'],error_contract:['...'],evidence_refs:['...']}"),
-    code_observability_work_package: z.record(z.unknown()).optional().describe("代码可维护性与可观测性工作包。示例 {status:'confirmed',logging_plan:['...'],comment_plan:['...'],sensitive_logging_policy:'redact',evidence_refs:['...']}"),
-};
-const VerifySchema = {
-    task_id: z.string().describe("任务 ID"),
-    changed_files: z.array(z.string()).describe("本次修改的文件列表"),
-};
-const LearnSchema = {
-    task_id: z.string().describe("任务 ID"),
-    result: z.enum(["success", "failure"]).describe("执行结果"),
-    failure_type: z.enum(["deterministic", "fixable", "scope_insufficient"]).optional().describe("失败类型"),
-    verify_output: z.object({
-        build_passed: z.boolean(),
-        tests_passed: z.boolean(),
-        acceptance_results: z.record(z.string(), z.boolean()).optional(),
-    }).optional().describe("验证输出"),
-    confirm: z.boolean().optional().describe("确认执行学习（写入状态）"),
-    authorized: z.boolean().optional().describe("confirm 的兼容别名"),
-};
-const StatusSchema = {
-    task_id: z.string().optional().describe("任务 ID（不传则查当前任务）"),
-    action: z.enum(["current", "recent", "resume", "cancel", "archive_stale", "retry_expand"]).optional().describe("操作类型"),
-    confirm: z.boolean().optional().describe("确认执行会写入状态的操作，例如 cancel/archive_stale/job_cancel"),
-    authorized: z.boolean().optional().describe("confirm 的兼容别名"),
-    job_id: z.string().optional().describe("Job ID（用于 job_status / job_resume / job_cancel）"),
-    job_action: z.enum(["job_status", "job_resume", "job_cancel"]).optional().describe("Job 操作: 查询状态、从 checkpoint 恢复、取消 job（advisory）"),
-};
-const PlanSchema = {
-    task_id: z.string().describe("sf_classify 返回的任务 ID"),
-};
-const AnalyzeSchema = {
-    task_id: z.string().describe("sf_expand 返回的任务 ID（需要先执行 expand）"),
-};
-const ReviewSchema = {
-    task_id: z.string().describe("任务 ID"),
-    changed_files: z.array(z.string()).describe("本次修改的文件列表"),
-    file_contents: z.record(z.string(), z.string()).optional().describe("变更文件的当前内容（key=文件路径，value=文件内容），不传则自动读取"),
-};
-const ScaffoldSchema = {
-    task_id: z.string().describe("sf_classify 返回的任务 ID（task_type 应为 scaffold）"),
-};
-const RecordVerificationExecutionSchema = {
-    task_id: z.string().describe("任务 ID"),
-    plan_id: z.string().describe("关联的 VerificationPlan ID"),
-    execution_records: z.array(z.object({
-        command: z.string().describe("执行的验证命令"),
-        exit_code: z.number().describe("命令退出码，0 表示通过"),
-        stdout_hash: z.string().describe("stdout 的 SHA256 hash"),
-        stderr_hash: z.string().describe("stderr 的 SHA256 hash"),
-        started_at: z.string().describe("命令开始时间 ISO 8601"),
-        finished_at: z.string().describe("命令结束时间 ISO 8601"),
-        evidence_id: z.string().describe("执行证据 ID"),
-    })).describe("真实执行记录列表"),
-};
-const AcceptSchema = {
-    task_id: z.string().describe("任务 ID"),
-    confirm: z.boolean().describe("用户显式确认验收结果，必须为 true"),
-    confirmed_by: z.string().describe("执行确认的用户或审批者标识"),
-    confirmation_ref: z.string().describe("可审计的用户确认引用"),
-    acceptance_notes: z.string().describe("验收备注或不适用理由"),
-    run_mode: z.enum(["manual_review", "not_applicable"]).describe("验收模式"),
-    final_access: z.object({
-        frontend_urls: z.array(z.string()),
-        backend_urls: z.array(z.string()),
-        docs_or_swagger_urls: z.array(z.string()),
-        start_commands: z.array(z.string()),
-        stop_commands: z.array(z.string()),
-        running_status: z.string(),
-        manual_review_steps_zh: z.array(z.string()),
-        known_limits_zh: z.array(z.string()),
-    }).optional().describe("manual_review 模式下的真实本地访问证据"),
-};
-const DeliverSchema = {
-    task_id: z.string().describe("任务 ID"),
-    changed_files: z.array(z.string()).optional().describe("变更文件列表（不传则使用任务记录中的文件）"),
-    skip_push: z.boolean().optional().describe("跳过推送"),
-    skip_pr: z.boolean().optional().describe("跳过 PR 创建"),
-    confirm: z.boolean().optional().describe("确认执行交付（破坏性操作）"),
-    authorized: z.boolean().optional().describe("confirm 的兼容别名"),
-};
-const CoordCheckSchema = {
-    task_id: z.string().optional().describe("任务 ID（用于获取变更文件列表）"),
-    branch: z.string().optional().describe("指定分支（不传则使用当前分支）"),
-};
-const TeamStatusSchema = {
-    since: z.string().optional().describe("起始日期（ISO 格式，默认 7 天前）"),
-    include_knowledge: z.boolean().optional().describe("包含知识库更新信息"),
-};
-const ContractCheckSchema = {
-    task_id: z.string().describe("任务 ID"),
-    changed_files: z.array(z.string()).optional().describe("变更文件列表（不传则从任务记录获取）"),
-};
-const OnboardSchema = {
-    step: z.enum(["project_overview", "code_tour", "knowledge_review", "first_task"]).optional().describe("当前引导步骤"),
-    reset: z.boolean().optional().describe("重置引导会话"),
-};
-const FeasibilityCheckSchema = {
-    task_id: z.string().describe("任务 ID（需要已完成 classify）"),
-};
-const DebugSchema = {
-    error_output: z.string().describe("错误输出文本"),
-    task_id: z.string().optional().describe("关联任务 ID"),
-};
-const ObservabilitySchema = {
-    period_days: z.number().optional().describe("报告周期天数（默认 30）"),
-};
-const MigrationCheckSchema = {
-    content: z.string().describe("迁移文件内容（SQL/DDL）"),
-    filename: z.string().describe("文件名（如 V001__create_users.sql）"),
-};
-const TestGuideSchema = {
-    changed_files: z.array(z.string()).describe("变更文件列表"),
-};
-const TestQualitySchema = {
-    content: z.string().describe("测试文件内容"),
-    filename: z.string().describe("测试文件名"),
-};
-const DependencyScanSchema = {
-    content: z.string().describe("依赖声明文件内容（package.json / pom.xml / build.gradle）"),
-    filename: z.string().describe("文件名"),
-};
-const ExploreSchema = {
-    domain_query: z.string().describe("技术选型领域关键词（如：分布式锁、流式处理、复杂表单状态管理、缓存策略）"),
-    task_id: z.string().optional().describe("关联任务 ID（可选，用于关联项目上下文）"),
-};
-// ── 工具注册 ──
-/**
- * 注册所有 SoloForge MCP 工具。
- * @description 核心注册函数，将全部 MCP 工具注册到指定的 McpServer 实例。
- *              包含：sf_classify、sf_expand、sf_verify、sf_learn、sf_status、
- *              sf_plan、sf_plan_advance、sf_analyze、sf_review、sf_scaffold、
- *              sf_deliver、sf_coord_check、sf_team_status、sf_contract_check、
- *              sf_onboard、sf_feasibility_check、sf_debug、sf_observability、
- *              sf_migration_check、sf_test_guide、sf_test_quality、sf_dependency_scan、
- *              sf_debt_report、sf_explore、sf_knowledge_audit/add/update、sf_resume_workspace。
- * @param server - MCP 服务器实例
- * @param deps - SoloForge 核心依赖项
- */
-/**
- * Plan Gate 写工具拦截 — 从 registerSafeTool 中间件提取的纯函数。
- * gate 和外部测试可直接调用，无需 MCP server mock。
- */
-export function checkWriteToolPlanGate(params) {
-    if (!hasWriteSideEffect(params.sideEffects))
-        return { allowed: true };
-    if (!params.ctx || !params.ctx.plan_proposal_gate) {
-        return {
-            allowed: false,
-            diagnostic_code: TOOL_DIAGNOSTIC_CODES.planGate,
-            violation_type: "guard_blocked",
-            reason: `工具 ${params.toolName} 执行前缺少 Plan Proposal Gate`,
-        };
-    }
-    return { allowed: true };
-}
-/**
- * 施工指令契约门 — 写操作前检查施工指令完整性。
- * 通过引擎模块函数真实消费。
- * 调用链 1: registerInstructionIssueCandidate（无契约时创建候选 draft）
- * 调用链 2: enforceInstructionBeforeImplementation → checkInstructionCompleteness → validateInstructionContract
- */
-export async function checkInstructionContractGate(params) {
-    if (!hasWriteSideEffect(params.sideEffects))
-        return { allowed: true };
-    if (!params.ctx)
-        return { allowed: true };
-    let instruction = params.ctx.instruction_contract;
-    const instrModule = await lazyInstructionContract();
-    // 无契约时消费 registerInstructionIssueCandidate — 创建 draft 候选并保存
-    if (!instruction && params.task_id) {
-        instruction = instrModule.registerInstructionIssueCandidate({
-            task_id: params.task_id,
-            description: params.toolName,
-            source: "auto_detected",
-            suggested_fields: {},
-        });
-        params.ctx.instruction_contract = instruction;
-        if (params.taskContextMgr) {
-            await params.taskContextMgr.save(params.ctx);
-        }
-    }
-    if (!instruction)
-        return { allowed: true };
-    // 消费 enforceInstructionBeforeImplementation（链式消费 checkInstructionCompleteness + validateInstructionContract）
-    const result = await instrModule.enforceInstructionBeforeImplementation(instruction, params.toolName);
-    // Draft 状态不阻断 — 仅在 confirmed/executing/blocked 状态时强制
-    if (instruction?.status === "draft") {
-        return { allowed: true, findings: result.allowed ? [] : [result.reason_zh] };
-    }
-    if (!result.allowed) {
-        return {
-            allowed: false,
-            diagnostic_code: result.diagnostic_code,
-            violation_type: "guard_blocked",
-            reason: result.reason_zh,
-        };
-    }
-    return { allowed: true };
-}
-/**
- * 设计产物编码门 — 依赖设计包的任务，在真实复验完成前不得写入业务实现。
- * 仅阻断文件/配置/外部交付写入；任务状态、设计文档复验和讨论本身仍可推进。
- */
-export function checkDesignArtifactWriteGate(params) {
-    const implementationWrite = params.sideEffects.some((effect) => ["file_write", "config_write", "external_write", "git_commit", "git_push", "pr_create"].includes(effect));
-    if (!implementationWrite || !params.ctx?.design_artifact_pack)
-        return { allowed: true };
-    if (params.ctx.design_artifact_pack.status === "implementation_ready")
-        return { allowed: true };
-    return {
-        allowed: false,
-        diagnostic_code: "SF-DESIGN-PACK-NOT-READY",
-        reason: `工具 ${params.toolName} 依赖的设计产物包状态为 ${params.ctx.design_artifact_pack.status}，未完成真实复验，不得写入实现或交付`,
-    };
-}
-/**
- * 架构设计门 — 架构设计类任务膨胀前执行 reviewArchitectureDesign。
- * Architecture Design Contract enforcement。
- */
-export async function checkArchitectureDesignGate(params) {
-    const route = params.route;
-    if (route !== "artifact_generation" && route !== "analysis")
-        return { allowed: true };
-    if (!params.ctx)
-        return { allowed: true };
-    const expansion = params.ctx.expansion;
-    if (!expansion)
-        return { allowed: true };
-    const archModule = await lazyArchitectureDesign();
-    const contract = expansion.architecture_contract;
-    if (contract) {
-        const result = archModule.reviewArchitectureDesign(contract);
-        if (!result.passed) {
-            return {
-                allowed: false,
-                reason_zh: "架构设计审查未通过",
-                findings: result.review.missing_sections ?? ["架构设计审查失败"],
-            };
-        }
-    }
-    return { allowed: true };
-}
-/**
- * 架构决策研讨门 — 正式架构设计前六域决策必须闭合。
- * 与是否存在施工指令契约无关，架构设计路由必经此门。
- */
-export async function checkArchitectureDecisionWorkshopGate(params) {
-    const workshopModule = await lazyArchitectureWorkshop();
-    if (!workshopModule.requiresArchitectureDecisionWorkshop(params.workflowIntent, params.ctx.intent)) {
-        return { allowed: true };
-    }
-    const existing = params.ctx.architecture_decision_workshop;
-    const contract = existing ?? workshopModule.createArchitectureDecisionWorkshop(params.ctx.task_id, params.projectContext ?? "new_system");
-    if (params.projectContext === "existing_system" && contract.project_context !== "existing_system") {
-        contract.project_context = "existing_system";
-    }
-    const evaluatedContract = workshopModule.applyArchitectureWorkshopGate(contract) ?? contract;
-    const gate = workshopModule.evaluateArchitectureDecisionWorkshop(evaluatedContract);
-    params.ctx.architecture_decision_workshop = evaluatedContract;
-    return {
-        allowed: gate.allowed,
-        findings: gate.blocking_findings,
-        next_domain: gate.next_domain,
-        contract: evaluatedContract,
-    };
-}
-/**
- * 现有系统分析门 — 现有项目编码前必须先做分析。
- * Existing System Analysis Contract enforcement。
- */
-export async function checkExistingSystemAnalysisGate(params) {
-    const archModule = await lazyExistingSystemAnalysis();
-    const context = archModule.detectProjectContext(params.hasExistingCode, params.hasPackageJson, params.hasSrcDir);
-    const gateResult = archModule.checkAnalysisGate(context, params.hasAnalysis, params.hasGapAnalysis);
-    if (!gateResult.allowed) {
-        return {
-            allowed: false,
-            reason_zh: gateResult.reason,
-            missing_analysis: gateResult.missing_analysis,
-        };
-    }
-    return { allowed: true };
-}
-/**
- * 编码就绪门 — 编码前必须有测试计划 + 验收标准。
- * Coding Readiness / Test-First enforcement。
- */
-export async function checkCodingReadinessGate(params) {
-    if (!params.ctx)
-        return { allowed: true };
-    const readinessModule = await lazyCodingReadiness();
-    const contract = params.ctx.coding_readiness_contract;
-    if (!contract) {
-        return {
-            allowed: true,
-            reason_zh: "无编码就绪契约（非编码任务），放行",
-        };
-    }
-    const result = readinessModule.evaluateCodingReadiness(contract, false, false, false);
-    if (!result.allowed) {
-        return {
-            allowed: false,
-            reason_zh: result.reason,
-            missing_preconditions: result.missing_preconditions,
-        };
-    }
-    return { allowed: true };
-}
-/**
- * 本地验收门 — 前端/全栈交付前必须有本地访问证据。
- * Local Docker / Browser Acceptance enforcement。
- */
-export async function checkLocalAcceptanceGate(params) {
-    const acceptanceModule = await lazyLocalAcceptance();
-    const requirement = acceptanceModule.requiresLocalAcceptance(params.hasFrontend, params.hasBackend, params.hasDockerCompose, params.hasDockerfile);
-    if (!requirement.required)
-        return { allowed: true };
-    if (!params.ctx) {
-        return {
-            allowed: false,
-            reason_zh: "需要本地验收但无任务上下文",
-            required_but_missing: ["local_acceptance_evidence"],
-        };
-    }
-    const evidence = params.ctx.local_acceptance_evidence;
-    if (!evidence) {
-        return {
-            allowed: false,
-            reason_zh: `项目需要本地验收（模式: ${requirement.run_mode}）但缺少验收证据`,
-            required_but_missing: ["local_acceptance_evidence", "final_access_url"],
-        };
-    }
-    if (evidence.run_mode === "not_applicable") {
-        return {
-            allowed: false,
-            reason_zh: "该项目需要本地验收，不得以 not_applicable 代替真实访问证据",
-            required_but_missing: ["manual_review", "final_access_url"],
-        };
-    }
-    const finalAccessResult = acceptanceModule.validateFinalAccess(evidence.final_access, requirement.run_mode);
-    if (!finalAccessResult.passed) {
-        return {
-            allowed: false,
-            reason_zh: `本地验收证据不完整: ${finalAccessResult.blocking_reasons.join("; ")}`,
-            required_but_missing: ["validated_final_access"],
-        };
-    }
-    return { allowed: true };
-}
-// ── S4 触发判定函数 ──
-// 不依赖 hasInstructionContract，基于 route + intent 风险信号判断是否需要 enforcement。
-// 关键设计: 不是所有 code_change 都触发，只有 intent 含高风险/复杂信号时才触发。
-// 低风险场景（skip_chat / direct_answer / 无风险信号的 code_change）不触发。
-const HIGH_IMPACT_KEYWORDS = /架构|技术选型|数据库|框架|多端|跨模块|高影响|高风险|migration|技术路线|选型|rework/i;
-const UNCERTAINTY_KEYWORDS = /不确定|方案选择|多选项|权衡|脑暴|brainstorm|多方案|选型|比较/i;
-const DETAIL_INTENSIVE_KEYWORDS = /多步骤|复杂|跨模块|高风险|多端|分布式|微服务/i;
-const LOW_RISK_ROUTES = new Set(["skip_chat", "direct_answer", "operation", "planning", "review", "source_extraction", "acceptance"]);
-/** 技术选型/架构/数据库/框架/高影响决策 → 需 decision sovereignty gate */
-export function requiresDecisionSovereignty(ctx, route) {
-    if (!ctx)
-        return false;
-    const routeVal = route ?? ctx.classification?.route_decision?.route ?? ctx.route_decision?.route;
-    if (!routeVal || LOW_RISK_ROUTES.has(routeVal))
-        return false;
-    // 所有路由都要求 intent 含高影响信号
-    const hasHighImpact = ctx.intent && HIGH_IMPACT_KEYWORDS.test(ctx.intent);
-    if (!hasHighImpact) {
-        // instruction_contract 的 risk/high_impact 也可作为信号
-        const ic = ctx.instruction_contract;
-        if (!ic || (!ic.risk && !ic.high_impact))
-            return false;
-        if (ic.risk !== "high" && !ic.high_impact)
-            return false;
-    }
-    // artifact_generation / analysis / code_change + 高影响 intent → 触发
-    return true;
-}
-/** 多步骤/不确定/高风险任务 → 需 detail discipline gate */
-export function requiresDetailDiscipline(ctx, route) {
-    if (!ctx)
-        return false;
-    const routeVal = route ?? ctx.classification?.route_decision?.route ?? ctx.route_decision?.route;
-    if (!routeVal || LOW_RISK_ROUTES.has(routeVal))
-        return false;
-    // 复杂 intent 触发
-    const hasComplexSignals = ctx.intent && DETAIL_INTENSIVE_KEYWORDS.test(ctx.intent);
-    if (!hasComplexSignals) {
-        const ic = ctx.instruction_contract;
-        if (!ic || (!ic.risk && !ic.high_impact))
-            return false;
-        if (ic.risk !== "high" && !ic.high_impact)
-            return false;
-    }
-    return true;
-}
-/** 高影响任务/架构设计/复杂编码/跨模块变更 → 需 first principles gate */
-export function requiresFirstPrinciples(ctx, route) {
-    if (!ctx)
-        return false;
-    const routeVal = route ?? ctx.classification?.route_decision?.route ?? ctx.route_decision?.route;
-    if (!routeVal || LOW_RISK_ROUTES.has(routeVal))
-        return false;
-    // 所有路由都要求 intent 含高影响信号
-    const hasHighImpact = ctx.intent && HIGH_IMPACT_KEYWORDS.test(ctx.intent);
-    if (!hasHighImpact) {
-        const ic = ctx.instruction_contract;
-        if (!ic || (!ic.risk && !ic.high_impact))
-            return false;
-        if (ic.risk !== "high" && !ic.high_impact)
-            return false;
-    }
-    return true;
-}
-/** 不确定项/方案选择/多选项 → 需 brainstorm gate */
-export function requiresBrainstorm(ctx, route) {
-    if (!ctx)
-        return false;
-    const routeVal = route ?? ctx.classification?.route_decision?.route ?? ctx.route_decision?.route;
-    if (!routeVal || LOW_RISK_ROUTES.has(routeVal))
-        return false;
-    // 仅当 intent 含不确定性信号时才触发
-    const hasUncertainty = ctx.intent && UNCERTAINTY_KEYWORDS.test(ctx.intent);
-    if (!hasUncertainty)
-        return false;
-    if (routeVal === "analysis" || routeVal === "artifact_generation")
-        return true;
-    if (routeVal === "code_change")
-        return true;
-    const ic = ctx.instruction_contract;
-    if (ic && ic.uncertainty)
-        return true;
-    return false;
-}
-/**
- * 技术选型决策门 — 高影响技术决策需用户确认。
- * Decision Sovereignty enforcement。
- * 不依赖 hasInstructionContract — 触发由 requiresDecisionSovereignty 判定。
- */
-export async function checkDecisionSovereigntyGate(params) {
-    if (!params.ctx)
-        return { allowed: true, not_applicable_with_reason: "无任务上下文" };
-    const triggered = requiresDecisionSovereignty(params.ctx, params.route);
-    if (!triggered) {
-        return { allowed: true, not_applicable_with_reason: "非高影响技术决策场景，跳过 decision sovereignty gate" };
-    }
-    const decisionContract = params.ctx.technology_decision_contract;
-    if (!decisionContract) {
-        return { allowed: false, reason_zh: "高影响技术决策场景缺 technology_decision_contract，无法执行决策主权校验" };
-    }
-    const decisionModule = await lazyTechnologyDecision();
-    const validation = decisionModule.validateTechnologyDecision(decisionContract);
-    if (!validation.valid) {
-        return { allowed: false, reason_zh: `技术选型决策校验失败: ${validation.violations.join("; ")}`, expected_schema: validation.expected_schema };
-    }
-    // 有决策记录时评估执行状态
-    const decisionRecord = params.ctx.technology_decision_record;
-    if (decisionRecord) {
-        const evaluation = decisionModule.evaluateDecisionExecution(decisionContract, decisionRecord);
-        if (evaluation.requires_human_gate && !decisionContract.human_gate_evidence) {
-            return { allowed: false, reason_zh: "高影响技术决策需用户确认（human gate），请提供确认证据", requires_human_gate: true };
-        }
-        if (!evaluation.allowed) {
-            return { allowed: false, reason_zh: evaluation.reason };
-        }
-    }
-    else {
-        // 无决策记录: 契约已验证通过，但需 human_gate_evidence 确认（如有高范围决策）
-        if (decisionContract.human_gate_required && !decisionContract.human_gate_evidence) {
-            return { allowed: false, reason_zh: "高影响技术决策需用户确认（human gate），请提供确认证据", requires_human_gate: true };
-        }
-    }
-    return { allowed: true };
-}
-/**
- * 细节纪律门 — 复杂任务缺关键细节维度时阻断。
- * Detail Discipline enforcement。
- * 不依赖 hasInstructionContract — 触发由 requiresDetailDiscipline 判定。
- */
-export async function checkDetailDisciplineGate(params) {
-    if (!params.ctx)
-        return { allowed: true, not_applicable_with_reason: "无任务上下文" };
-    const triggered = requiresDetailDiscipline(params.ctx, params.route);
-    if (!triggered) {
-        return { allowed: true, not_applicable_with_reason: "非复杂/多步骤任务场景，跳过 detail discipline gate" };
-    }
-    const detailContract = params.ctx.detail_discipline_contract;
-    if (!detailContract) {
-        return { allowed: false, reason_zh: "多步骤/复杂任务缺 detail_discipline_contract，无法执行细节纪律校验" };
-    }
-    const detailModule = await lazyDetailDiscipline();
-    const check = detailModule.performDetailCheck(detailContract, detailContract.contract_id ?? "unknown", "implementation", params.ctx.provided_details ?? {});
-    if (check.blocking) {
-        const riskItems = detailModule.generateRiskItems(check);
-        const blockingLabels = riskItems.filter(r => r.severity === "blocking").map(r => r.dimension ?? r.description);
-        return { allowed: false, reason_zh: `任务方案缺关键细节: ${blockingLabels.join("; ")}`, missing_details: blockingLabels };
-    }
-    return { allowed: true };
-}
-/**
- * 第一性原理门 — 高影响任务需目标/约束/本质问题/权衡。
- * First Principles enforcement。
- * 不依赖 hasInstructionContract — 触发由 requiresFirstPrinciples 判定。
- */
-export async function checkFirstPrinciplesGate(params) {
-    if (!params.ctx)
-        return { allowed: true, not_applicable_with_reason: "无任务上下文" };
-    const triggered = requiresFirstPrinciples(params.ctx, params.route);
-    if (!triggered) {
-        return { allowed: true, not_applicable_with_reason: "非高影响任务场景，跳过 first principles gate" };
-    }
-    const fpFrame = params.ctx.first_principles_frame;
-    if (!fpFrame) {
-        return { allowed: false, reason_zh: "高影响任务缺 first_principles_frame，无法执行第一性原理校验" };
-    }
-    const fpModule = await lazyFirstPrinciples();
-    const validation = fpModule.validateFirstPrinciplesForHighImpact(fpFrame);
-    if (!validation.passed) {
-        return { allowed: false, reason_zh: `高影响任务缺第一性原理推理: ${validation.violations.join("; ")}`, failures: validation.violations, expected_schema: validation.expected_schema };
-    }
-    return { allowed: true };
-}
-/**
- * 脑暴/方案探索门 — 不确定项需多方案+推荐理由+用户确认。
- * Brainstorm Contract enforcement。
- * 不依赖 hasInstructionContract — 触发由 requiresBrainstorm 判定。
- */
-export async function checkBrainstormGate(params) {
-    if (!params.ctx)
-        return { allowed: true, not_applicable_with_reason: "无任务上下文" };
-    const triggered = requiresBrainstorm(params.ctx, params.route);
-    if (!triggered) {
-        return { allowed: true, not_applicable_with_reason: "非不确定/方案选择场景，跳过 brainstorm gate" };
-    }
-    const brainstormSession = params.ctx.brainstorm_session;
-    if (!brainstormSession) {
-        return { allowed: false, reason_zh: "不确定项/方案选择缺 brainstorm_session，无法执行方案探索校验" };
-    }
-    const brainstormModule = await lazyBrainstormContract();
-    const validation = brainstormModule.validateBrainstormSession(brainstormSession);
-    if (!validation.valid) {
-        return { allowed: false, reason_zh: `方案探索不完整: ${validation.violations.join("; ")}`, violations: validation.violations, expected_schema: validation.expected_schema };
-    }
-    // 脑暴推荐永远不能自动执行 — 需 Decision Sovereignty human gate
-    const canAutoExec = brainstormModule.canBrainstormAutoExecute(brainstormSession);
-    if (canAutoExec) {
-        return { allowed: false, reason_zh: "脑暴推荐不能绕过用户确认，需通过 Decision Sovereignty human gate" };
-    }
-    return { allowed: true };
-}
-/**
- */
-export async function assessCepAfterVerification(params) {
-    const cepModule = await import("../../engine/core_experience_principle.js");
-    const result = cepModule.evaluateCoreExperiencePrinciple({
-        task_id: params.task_id,
-        workflow_id: "sf_verify",
-        has_mainline_hooks: true,
-        has_owner_contracts: true,
-        natural_language_entry: true,
-        requires_internal_contract_knowledge: false,
-        user_path_steps: 3,
-        has_failures: params.has_failures ?? false,
-        hard_fail_downgraded: params.hard_fail_downgraded ?? false,
-        forced_heavy_process: false,
-        has_sufficient_evidence: params.has_verification_evidence,
-        output_too_long_no_summary: false,
-        report_only_no_repair: false,
-        failed_but_marked_done: params.failed_but_marked_done ?? false,
-        auto_repair_overreach: false,
-        repair_reverified: false,
-        outputs_raw_noise: false,
-    });
-    return {
-        passed: result.passed,
-        violations: result.violations.map((v) => ({
-            principle: v.principle,
-            severity: v.severity,
-            reason_zh: v.reason_zh ?? "",
-            required_action: v.required_action,
-        })),
-        evaluated_principles: result.evaluated_principles,
-    };
-}
-/**
- * CEP 集成: 交付前 false completion 检查 — 从 sf_deliver handler 提取的真实主链路函数。
- * 返回 CEP 决策（blocked/repair_reverify/allowed），由 handler 和 gate 共用。
- */
-export async function assessCepBeforeDelivery(params) {
-    const cepModule = await import("../../engine/core_experience_principle.js");
-    const nfcResult = cepModule.evaluateNoFalseCompletion({
-        verification_passed: params.verification_passed,
-        build_passed: params.build_passed,
-        browser_acceptance_passed: params.browser_acceptance_passed,
-        guard_passed: params.guard_passed,
-        evidence_sufficient: params.evidence_sufficient,
-        current_status: params.current_status,
-    });
-    return {
-        decision: nfcResult.decision,
-        reason_zh: nfcResult.reason_zh ?? "",
-        passed: nfcResult.decision === "completed",
-    };
-}
-/**
- * CEP 集成: 工作流解析后评估 — 检查机制是否接入真实主链路、用户路径是否过短。
- */
-export async function assessCepAfterWorkflowResolve(params) {
-    const cepModule = await import("../../engine/core_experience_principle.js");
-    const result = cepModule.evaluateCoreExperiencePrinciple({
-        task_id: params.task_id,
-        workflow_id: "workflow_resolve",
-        has_mainline_hooks: params.workflow_resolved,
-        has_owner_contracts: params.workflow_resolved,
-        natural_language_entry: true,
-        requires_internal_contract_knowledge: false,
-        user_path_steps: 3,
-        has_failures: !params.workflow_resolved,
-        hard_fail_downgraded: false,
-        forced_heavy_process: false,
-        has_sufficient_evidence: params.workflow_resolved,
-        output_too_long_no_summary: false,
-        report_only_no_repair: false,
-        failed_but_marked_done: false,
-        auto_repair_overreach: false,
-        repair_reverified: false,
-        outputs_raw_noise: false,
-    });
-    return {
-        passed: result.passed,
-        violations: result.violations.map((v) => ({
-            principle: v.principle,
-            severity: v.severity,
-            reason_zh: v.reason_zh ?? "",
-        })),
-        evaluated_principles: result.evaluated_principles,
-    };
-}
-/**
- * CEP 集成: 护栏评估后检查 — 硬规则是否被降级、低风险是否过重。
- */
-export async function assessCepAfterGuardEvaluation(params) {
-    const cepModule = await import("../../engine/core_experience_principle.js");
-    const result = cepModule.evaluateCoreExperiencePrinciple({
-        task_id: params.task_id,
-        workflow_id: "guard_evaluation",
-        has_mainline_hooks: true,
-        has_owner_contracts: true,
-        natural_language_entry: true,
-        requires_internal_contract_knowledge: false,
-        user_path_steps: 3,
-        has_failures: !params.guard_passed,
-        hard_fail_downgraded: params.hard_fail_downgraded,
-        forced_heavy_process: params.is_low_risk && !params.guard_passed,
-        has_sufficient_evidence: params.guard_passed,
-        output_too_long_no_summary: false,
-        report_only_no_repair: false,
-        failed_but_marked_done: false,
-        auto_repair_overreach: false,
-        repair_reverified: false,
-        outputs_raw_noise: false,
-    });
-    return {
-        passed: result.passed,
-        violations: result.violations.map((v) => ({
-            principle: v.principle,
-            severity: v.severity,
-            reason_zh: v.reason_zh ?? "",
-        })),
-        evaluated_principles: result.evaluated_principles,
-    };
-}
-/**
- * CEP 集成: 修复重验证决策 — 检查是否假完成、是否进入正确修复路径。
- */
-export async function assessCepForRepairReverify(params) {
-    const cepModule = await import("../../engine/core_experience_principle.js");
-    const nfcResult = cepModule.evaluateNoFalseCompletion({
-        verification_passed: params.verification_passed,
-        build_passed: params.build_passed,
-        browser_acceptance_passed: true,
-        guard_passed: true,
-        evidence_sufficient: params.evidence_sufficient,
-        current_status: params.current_status,
-    });
-    return {
-        decision: nfcResult.decision,
-        reason_zh: nfcResult.reason_zh ?? "",
-        passed: nfcResult.decision === "completed",
-    };
-}
-/**
- * CEP 集成: 用户反馈输出质量 — 检查结论优先、摘要清晰、不隐藏失败、中文语义。
- */
-export async function assessCepForUserFeedback(params) {
-    const cepModule = await import("../../engine/core_experience_principle.js");
-    const cep = cepModule.evaluateUserVisibleOutput({
-        has_conclusion_first: params.has_conclusion_first,
-        has_clear_summary: params.has_clear_summary,
-        has_actionable_next_step: params.has_actionable_next_step,
-        exposes_internal_noise: params.exposes_internal_noise,
-        hides_critical_failure: params.hides_critical_failure,
-        chinese_semantic_first: params.chinese_semantic_first,
-    });
-    const logGov = await import("../../engine/log_governance.js");
-    const logReport = logGov.evaluateFeedbackOutputQuality({
-        output: [
-            params.has_conclusion_first ? "结论优先" : "缺少结论",
-            params.has_clear_summary ? "摘要清晰" : "摘要不足",
-            params.has_actionable_next_step ? "下一步明确" : "下一步缺失",
-        ].join("；"),
-        critical_failure_hidden: params.hides_critical_failure,
-    });
-    return {
-        passed: cep.passed && logReport.passed,
-        issues_zh: [
-            ...cep.issues_zh,
-            ...logReport.findings.map((f) => f.message_zh),
-        ],
-    };
-}
-/**
- * 注册所有 MCP 工具到服务器实例。
- * @param server - McpServer 实例
- * @param deps - 工具依赖项（配置、知识索引、任务上下文）
- */
-export async function registerTools(server, deps) {
-    debug("工具注册", "开始注册 MCP 工具...");
-    const { config, knowledgeIndex, taskContext } = deps;
-    const projectPath = config._projectPath || process.cwd();
-    // H1: LLM Gateway — Token 预算熔断，防止单任务 Token 超支
-    const gateway = deps.gateway ?? new (await lazyLLM()).LLMGateway();
-    // H4: IO Controller — 工作区互斥锁，防止外部修改导致的静默覆盖
-    const ioController = new (await lazyIO()).IOController(projectPath);
-    // ── 统一网关 : 唯一工具调用边界 ──
-    /** 计算 sf_status cancel 的动态 category */
-    function computeEffectiveCategory(toolName, args, contract) {
-        if (toolName === "sf_status" && (args.action === "cancel" || args.action === "archive_stale" || args.job_action === "job_cancel")) {
-            return "normal_controlled";
-        }
-        return contract.category;
-    }
-    /** 计算 sf_status cancel 的动态 side_effects */
-    function computeEffectiveSideEffects(toolName, args, contract) {
-        if (toolName === "sf_status" && (args.action === "cancel" || args.action === "archive_stale" || args.job_action === "job_cancel")) {
-            return ["task_context_write"];
-        }
-        return contract.side_effects;
-    }
-    /** State precheck: validate task status before contract guard */
-    const STATE_PRECHECKS = {
-        sf_accept: ["executing", "verifying", "retrying"],
-        sf_verify: ["executing", "retrying"],
-        sf_record_verification_execution: ["verifying", "executing"],
-        sf_learn: ["verifying", "executing"],
-        sf_expand: ["classifying", "expanding", "clarifying"],
-    };
-    const STATE_ERROR_LABELS = {
-        sf_accept: "不可验收",
-        sf_verify: "不可验证",
-        sf_record_verification_execution: "不可录入验证结果",
-        sf_learn: "不可学习",
-        sf_expand: "不可膨胀",
-    };
-    /** 授权模型: explicit > dynamic write gate > destructive gate > workflow gate > category default */
-    function checkAuth(toolName, args, contract, ctx, effectiveCategory) {
-        // 1. 显式确认
-        if (args.confirm === true || args.authorized === true || args.authorization_token) {
-            return { required: true, granted: true, reason: "explicit confirmation" };
-        }
-        // 1b. sf_status 的写入型动作必须显式确认，即便普通查询本身允许自动维护状态。
-        if (toolName === "sf_status" && (args.action === "cancel" || args.action === "archive_stale" || args.job_action === "job_cancel")) {
-            return { required: true, granted: false, reason: "dynamic write upgrade requires explicit confirmation" };
-        }
-        // 2. 动态写入升级: cancel/job_cancel 从 read_only 变为 write → 必须确认
-        if (effectiveCategory && effectiveCategory !== contract.category && effectiveCategory !== "read_only_bypass") {
-            return { required: true, granted: false, reason: "dynamic write upgrade requires explicit confirmation" };
-        }
-        // 3. 破坏性副作用始终需要显式确认
-        const destructive = ["git_commit", "git_push", "pr_create", "external_write"];
-        if (contract.side_effects.some((e) => destructive.includes(e))) {
-            return { required: true, granted: false, reason: "destructive side effects require explicit confirmation" };
-        }
-        // 4. 独立严格工具（无 workflow 要求，无 task context）→ 由 handler 自行检查
-        if (contract.category === "strict_controlled" && !ctx && !contract.requires_workflow) {
-            if (contract.requires_authorization) {
-                return { required: true, granted: false, reason: "standalone strict tool requires explicit confirmation" };
-            }
-            return { required: false, granted: true, reason: "standalone strict tool" };
-        }
-        // 5. strict_controlled 的 workflow 合同门控
-        if (contract.category === "strict_controlled" && ctx?.last_tool_trace) {
-            const allowed = ctx.last_tool_trace.next_allowed_tools ?? [];
-            if (allowed.includes(toolName)) {
-                return { required: true, granted: true, reason: "workflow contract gate" };
-            }
-        }
-        // 5b. 基于状态的回退: 严格工具且任务处于有效状态但无 tool_trace
-        if (contract.category === "strict_controlled" && ctx && !ctx.last_tool_trace && contract.requires_workflow) {
-            const validStates = STATE_PRECHECKS[toolName];
-            if (validStates && validStates.includes(ctx.status)) {
-                return { required: true, granted: true, reason: "task in valid state for tool" };
-            }
-        }
-        // 5c. 非严格工具: 自动授权，除非 requires_authorization
-        if (contract.category === "read_only_bypass" || contract.category === "normal_controlled") {
-            if (contract.requires_authorization) {
-                return { required: true, granted: false, reason: "tool requires explicit authorization" };
-            }
-            return { required: false, granted: true, reason: "non-strict category" };
-        }
-        return { required: true, granted: false, reason: "no authorization source" };
-    }
-    function registerSafeTool(name, desc, schema, handler) {
-        server.tool(name, desc, schema, async (args) => {
-            const invocationId = `inv-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-            const taskId = args.task_id;
-            const contract = findToolInvocationContractByName(name);
-            // 无合同 → hard fail
-            if (!contract) {
-                return {
-                    content: [{ type: "text", text: JSON.stringify({ error: `工具 ${name} 未注册契约` }) }],
-                    isError: true,
-                };
-            }
-            const effectiveCategory = computeEffectiveCategory(name, args, contract);
-            const effectiveSideEffects = computeEffectiveSideEffects(name, args, contract);
-            // 加载 TaskContext
-            let ctx = null;
-            if (taskId) {
-                ctx = await taskContext.load(taskId);
-            }
-            // 状态预检: 在合同守卫之前验证任务状态
-            if (taskId && STATE_PRECHECKS[name] && ctx) {
-                const validStates = STATE_PRECHECKS[name];
-                if (!validStates.includes(ctx.status)) {
-                    const label = STATE_ERROR_LABELS[name] ?? "状态不正确";
-                    return {
-                        content: [{ type: "text", text: JSON.stringify({
-                                    error: `任务状态 ${ctx.status} ${label}，需要 ${validStates.join(" 或 ")}`,
-                                    status: ctx.status,
-                                }) }],
-                        isError: true,
-                    };
-                }
-            }
-            // 严格受控但缺少 task_id
-            const isStandaloneStrict = !contract.requires_workflow;
-            if (contract.category === "strict_controlled" && !taskId && !isStandaloneStrict) {
-                return {
-                    content: [{ type: "text", text: JSON.stringify({ error: `strict controlled 工具 ${name} 需要 task_id` }) }],
-                    isError: true,
-                };
-            }
-            // 授权检查
-            const authorization = checkAuth(name, args, contract, ctx ?? undefined, effectiveCategory);
-            // 授权拒绝 → 仅对网关级拒绝执行 hard fail
-            // （动态写入升级、破坏性操作、无授权源的 strict_controlled）
-            // Handler 级授权（如 sf_capability_update confirm）由 handler 自行处理
-            const gatewayDenial = !authorization.granted &&
-                authorization.reason !== "tool requires explicit authorization";
-            if (gatewayDenial) {
-                const blockedTrace = createToolTrace({
-                    tool_name: name, invocation_id: invocationId, task_id: taskId,
-                    actual_side_effects: effectiveSideEffects,
-                    next_allowed_tools: contract.default_next_tools,
-                    forbidden_tools: contract.forbidden_next_tools,
-                    authorization, bypass: undefined,
-                });
-                const authViolation = {
-                    invocation_id: invocationId, tool_name: name,
-                    violation_type: "missing_authorization", severity: "hard_fail",
-                    reason: authorization.reason ?? "authorization denied",
-                    recovery: "提供 confirm=true / authorized=true / authorization_token",
-                };
-                if (taskId && ctx) {
-                    await taskContext.setToolTrace(taskId, blockedTrace, [authViolation]);
-                }
-                return {
-                    content: [{ type: "text", text: JSON.stringify({
-                                error: authViolation.reason, violation: authViolation,
-                                tool_trace: blockedTrace,
-                                next_allowed_tools: contract.default_next_tools,
-                                forbidden_tools: contract.forbidden_next_tools,
-                            }) }],
-                    isError: true,
-                };
-            }
-            // read_only_bypass 的旁路处理
-            const bypass = effectiveCategory === "read_only_bypass"
-                ? { allowed: true, reason: "read_only" } : undefined;
-            // 计划前置门: 在合同验证之前检查 — 写工具必须有 plan_proposal_gate
-            // sf_classify 创建任务、sf_expand 创建 plan_proposal_gate — 两者豁免
-            const hasWriteEffect = hasWriteSideEffect(effectiveSideEffects);
-            const planGateExempt = name === "sf_classify" || name === "sf_expand";
-            if (hasWriteEffect && taskId && !planGateExempt) {
-                const pgResult = checkWriteToolPlanGate({ ctx, toolName: name, sideEffects: effectiveSideEffects });
-                if (!pgResult.allowed) {
-                    const planViolation = {
-                        invocation_id: invocationId, tool_name: name,
-                        violation_type: "guard_blocked", severity: "hard_fail",
-                        reason: pgResult.reason ?? "执行前缺少 Plan Proposal Gate",
-                        recovery: "先调用 sf_classify → sf_expand → 设置 plan_proposal_gate 后再执行此工具",
-                    };
-                    const blockedTrace = createToolTrace({
-                        tool_name: name, invocation_id: invocationId, task_id: taskId,
-                        actual_side_effects: effectiveSideEffects,
-                        next_allowed_tools: contract.default_next_tools,
-                        forbidden_tools: contract.forbidden_next_tools,
-                        authorization, bypass,
-                    });
-                    await taskContext.setToolTrace(taskId, blockedTrace, [planViolation]);
-                    return {
-                        content: [{ type: "text", text: JSON.stringify({
-                                    error: planViolation.reason,
-                                    violation: planViolation,
-                                    diagnostic_code: pgResult.diagnostic_code ?? TOOL_DIAGNOSTIC_CODES.planGate,
-                                    recovery: planViolation.recovery,
-                                }) }],
-                        isError: true,
-                    };
-                }
-                const planGateCheck = taskContext.checkPlanGateBeforeWrite(ctx);
-                if (!planGateCheck.allowed) {
-                    const planViolation = {
-                        invocation_id: invocationId, tool_name: name,
-                        violation_type: "guard_blocked", severity: "hard_fail",
-                        reason: planGateCheck.reason_zh,
-                        recovery: "请先通过 PlanProposalFirstGate 生成并确认执行计划",
-                    };
-                    const blockedTrace = createToolTrace({
-                        tool_name: name, invocation_id: invocationId, task_id: taskId,
-                        actual_side_effects: effectiveSideEffects,
-                        next_allowed_tools: contract.default_next_tools,
-                        forbidden_tools: contract.forbidden_next_tools,
-                        authorization, bypass,
-                    });
-                    await taskContext.setToolTrace(taskId, blockedTrace, [planViolation]);
-                    return {
-                        content: [{ type: "text", text: JSON.stringify({
-                                    error: planViolation.reason,
-                                    violation: planViolation,
-                                    diagnostic_code: TOOL_DIAGNOSTIC_CODES.planGate,
-                                    recovery: planViolation.recovery,
-                                }) }],
-                        isError: true,
-                    };
-                }
-            }
-            // 施工指令契约门: 写操作前检查 instruction_contract 状态
-            if (hasWriteEffect && taskId) {
-                const instrResult = await checkInstructionContractGate({ ctx, toolName: name, sideEffects: effectiveSideEffects, task_id: taskId, taskContextMgr: taskContext });
-                if (!instrResult.allowed) {
-                    const instrViolation = {
-                        invocation_id: invocationId, tool_name: name,
-                        violation_type: "guard_blocked", severity: "hard_fail",
-                        reason: instrResult.reason ?? "施工指令未就绪",
-                        recovery: "请先完善施工指令（目标、范围、非目标、落点、验收标准、禁止绕过项）",
-                    };
-                    const instrTrace = createToolTrace({
-                        tool_name: name, invocation_id: invocationId, task_id: taskId,
-                        actual_side_effects: effectiveSideEffects,
-                        next_allowed_tools: contract.default_next_tools,
-                        forbidden_tools: contract.forbidden_next_tools,
-                        authorization, bypass,
-                    });
-                    await taskContext.setToolTrace(taskId, instrTrace, [instrViolation]);
-                    return {
-                        content: [{ type: "text", text: JSON.stringify({
-                                    error: instrViolation.reason,
-                                    violation: instrViolation,
-                                    diagnostic_code: instrResult.diagnostic_code ?? TOOL_DIAGNOSTIC_CODES.instructionContract,
-                                    recovery: instrViolation.recovery,
-                                }) }],
-                        isError: true,
-                    };
-                }
-            }
-            // 问题六十二: MCP 写入路径同样必须消费设计产物包状态，不能绕开 CLI hook。
-            if (hasWriteEffect && taskId) {
-                const designWriteGate = checkDesignArtifactWriteGate({ ctx, toolName: name, sideEffects: effectiveSideEffects });
-                if (!designWriteGate.allowed) {
-                    const designViolation = {
-                        invocation_id: invocationId, tool_name: name,
-                        violation_type: "guard_blocked", severity: "hard_fail",
-                        reason: designWriteGate.reason ?? "设计产物包未达到实现就绪状态",
-                        recovery: "仅可继续补充设计资产并执行 sf_verify 真实复验；通过前不得写入业务实现",
-                    };
-                    const designTrace = createToolTrace({
-                        tool_name: name, invocation_id: invocationId, task_id: taskId,
-                        actual_side_effects: effectiveSideEffects,
-                        next_allowed_tools: contract.default_next_tools,
-                        forbidden_tools: contract.forbidden_next_tools,
-                        authorization, bypass,
-                    });
-                    await taskContext.setToolTrace(taskId, designTrace, [designViolation]);
-                    return {
-                        content: [{ type: "text", text: JSON.stringify({
-                                    error: designViolation.reason,
-                                    violation: designViolation,
-                                    diagnostic_code: designWriteGate.diagnostic_code,
-                                    recovery: designViolation.recovery,
-                                }) }],
-                        isError: true,
-                    };
-                }
-            }
-            // 用户项目知识门禁: review/verify/deliver 不能绕过不可消费的项目 hard rule。
-            if (["sf_review", "sf_verify", "sf_deliver"].includes(name)) {
-                const { evaluateLifecycleKnowledgeDecision } = await import("../../engine/lifecycle_knowledge_contract.js");
-                const lifecycleStage = name === "sf_review" ? "implementation" : name === "sf_verify" ? "testing" : "delivery";
-                const lifecycleDecision = evaluateLifecycleKnowledgeDecision({
-                    projectPath,
-                    consumer: name,
-                    intent: ctx?.intent ?? name,
-                    route: name === "sf_review" ? "review" : name === "sf_verify" ? "verification" : "delivery",
-                    lifecycle_stage: lifecycleStage,
-                    changed_files: Array.isArray(args.changed_files) ? args.changed_files : ctx?.execution?.changed_files ?? [],
-                    verified_files: Array.isArray(args.changed_files) ? args.changed_files : ctx?.execution?.changed_files ?? [],
-                    traceability_ids: [
-                        ...(ctx?.traceability_binding?.requirement_ids ?? []),
-                        ...(ctx?.traceability_binding?.prototype_ids ?? []),
-                        ...(ctx?.traceability_binding?.architecture_ids ?? []),
-                        ...(ctx?.traceability_binding?.detail_design_ids ?? []),
-                        ...(ctx?.traceability_binding?.phase_ids ?? []),
-                        ...(ctx?.traceability_binding?.slice_ids ?? []),
-                        ...(ctx?.traceability_binding?.acceptance_ids ?? []),
-                    ],
-                    config,
-                    task_id: taskId,
-                    require_design_audit: false,
-                    enforce_control_plane: name !== "sf_review",
-                    generation_traces: [
-                        ...(ctx?.classification ? [{ tool_name: "sf_classify", task_id: taskId, status: "passed", evidence_kind: "result" }] : []),
-                        ...(ctx?.expansion ? [{ tool_name: "sf_expand", task_id: taskId, status: "passed", evidence_kind: "result" }] : []),
-                        ...(name === "sf_verify" ? [{ tool_name: "sf_verify", task_id: taskId, status: "blocked", evidence_kind: "plan" }] : []),
-                    ],
-                    selection_limit: 8,
-                });
-                if (lifecycleDecision.hard_fail_count > 0) {
-                    const hardFindings = lifecycleDecision.findings
-                        .filter((finding) => finding.severity === "hard_fail")
-                        .map((finding) => `[${finding.code}] ${finding.message_zh}`);
-                    const pkViolation = {
-                        invocation_id: invocationId,
-                        tool_name: name,
-                        violation_type: "guard_blocked",
-                        severity: "hard_fail",
-                        reason: lifecycleDecision.decision_summary_zh,
-                        recovery: lifecycleDecision.recovery_commands.join("；") || "运行 soloforge next 查看统一生命周期知识合同阻断项",
-                    };
-                    const pkTrace = createToolTrace({
-                        tool_name: name, invocation_id: invocationId, task_id: taskId,
-                        actual_side_effects: effectiveSideEffects,
-                        next_allowed_tools: ["sf_expand", "sf_status"],
-                        forbidden_tools: ["sf_review", "sf_verify", "sf_deliver"],
-                        authorization, bypass,
-                    });
-                    if (taskId && ctx)
-                        await taskContext.setToolTrace(taskId, pkTrace, [pkViolation]);
-                    return {
-                        content: [{ type: "text", text: JSON.stringify({
-                                    error: pkViolation.reason,
-                                    violation: pkViolation,
-                                    diagnostic_code: TOOL_DIAGNOSTIC_CODES.projectKnowledgeBlocked,
-                                    findings: hardFindings,
-                                    lifecycle_knowledge_decision: {
-                                        contract_id: lifecycleDecision.contract_id,
-                                        lifecycle_stage: lifecycleDecision.lifecycle_stage,
-                                        authoritative_paths: lifecycleDecision.authoritative_paths,
-                                        recovery_commands: lifecycleDecision.recovery_commands,
-                                    },
-                                    recovery: pkViolation.recovery,
-                                }) }],
-                        isError: true,
-                    };
-                }
-            }
-            // 合同验证
-            const lastTrace = ctx?.last_tool_trace;
-            // 为动态工具构建有效的合同覆盖（如 sf_status cancel）
-            let contractOverride;
-            if (effectiveCategory !== contract.category || effectiveSideEffects !== contract.side_effects) {
-                contractOverride = { ...contract, category: effectiveCategory, side_effects: effectiveSideEffects };
-            }
-            // Workflow ID: 仅来自真实的 expansion trace
-            const explicitWorkflowId = ctx?.expansion?.workflow_trace?.workflow_id;
-            const violations = validateToolInvocation({
-                tool_name: name,
-                current_next_allowed: lastTrace?.next_allowed_tools ?? [],
-                current_forbidden: lastTrace?.forbidden_tools ?? [],
-                authorization,
-                bypass,
-                actual_side_effects: effectiveSideEffects,
-                workflow_id: explicitWorkflowId,
-                _contractOverride: contractOverride,
-            });
-            // 基于状态的回退: 将 contract_state_mismatch 从 hard_fail 降级为 require_human
-            if (authorization.reason === "task in valid state for tool") {
-                for (const v of violations) {
-                    if (v.violation_type === "contract_state_mismatch" && v.severity === "hard_fail") {
-                        v.severity = "require_human";
-                        v.reason += " (state-based fallback: no real workflow_id)";
-                    }
-                }
-            }
-            // Hard-fail 违规 → 阻止
-            const hardFail = violations.find(v => v.severity === "hard_fail");
-            if (hardFail) {
-                const blockedTrace = createToolTrace({
-                    tool_name: name, invocation_id: invocationId, task_id: taskId,
-                    actual_side_effects: effectiveSideEffects,
-                    next_allowed_tools: contract.default_next_tools,
-                    forbidden_tools: contract.forbidden_next_tools,
-                    authorization, bypass,
-                });
-                if (taskId && ctx) {
-                    await taskContext.setToolTrace(taskId, blockedTrace, violations);
-                }
-                return {
-                    content: [{ type: "text", text: JSON.stringify({
-                                error: hardFail.reason, violation: hardFail,
-                                tool_trace: blockedTrace,
-                                next_allowed_tools: contract.default_next_tools,
-                                forbidden_tools: contract.forbidden_next_tools,
-                            }) }],
-                    isError: true,
-                };
-            }
-            // 执行 handler
-            try {
-                const raw = await handler(args);
-                // 如果 handler 直接返回 { content } 则透传
-                if (raw && typeof raw === "object" && "content" in raw && Array.isArray(raw.content)) {
-                    return raw;
-                }
-                // 从 { result } 模式中提取数据
-                const data = raw?.result !== undefined ? raw.result : raw;
-                const hasError = !!(data && typeof data === "object" && "error" in data);
-                const recoveryNextTools = hasError && Array.isArray(data.recovery_next_tools)
-                    ? data.recovery_next_tools
-                    : contract.default_next_tools;
-                const recoveryForbiddenTools = hasError && Array.isArray(data.recovery_forbidden_tools)
-                    ? data.recovery_forbidden_tools
-                    : contract.forbidden_next_tools;
-                // 构建 trace；失败处理器可显式开放修复重验路径
-                const trace = createToolTrace({
-                    tool_name: name, invocation_id: invocationId, task_id: taskId,
-                    workflow_id: ctx?.expansion?.workflow_trace?.workflow_id,
-                    actual_side_effects: effectiveSideEffects,
-                    next_allowed_tools: recoveryNextTools,
-                    forbidden_tools: recoveryForbiddenTools,
-                    authorization, bypass,
-                });
-                // 将 trace 写入 TaskContext
-                if (taskId) {
-                    await taskContext.setToolTrace(taskId, trace, violations.length > 0 ? violations : undefined);
-                }
-                // 用 trace + next/forbidden 装饰响应
-                const response = {
-                    ...data,
-                    tool_trace: trace,
-                    next_allowed_tools: recoveryNextTools,
-                    forbidden_tools: recoveryForbiddenTools,
-                };
-                // 基于状态的回退: 在响应中暴露降级 workflow
-                if (authorization.reason === "task in valid state for tool") {
-                    response.degraded_workflow = true;
-                    response.workflow_source = "state-based-fallback";
-                }
-                return {
-                    content: [{ type: "text", text: JSON.stringify(response, null, 2) }],
-                    isError: hasError ? true : undefined,
-                };
-            }
-            catch (err) {
-                const errorNextTools = name === "sf_expand"
-                    ? ["sf_expand", "sf_status", "sf_debug", "sf_governance_report"]
-                    : contract.default_next_tools;
-                const errorForbiddenTools = name === "sf_expand"
-                    ? ["sf_verify", "sf_review", "sf_deliver", "sf_scaffold"]
-                    : contract.forbidden_next_tools;
-                if (name === "sf_expand" && taskId) {
-                    try {
-                        await taskContext.updateStatus(taskId, "failed");
-                    }
-                    catch { /* best effort */ }
-                }
-                const errorTrace = createToolTrace({
-                    tool_name: name, invocation_id: invocationId, task_id: taskId,
-                    actual_side_effects: effectiveSideEffects,
-                    next_allowed_tools: errorNextTools,
-                    forbidden_tools: errorForbiddenTools,
-                    authorization, bypass,
-                });
-                if (taskId) {
-                    try {
-                        await taskContext.setToolTrace(taskId, errorTrace);
-                    }
-                    catch { /* best effort */ }
-                }
-                return {
-                    content: [{ type: "text", text: JSON.stringify({
-                                error: err instanceof Error ? err.message : String(err),
-                                tool_trace: errorTrace,
-                                next_allowed_tools: errorNextTools,
-                                forbidden_tools: errorForbiddenTools,
-                            }) }],
-                    isError: true,
-                };
-            }
-        });
-    }
-    // 加载认知锚点上下文 — 必须提供相关性参数，禁止全量加载
-    async function loadRelevantAnchors(query) {
-        debug("工具注册", "加载认知锚点");
-        return _loadRelevantAnchorsInner(query);
-    }
-    async function _loadRelevantAnchorsInner(query) {
-        const stateDir = taskContext.getStateDir();
-        const mapPath = path.join(stateDir, "cognitive.map.json");
-        const mapData = (await lazyAnchor()).readMapJson(mapPath);
-        if (!mapData || mapData.anchors.length === 0)
-            return undefined;
-        const existingFiles = new Set();
-        try {
-            for (const anchor of mapData.anchors) {
-                for (const ref of anchor.source_refs) {
-                    if (ref.type === "file" && await fsp.access(path.join(projectPath, ref.ref)).then(() => true, () => false)) {
-                        existingFiles.add(ref.ref);
-                    }
-                }
-            }
-        }
-        catch { /* ignore */ }
-        const checked = (await lazyAnchor()).checkAnchorStaleness(mapData.anchors, existingFiles);
-        // 必须有 module 或 file_paths，否则不返回任何锚点（禁止全量加载）
-        if (!query.module && (!query.file_paths || query.file_paths.length === 0))
-            return undefined;
-        // 收集与任意提供的 file_paths 或 module 匹配的锚点
-        const seen = new Set();
-        const relevant = [];
-        if (query.module) {
-            for (const a of (await lazyAnchor()).filterRelevantAnchors(checked, { module: query.module })) {
-                if (!seen.has(a.anchor_id)) {
-                    seen.add(a.anchor_id);
-                    relevant.push(a);
-                }
-            }
-        }
-        if (query.file_paths) {
-            for (const fp of query.file_paths) {
-                for (const a of (await lazyAnchor()).filterRelevantAnchors(checked, { file_path: fp })) {
-                    if (!seen.has(a.anchor_id)) {
-                        seen.add(a.anchor_id);
-                        relevant.push(a);
-                    }
-                }
-            }
-        }
-        if (relevant.length === 0)
-            return undefined;
-        return relevant.map((a) => ({
-            anchor_id: a.anchor_id,
-            module: a.module,
-            summary: a.core_contracts.slice(0, 3).join("; "),
-            stale_anchor: a.stale_anchor,
-        }));
-    }
-    debug("工具注册", "批量注册核心/辅助/知识维护工具...");
-    // ── sf_classify: 意图分类入口，创建任务上下文并返回分类结果 ──
-    registerSafeTool("sf_classify", "分析开发者意图，返回任务类型、风险、复杂度和执行策略", ClassifySchema, async (args) => {
-        const asksForNavigation = /(?:下一步|继续(?:做|执行|开发)?|现在(?:可以|能)(?:开始)?(?:写代码|编码|开发|测试|交付)|接下来(?:做什么|该做什么)|该(?:做什么|怎么继续))/i.test(args.intent);
-        if (asksForNavigation) {
-            const navigation = await (await lazyNavigation()).planNextAction(projectPath);
-            return {
-                result: {
-                    status: "navigation_required",
-                    reason_zh: "检测到阶段推进意图，必须先依据 SoloForge 状态规划下一步",
-                    navigation,
-                },
-            };
-        }
-        // 检查是否存在进行中的任务
-        const existing = await taskContext.getCurrentTask();
-        if (existing && !["done", "failed"].includes(existing.status)) {
-            const navigation = await (await lazyNavigation()).planNextAction(projectPath);
-            if (navigation.stale_task?.is_stale) {
-                return {
-                    result: {
-                        status: "stale_task_requires_resolution",
-                        error: "存在陈旧任务指针，必须先选择恢复、归档或开始新任务",
-                        existing_task_id: existing.task_id,
-                        existing_status: existing.status,
-                        navigation,
-                        hint: "先调用 sf_navigation 查看可执行处理步骤，不得绕过 SoloForge 状态直接分析或编码",
-                    },
-                };
-            }
-            return {
-                result: {
-                    error: "存在未完成的任务",
-                    warning: "存在未完成的任务",
-                    existing_task_id: existing.task_id,
-                    existing_status: existing.status,
-                    existing_intent: existing.intent,
-                    hint: "调用 sf_status action=cancel 取消旧任务，或继续完成它",
-                },
-            };
-        }
-        // 创建任务上下文
-        const ctx = await taskContext.create(args.intent, config.product_profile);
-        const input = { intent: args.intent, project_path: projectPath, task_id: ctx.task_id };
-        const classification = (await lazyClassifier()).classify(input);
-        // 存储分类结果
-        await taskContext.setClassification(ctx.task_id, classification);
-        if (!(await lazyIntentRouter()).shouldEnterSoloForge(classification?.route_decision)) {
-            await taskContext.updateStatus(ctx.task_id, "done");
-        }
-        return {
-            result: {
-                task_id: ctx.task_id,
-                ...classification,
-            },
-        };
-    });
-    // ── sf_expand: 意图膨胀，生成结构化 prompt 并注入计划上下文 ──
-    registerSafeTool("sf_expand", "将意图膨胀为结构化 prompt，包含 scope、验收标准和知识匹配。当存在计划时自动注入当前阶段上下文和输出模板", ExpandSchema, async (args) => {
-        const ctx = await taskContext.load(args.task_id);
-        if (!ctx || !ctx.classification) {
-            return { result: { error: "任务不存在或尚未分类，请先调用 sf_classify" } };
-        }
-        // 合并校验 + 应用：ctx 已存储值 → args 覆盖值，统一解析和规范化
-        let needsSave = false;
-        for (const field of CONTRACT_OBJECT_FIELDS) {
-            // args 优先，其次 ctx 已存储值
-            const raw = args[field] ?? ctx[field];
-            if (!raw)
-                continue;
-            const parsed = parseContractObject(raw, field);
-            if (parsed.error)
-                return { result: { error: parsed.error, status: "invalid_input" } };
-            if (parsed.value) {
-                ctx[field] = field === "decision_workshop"
-                    ? ((await lazyDecisionWorkshop()).normalizeDecisionWorkshopContract(parsed.value, args.task_id) ?? parsed.value)
-                    : parsed.value;
-                needsSave = true;
-            }
-        }
-        if (needsSave)
-            await taskContext.save(ctx);
-        // 状态守卫：classifying/expanding/clarifying/failed → expanding
-        if (ctx.status === "classifying" || ctx.status === "clarifying" || ctx.status === "failed") {
-            await taskContext.updateStatus(args.task_id, "expanding");
-            ctx.status = "expanding";
-        }
-        else if (ctx.status !== "expanding") {
-            return {
-                result: { error: `任务状态 ${ctx.status} 不可膨胀，需要 classifying 或 expanding`, status: ctx.status },
-            };
-        }
-        // 构建计划上下文（如果存在计划）
-        let planContext;
-        if (ctx.planning && ctx.planning.sub_tasks.length > 0 && ctx.planning.current_step_index < ctx.planning.sub_tasks.length) {
-            const currentStep = ctx.planning.sub_tasks[ctx.planning.current_step_index];
-            const previousOutputs = {};
-            // 读取前序步骤的产出文件（P3: 产物系统）
-            for (let i = 0; i < ctx.planning.current_step_index; i++) {
-                const step = ctx.planning.sub_tasks[i];
-                if (step.output_path) {
-                    try {
-                        const fs = await import("node:fs/promises");
-                        const content = await fs.readFile(step.output_path, "utf-8");
-                        previousOutputs[step.title] = content;
-                    }
-                    catch {
-                        // 文件不存在则跳过
-                    }
-                }
-            }
-            planContext = { current_step: currentStep, previous_outputs: previousOutputs };
-        }
-        // H1: Token 预算检查 — advisory 模式，仅警告不阻断
-        gateway.beginTask(args.task_id);
-        let h1Warning;
-        try {
-            const gateResult = gateway.request("solution_brainstorm");
-            if (!gateResult.allowed) {
-                h1Warning = { warning: `H1 advisory: ${gateResult.reason}`, budget_remaining: gateResult.remaining_budget };
-            }
-        }
-        catch (e) {
-            h1Warning = { warning: `H1 advisory: ${e.message}`, budget_remaining: 0 };
-        }
-        // H4: advisory-only — 不获取持久锁，仅检查当前锁定状态
-        let h4LockWarning;
-        const lockStatus = await ioController.isLocked();
-        if (lockStatus.locked && lockStatus.task_id !== args.task_id) {
-            h4LockWarning = `H4 advisory: 工作区已被任务 ${lockStatus.task_id} 锁定（${lockStatus.reason ?? "未知"}），当前 H4 未进入强制层`;
-        }
-        let expansion;
-        try {
-            expansion = await (await lazyExpander()).expand({
-                intent: ctx.intent,
-                classification: ctx.classification,
-                projectPath,
-                config,
-                knowledgeIndex,
-                clarificationAnswers: args.clarification_answers,
-                route_decision: ctx.classification?.route_decision,
-                plan_context: planContext,
-                input_material_confirmations: args.input_material_confirmations,
-                task_id: args.task_id,
-                brainstorm_session: ctx.brainstorm_session ?? undefined,
-            });
-        }
-        catch (expandErr) {
-            // 尝试回退到 failed 状态，避免任务停留在 expanding
-            try {
-                await taskContext.updateStatus(args.task_id, "failed");
-            }
-            catch {
-                // 状态转换非法（如已非 expanding），忽略
-            }
-            throw expandErr;
-        }
-        finally {
-            if (!h1Warning)
-                gateway.completeOperation();
-            gateway.endTask();
-        }
-        expansion.task_id = args.task_id;
-        const projectRoot = await fsp.realpath(projectPath);
-        const referencedMaterialPaths = new Set((expansion.input_materials ?? [])
-            .map((material) => material.path_or_ref)
-            .filter((materialPath) => typeof materialPath === "string" && materialPath.length > 0)
-            .map((materialPath) => path.resolve(projectRoot, normalizePathCandidate(materialPath))));
-        const _confirmedCandidates = (args.input_material_confirmations ?? [])
-            .map((materialPath) => path.resolve(projectRoot, normalizePathCandidate(materialPath)))
-            .filter((absolutePath) => isSameOrDescendantPath(absolutePath, projectRoot, { caseSensitive: false }))
-            .filter((absolutePath) => referencedMaterialPaths.has(absolutePath));
-        const confirmedProjectSourcePaths = [];
-        for (const absolutePath of _confirmedCandidates) {
-            try {
-                if ((await fsp.stat(absolutePath)).isFile()
-                    && (await fsp.realpath(absolutePath)).startsWith(`${projectRoot}${path.sep}`)) {
-                    confirmedProjectSourcePaths.push(absolutePath);
-                }
-            }
-            catch {
-                // 跳过无效路径
-            }
-        }
-        const registerConfirmedProjectSources = (registry) => {
-            for (const absolutePath of confirmedProjectSourcePaths) {
-                const sourceRef = path.relative(projectRoot, absolutePath);
-                registry.register({
-                    source_type: "project_file",
-                    evidence_role: "project_source_file",
-                    authority: "authoritative",
-                    freshness: "current",
-                    permission: "allowed",
-                    scope: "confirmed_input_material",
-                    description: `已确认项目输入材料: ${sourceRef}`,
-                    source_ref: sourceRef,
-                });
-            }
-        };
-        const workflowIntent = ctx.route_decision?.workflow_intent ?? ctx.classification.route_decision?.workflow_intent;
-        // 问题六十: 高风险项目事实声明先过证据门，避免后续架构研讨门遮蔽无证据问题。
-        {
-            const evRoute = ctx.route_decision?.route ?? ctx.classification?.route_decision?.route;
-            const evWorkflowIntent = ctx.route_decision?.workflow_intent ?? ctx.classification?.route_decision?.workflow_intent;
-            const evRisk = (await import("../../engine/evidence_grounding_contract.js")).assessTaskRisk(ctx.classification?.task_type, evRoute, ctx.intent);
-            const isArchitectureContext = evWorkflowIntent === "architecture_design"
-                || evWorkflowIntent === "existing_system_gap_analysis"
-                || evRoute === "artifact_generation"
-                || hasArchitectureIntentSignal(ctx.intent);
-            if (isArchitectureContext && (evRisk === "high" || evRisk === "critical")) {
-                const { createEvidenceGroundingSystem } = await import("../../engine/evidence_grounding_contract.js");
-                const evg = createEvidenceGroundingSystem();
-                evg.registry.register({
-                    source_type: "task_context",
-                    evidence_role: "classification",
-                    authority: "authoritative",
-                    freshness: "current",
-                    permission: "allowed",
-                    scope: "classification",
-                    description: "任务分类结果",
-                    source_ref: `task:${args.task_id}`,
-                });
-                if (knowledgeIndex) {
-                    const { project } = knowledgeIndex.getAllEntries();
-                    for (const entry of project) {
-                        if (entry.status !== "active")
-                            continue;
-                        evg.registry.register({
-                            source_type: "knowledge_asset",
-                            evidence_role: "template_guidance",
-                            authority: "trusted",
-                            freshness: "current",
-                            permission: "allowed",
-                            scope: entry.scope?.join(",") ?? "knowledge",
-                            description: entry.name,
-                            source_ref: entry.file_path,
-                        });
-                    }
-                }
-                const tdc = ctx.technology_decision_contract;
-                if (tdc?.human_gate_evidence) {
-                    evg.registry.register({
-                        source_type: "user_confirmation",
-                        evidence_role: "user_confirmation",
-                        authority: "authoritative",
-                        freshness: "current",
-                        permission: "allowed",
-                        scope: "technology_decision",
-                        description: `技术决策确认: ${tdc.decision_scope ?? "general"}`,
-                        source_ref: `decision:${tdc.decision_id ?? args.task_id}`,
-                    });
-                }
-                registerConfirmedProjectSources(evg.registry);
-                const evClaims = [
-                    {
-                        id: "claim-expand-0",
-                        category: "user_confirmation",
-                        claim_text: "任务路由和执行范围已确认",
-                        evidence_ids: evg.registry.query({ source_type: "task_context" }).map((e) => e.id),
-                        is_uncertain: false,
-                        risk_level: evRisk,
-                    },
-                    {
-                        id: "claim-expand-1",
-                        category: "architecture",
-                        claim_text: "技术方案基于现有系统分析",
-                        evidence_ids: evg.registry.query({}).filter((e) => e.evidence_role && e.evidence_role !== "template_guidance" && e.evidence_role !== "classification").map((e) => e.id),
-                        is_uncertain: false,
-                        risk_level: evRisk,
-                    },
-                ];
-                const evMatrix = evg.builder.buildContext(evClaims, {
-                    target_claims: evClaims.map((c) => c.claim_text),
-                    source_types: [],
-                    keywords: [],
-                    max_results: 10,
-                });
-                evMatrix.task_id = args.task_id;
-                const evGate = evg.gate.evaluate(evMatrix, evRisk);
-                await taskContext.setEvidenceGroundingResult(args.task_id, {
-                    evidence_matrix: evMatrix,
-                    evidence_gate_result: evGate,
-                    unsupported_claims: evGate.unsupported_claims,
-                    conflict_resolutions: evMatrix.conflicts,
-                });
-                if (!evGate.allowed) {
-                    return {
-                        result: {
-                            error: `证据驱动门禁阻断: ${evGate.reason_zh}`,
-                            diagnostic_code: evGate.diagnostic_code,
-                            reason_zh: evGate.reason_zh,
-                            unsupported_claims: evGate.unsupported_claims,
-                            missing_evidence: evGate.missing_evidence,
-                            status: "blocked",
-                            recovery: "请提供项目文件、命令输出或其他权威证据支撑关键声明后重新 sf_expand",
-                        },
-                    };
-                }
-            }
-        }
-        // 问题六十一: 架构设计前的六域研讨门独立执行，不得被施工指令契约有无绕过。
-        let existingSourceRoot = false;
-        for (const candidate of ["src", "backend", "frontend", "apps", "services"]) {
-            if (await fsp.access(path.join(projectPath, candidate)).then(() => true, () => false)) {
-                existingSourceRoot = true;
-                break;
-            }
-        }
-        let existingManifest = false;
-        for (const candidate of ["package.json", "pom.xml", "build.gradle", "settings.gradle"]) {
-            if (await fsp.access(path.join(projectPath, candidate)).then(() => true, () => false)) {
-                existingManifest = true;
-                break;
-            }
-        }
-        const detectedArchitectureContext = existingSourceRoot && existingManifest
-            ? "existing_system"
-            : (!existingSourceRoot && !existingManifest ? "empty_project" : "new_system");
-        const workshopGate = await checkArchitectureDecisionWorkshopGate({
-            ctx,
-            workflowIntent,
-            projectContext: detectedArchitectureContext,
-        });
-        await taskContext.save(ctx);
-        if (!workshopGate.allowed) {
-            return {
-                result: {
-                    error: "架构设计前必须先完成六类架构决策研讨与用户确认",
-                    status: "awaiting_confirmation",
-                    architecture_decision_workshop: workshopGate.contract,
-                    blocking_findings: workshopGate.findings,
-                    next_domain: workshopGate.next_domain,
-                    recovery: "请从当前待讨论域开始，提供候选方案、推荐理由、风险和用户确认后重新调用 sf_expand",
-                },
-            };
-        }
-        // 六域决策闭合后创建设计产物生命周期；正式设计与后续实现必须以其复验结果为准。
-        if (workflowIntent === "architecture_design" && !ctx.design_artifact_pack) {
-            const designModule = await lazyDesignArtifactPack();
-            ctx.design_artifact_pack = designModule.createDesignArtifactPack(args.task_id);
-            ctx.design_artifact_pack.status = "awaiting_decisions";
-            ctx.design_artifact_pack.decision_workshop_ref = `task:${args.task_id}:architecture_decision_workshop`;
-            ctx.design_artifact_pack.user_confirmation_ref = ctx.architecture_decision_workshop?.document_output_confirmation_ref;
-            await taskContext.save(ctx);
-        }
-        // 问题六十一（通用）: 可组合决策包门禁
-        const dwModule = await lazyDecisionWorkshop();
-        const packMatch = dwModule.matchDecisionPacks({
-            workflow_intent: workflowIntent,
-            intent: ctx.intent,
-            task_type: ctx.classification?.task_type,
-        });
-        // 过滤掉架构（架构由上面的专用子包处理）
-        const nonArchPacks = packMatch.packs.filter((p) => p !== "architecture");
-        if (nonArchPacks.length > 0) {
-            const dwContract = ctx.decision_workshop ?? dwModule.createDecisionWorkshop(args.task_id, nonArchPacks, detectedArchitectureContext, packMatch.reasons.join("；"));
-            const dwGate = dwModule.evaluateDecisionWorkshop(dwContract);
-            ctx.decision_workshop = dwModule.applyDecisionWorkshopGate(dwContract);
-            await taskContext.save(ctx);
-            if (!dwGate.allowed) {
-                return {
-                    result: {
-                        error: `${packMatch.reasons.join("；")}，必须先完成决策研讨与用户确认`,
-                        status: "awaiting_confirmation",
-                        decision_workshop: ctx.decision_workshop,
-                        blocking_findings: dwGate.blocking_findings,
-                        next_domain: dwGate.next_domain,
-                        activated_packs: nonArchPacks,
-                        recovery: "请从当前待讨论域开始，提供候选方案、推荐理由、风险和用户确认后重新调用 sf_expand",
-                    },
-                };
-            }
-        }
-        // 问题四十九/五十: 已有架构合同或现有系统证据的进一步审查。
-        const expansionRoute = expansion?.workflow_trace
-            ? expansion?.workflow_trace?.route
-            : undefined;
-        const hasInstructionContract = !!ctx?.instruction_contract;
-        if (hasInstructionContract) {
-            if (expansionRoute === "artifact_generation" || expansionRoute === "analysis") {
-                const archGate = await checkArchitectureDesignGate({ ctx, route: expansionRoute });
-                if (!archGate.allowed) {
-                    return {
-                        result: {
-                            error: archGate.reason_zh,
-                            architecture_gate_findings: archGate.findings,
-                            status: "blocked",
-                            recovery: "架构设计审查未通过，请补充缺失项后重新 sf_expand",
-                        },
-                    };
-                }
-            }
-            if (expansionRoute === "code_change" || expansionRoute === "artifact_generation") {
-                const analysisGate = await checkExistingSystemAnalysisGate({
-                    hasExistingCode: !!config?.tech_stack,
-                    hasPackageJson: !!projectPath,
-                    hasSrcDir: true,
-                    hasAnalysis: !!ctx.existing_system_analysis,
-                    hasGapAnalysis: !!ctx.requirement_gap_analysis,
-                });
-                if (!analysisGate.allowed) {
-                    return {
-                        result: {
-                            error: `现有系统分析门禁未通过: ${analysisGate.reason_zh}`,
-                            missing_analysis: analysisGate.missing_analysis,
-                            status: "blocked",
-                            recovery: "请先对现有项目执行系统分析和差距分析，再继续架构设计或编码",
-                        },
-                    };
-                }
-            }
-        }
-        // ── S4 gates: 轻量路径（acceptance/review/read_only）整体跳过 ──
-        const isLightweightRoute = expansionRoute === "acceptance" || expansionRoute === "review"
-            || expansionRoute === "direct_answer" || expansionRoute === "analysis";
-        if (!isLightweightRoute) {
-            // ── S4 gates: 独立于 hasInstructionContract，由 requires* 触发判定 ──
-            // 问题十六: 技术选型决策主权 gate — 高影响技术决策缺证据时 blocked
-            {
-                const decisionGate = await checkDecisionSovereigntyGate({ ctx, route: expansionRoute });
-                if (!decisionGate.allowed) {
-                    return {
-                        result: {
-                            error: decisionGate.reason_zh,
-                            status: "blocked",
-                            expected_schema: decisionGate.expected_schema,
-                            recovery: decisionGate.requires_human_gate ? "请提供技术决策确认证据（human_gate_evidence）" : "技术选型决策校验失败，请按照 expected_schema 格式提供 technology_decision_contract",
-                        },
-                    };
-                }
-            }
-            // 问题二十六: 细节纪律 gate — 复杂任务缺关键细节时 blocked
-            {
-                const detailGate = await checkDetailDisciplineGate({ ctx, route: expansionRoute });
-                if (!detailGate.allowed) {
-                    return {
-                        result: {
-                            error: detailGate.reason_zh,
-                            missing_details: detailGate.missing_details,
-                            status: "blocked",
-                            recovery: "多步骤/复杂任务缺 detail_discipline_contract，请提供后重新 sf_expand",
-                        },
-                    };
-                }
-            }
-            // 问题二十七: 第一性原理 gate — 高影响任务缺推理时 blocked
-            {
-                const fpGate = await checkFirstPrinciplesGate({ ctx, route: expansionRoute });
-                if (!fpGate.allowed) {
-                    return {
-                        result: {
-                            error: fpGate.reason_zh,
-                            failures: fpGate.failures,
-                            expected_schema: fpGate.expected_schema,
-                            status: "blocked",
-                            recovery: "高影响任务缺 first_principles_frame，请按照 expected_schema 格式提供后重新 sf_expand",
-                        },
-                    };
-                }
-            }
-            // 问题四十二(brainstorm): 脑暴契约 gate — 不确定项缺方案探索时 blocked
-            {
-                const brainstormGate = await checkBrainstormGate({ ctx, route: expansionRoute });
-                if (!brainstormGate.allowed) {
-                    return {
-                        result: {
-                            error: brainstormGate.reason_zh,
-                            violations: brainstormGate.violations,
-                            expected_schema: brainstormGate.expected_schema,
-                            status: "blocked",
-                            recovery: "不确定项/方案选择缺 brainstorm_session，请按照 expected_schema 格式提供后重新 sf_expand",
-                        },
-                    };
-                }
-            }
-            // 问题六十六/六十七/六十八: 编码前工程约束必须聚合返回。
-            // 不能让 OOD 或后端工程门禁抢先返回，遮蔽用户项目的注释/日志契约。
-            {
-                const preImplementationBlocks = [];
-                const preImplementationPayload = {};
-                const artifactDesignIntent = expansionRoute === "artifact_generation"
-                    || ["architecture_design", "detailed_design", "database_design", "api_design"].includes(String(workflowIntent))
-                    || /(?:架构|数据库|API|接口|OpenAPI).{0,12}(?:设计|规格|文档)|(?:设计|规格|文档).{0,12}(?:API|接口|OpenAPI)/i.test(ctx.intent);
-                const isImplementationRoute = !artifactDesignIntent && (expansionRoute === "code_change"
-                    || String(workflowIntent) === "backend_api_implementation"
-                    || String(workflowIntent) === "frontend_business_logic"
-                    || /编码|实现|开发|controller|service|component/i.test(ctx.intent));
-                const traceabilityModule = await lazyTraceability();
-                const traceReport = isImplementationRoute
-                    ? traceabilityModule.auditDesignImplementationTraceability(projectPath)
-                    : {
-                        passed: true,
-                        matrix_exists: false,
-                        findings: [],
-                        checked_files: [],
-                        matrix_path: traceabilityModule.DEFAULT_DESIGN_IMPLEMENTATION_TRACEABILITY_PATH,
-                    };
-                if (isImplementationRoute && !traceReport.passed) {
-                    ctx.traceability_binding = {
-                        requirement_ids: [],
-                        prototype_ids: [],
-                        architecture_ids: [],
-                        detail_design_ids: [],
-                        phase_ids: [],
-                        slice_ids: [],
-                        acceptance_ids: [],
-                        status: "needs_backfill",
-                        findings: traceReport.findings.map((finding) => `${finding.code}: ${finding.message_zh}`),
-                    };
-                    await taskContext.save(ctx);
-                    return {
-                        result: {
-                            error: "需求/原型/设计/切片/验收追踪链路未闭合，不得进入编码实现",
-                            status: "blocked",
-                            diagnostic_code: TOOL_DIAGNOSTIC_CODES.traceabilityMissing,
-                            traceability_findings: traceReport.findings,
-                            checked_files: traceReport.checked_files,
-                            matrix_path: traceReport.matrix_path,
-                            template_path: traceabilityModule.DESIGN_IMPLEMENTATION_TRACEABILITY_TEMPLATE_PATH,
-                            recovery_command: traceabilityModule.DESIGN_IMPLEMENTATION_TRACEABILITY_RECOVERY_COMMAND,
-                            recovery: `${traceabilityModule.DESIGN_IMPLEMENTATION_TRACEABILITY_RECOVERY_GUIDANCE}。不得取消任务后直接写代码，不得改用 Bash 绕过追踪矩阵。`,
-                        },
-                    };
-                }
-                const traceBindingIds = traceabilityModule.extractTraceabilityBindingIds(ctx);
-                if (traceReport.matrix_exists && isImplementationRoute) {
-                    const missingPrefixes = ["PHASE", "SLICE", "DD", "AC"].filter((prefix) => !traceBindingIds.some((id) => id.startsWith(`${prefix}-`)));
-                    if (missingPrefixes.length > 0) {
-                        ctx.traceability_binding = {
-                            requirement_ids: traceBindingIds.filter((id) => id.startsWith("REQ-")),
-                            prototype_ids: traceBindingIds.filter((id) => id.startsWith("PROTO-")),
-                            architecture_ids: traceBindingIds.filter((id) => id.startsWith("ARCH-")),
-                            detail_design_ids: traceBindingIds.filter((id) => id.startsWith("DD-")),
-                            phase_ids: traceBindingIds.filter((id) => id.startsWith("PHASE-")),
-                            slice_ids: traceBindingIds.filter((id) => id.startsWith("SLICE-")),
-                            acceptance_ids: traceBindingIds.filter((id) => id.startsWith("AC-")),
-                            status: "missing",
-                            findings: missingPrefixes.map((prefix) => `编码前缺少 ${prefix}-* 绑定`),
-                        };
-                        await taskContext.save(ctx);
-                        return {
-                            result: {
-                                error: "编码任务必须先绑定阶段、切片、详细设计和验收 ID",
-                                status: "awaiting_traceability_binding",
-                                diagnostic_code: TOOL_DIAGNOSTIC_CODES.traceabilityBindingMissing,
-                                missing_prefixes: missingPrefixes,
-                                matrix_path: traceReport.matrix_path,
-                                template_path: traceabilityModule.DESIGN_IMPLEMENTATION_TRACEABILITY_TEMPLATE_PATH,
-                                recovery_command: "sf_expand",
-                                recovery: "在任务上下文或指令中明确本次实现对应的 PHASE-*、SLICE-*、DD-*、AC-*，再重新调用 sf_expand；不得脱离已确认设计直接编码，不得取消任务后改用 Bash/Edit/Write 直接实现",
-                            },
-                        };
-                    }
-                    ctx.traceability_binding = {
-                        requirement_ids: traceBindingIds.filter((id) => id.startsWith("REQ-")),
-                        prototype_ids: traceBindingIds.filter((id) => id.startsWith("PROTO-")),
-                        architecture_ids: traceBindingIds.filter((id) => id.startsWith("ARCH-")),
-                        detail_design_ids: traceBindingIds.filter((id) => id.startsWith("DD-")),
-                        phase_ids: traceBindingIds.filter((id) => id.startsWith("PHASE-")),
-                        slice_ids: traceBindingIds.filter((id) => id.startsWith("SLICE-")),
-                        acceptance_ids: traceBindingIds.filter((id) => id.startsWith("AC-")),
-                        status: "bound",
-                        findings: [],
-                    };
-                    preImplementationPayload.traceability_binding = ctx.traceability_binding;
-                }
-                const oodModule = await lazyOodSolid();
-                const oodGate = oodModule.evaluateOodDesignGate({
-                    task_id: args.task_id,
-                    intent: ctx.intent,
-                    route: expansionRoute,
-                    summary: ctx.ood_solid_summary,
-                });
-                if (oodGate.applicable) {
-                    ctx.ood_solid_summary = oodGate.required_summary;
-                    preImplementationPayload.ood_solid_summary = oodGate.required_summary;
-                }
-                if (!oodGate.allowed) {
-                    preImplementationBlocks.push({
-                        code: TOOL_DIAGNOSTIC_CODES.oodMissingSummary,
-                        reason_zh: oodGate.reason_zh,
-                    });
-                }
-                const backendModule = await lazyBackendImplementation();
-                const backendGate = backendModule.evaluateBackendImplementationGate({
-                    task_id: args.task_id,
-                    intent: ctx.intent,
-                    route: expansionRoute,
-                    work_package: ctx.backend_implementation_work_package,
-                });
-                if (backendGate.applicable) {
-                    ctx.backend_implementation_work_package = backendGate.work_package;
-                    preImplementationPayload.backend_implementation_work_package = backendGate.work_package;
-                }
-                if (!backendGate.allowed) {
-                    preImplementationBlocks.push({
-                        code: TOOL_DIAGNOSTIC_CODES.backendMissingSummary,
-                        reason_zh: backendGate.reason_zh,
-                    });
-                }
-                if (ctx.classification.task_type !== "scaffold") {
-                    const obsModule = await lazyCodeObservability();
-                    const obsGate = obsModule.evaluateCodeObservabilityGate({
-                        task_id: args.task_id,
-                        intent: ctx.intent,
-                        route: expansionRoute,
-                        changed_files: ctx.execution?.changed_files,
-                        work_package: ctx.code_observability_work_package,
-                    });
-                    if (obsGate.applicable) {
-                        ctx.code_observability_work_package = obsGate.work_package;
-                        preImplementationPayload.code_observability_work_package = obsGate.work_package;
-                    }
-                    if (!obsGate.allowed) {
-                        preImplementationBlocks.push({
-                            code: TOOL_DIAGNOSTIC_CODES.codeObservabilityWorkPackage,
-                            reason_zh: obsGate.reason_zh,
-                        });
-                    }
-                }
-                if (Object.keys(preImplementationPayload).length > 0) {
-                    await taskContext.save(ctx);
-                }
-                if (preImplementationBlocks.length > 0) {
-                    return {
-                        result: {
-                            error: "编码前工程契约未全部确认，不得开始实现",
-                            status: "awaiting_implementation_contracts",
-                            diagnostic_codes: preImplementationBlocks.map((b) => b.code),
-                            blocking_findings: preImplementationBlocks,
-                            ...preImplementationPayload,
-                            recovery: "请同时确认 OOD/SOLID、后端工程边界、代码注释与日志契约后重新调用 sf_expand",
-                        },
-                    };
-                }
-            }
-        } // end if (!isLightweightRoute) — 轻量路径跳过 S4 gates + 编码前工程约束
-        // Input Material Contract: 处理 hard-blocking 结果
-        // Privacy Gate: 隐私/敏感信息策略阻断
-        const isBlocked = expansion.prompt.startsWith("## 阻塞：输入材料禁止读取")
-            || expansion.prompt.startsWith("## 阻塞：隐私/敏感信息策略");
-        let isMaterialClarification = false;
-        if (expansion.prompt.startsWith("## 澄清请求") && expansion.input_materials) {
-            for (const m of expansion.input_materials) {
-                if (m.access_mode !== "forbidden" && (await lazyInputMaterial()).classifyIngestionStatus(m.path_or_ref) === "requires_confirmation") {
-                    isMaterialClarification = true;
-                    break;
-                }
-            }
-        }
-        // 注入 H1/H4 advisory warnings
-        const advisories = {};
-        if (h1Warning)
-            advisories.h1_advisory = h1Warning;
-        if (h4LockWarning)
-            advisories.h4_advisory = h4LockWarning;
-        // 问题六十：证据驱动门禁 — 高风险任务必须阻断无证据声明
-        const _evRoute = ctx.route_decision?.route ?? ctx.classification?.route_decision?.route;
-        const _evRisk = (await import("../../engine/evidence_grounding_contract.js")).assessTaskRisk(ctx.classification?.task_type, _evRoute, ctx.intent);
-        if (_evRisk === "high" || _evRisk === "critical") {
-            const { createEvidenceGroundingSystem } = await import("../../engine/evidence_grounding_contract.js");
-            const _evg = createEvidenceGroundingSystem();
-            if (ctx.classification) {
-                _evg.registry.register({
-                    source_type: "task_context",
-                    evidence_role: "classification",
-                    authority: "authoritative",
-                    freshness: "current",
-                    permission: "allowed",
-                    scope: "classification",
-                    description: "任务分类结果",
-                    source_ref: `task:${args.task_id}`,
-                });
-            }
-            // 注册知识索引中的项目知识作为证据（仅项目级，不含全局通用规则）
-            // 所有知识索引条目都是 template_guidance 角色，不得支撑项目事实声明
-            if (knowledgeIndex) {
-                const { project } = knowledgeIndex.getAllEntries();
-                for (const entry of project) {
-                    if (entry.status !== "active")
-                        continue;
-                    _evg.registry.register({
-                        source_type: "knowledge_asset",
-                        evidence_role: "template_guidance",
-                        authority: "trusted",
-                        freshness: "current",
-                        permission: "allowed",
-                        scope: entry.scope?.join(",") ?? "knowledge",
-                        description: entry.name,
-                        source_ref: entry.file_path,
-                    });
-                }
-            }
-            // 技术决策契约含 human_gate_evidence → 注册为 user_confirmation（真实项目证据）
-            const _tdc = ctx.technology_decision_contract;
-            if (_tdc?.human_gate_evidence) {
-                _evg.registry.register({
-                    source_type: "user_confirmation",
-                    evidence_role: "user_confirmation",
-                    authority: "authoritative",
-                    freshness: "current",
-                    permission: "allowed",
-                    scope: "technology_decision",
-                    description: `技术决策确认: ${_tdc.decision_scope ?? "general"}`,
-                    source_ref: `decision:${_tdc.decision_id ?? args.task_id}`,
-                });
-            }
-            registerConfirmedProjectSources(_evg.registry);
-            const _evClaims = [
-                {
-                    id: "claim-expand-0",
-                    category: "user_confirmation",
-                    claim_text: "任务路由和执行范围已确认",
-                    evidence_ids: _evg.registry.query({ source_type: "task_context" }).map((e) => e.id),
-                    is_uncertain: false,
-                    risk_level: _evRisk,
-                },
-            ];
-            // 只在架构设计/现有系统分析场景生成 architecture claim
-            const _evWorkflowIntent = ctx.route_decision?.workflow_intent ?? ctx.classification?.route_decision?.workflow_intent;
-            const _isArchitectureContext = _evWorkflowIntent === "architecture_design"
-                || _evWorkflowIntent === "existing_system_gap_analysis"
-                || _evRoute === "artifact_generation"
-                || hasArchitectureIntentSignal(ctx.intent);
-            if (_isArchitectureContext) {
-                _evClaims.push({
-                    id: "claim-expand-1",
-                    category: "architecture",
-                    claim_text: "技术方案基于现有系统分析",
-                    evidence_ids: _evg.registry.query({}).filter((e) => e.evidence_role && e.evidence_role !== "template_guidance" && e.evidence_role !== "classification").map((e) => e.id),
-                    is_uncertain: false,
-                    risk_level: _evRisk,
-                });
-            }
-            const _evVerify = _evg.verifier.verify(_evClaims, _evRisk);
-            const _evMatrix = _evg.builder.buildContext(_evClaims, {
-                target_claims: _evClaims.map((c) => c.claim_text),
-                source_types: [], keywords: [], max_results: 10,
-            });
-            _evMatrix.task_id = args.task_id;
-            const _evGate = _evg.gate.evaluate(_evMatrix, _evRisk);
-            // 写回 TaskContext（blocked 也保存）
-            await taskContext.setEvidenceGroundingResult(args.task_id, {
-                evidence_matrix: _evMatrix,
-                evidence_gate_result: _evGate,
-                unsupported_claims: _evGate.unsupported_claims,
-                conflict_resolutions: _evMatrix.conflicts,
-            });
-            if (!_evGate.allowed) {
-                return {
-                    result: {
-                        error: `证据驱动门禁阻断: ${_evGate.reason_zh}`,
-                        diagnostic_code: _evGate.diagnostic_code,
-                        reason_zh: _evGate.reason_zh,
-                        unsupported_claims: _evGate.unsupported_claims,
-                        missing_evidence: _evGate.missing_evidence,
-                        status: "blocked",
-                        recovery: "请提供项目文件、命令输出或其他权威证据支撑关键声明后重新 sf_expand",
-                    },
-                };
-            }
-            if (_evGate.requires_user_confirmation.length > 0) {
-                advisories.evidence_advisory = {
-                    level: "requires_confirmation",
-                    items: _evGate.requires_user_confirmation,
-                    diagnostic_code: _evGate.diagnostic_code,
-                };
-            }
-        }
-        else {
-            // 低风险通用问答：标注为通用建议
-            advisories.evidence_advisory = "通用建议，非项目事实；证据驱动门禁低风险放行";
-        }
-        // 配置优先级警告
-        if (expansion.config_resolution_reports && expansion.config_resolution_reports.length > 0) {
-            const configWarnings = expansion.config_resolution_reports
-                .filter(r => r.conflicts.length > 0)
-                .map(r => r.conflicts.map(c => `${c.reason}`).join("; "));
-            if (configWarnings.length > 0) {
-                advisories.config_precedence_warnings = configWarnings;
-            }
-        }
-        // 决策契约 advisory: 校验 expand 输出是否包含默认决策字段
-        const decisionContract = (await lazyDecision()).validateDecisionOutput(expansion);
-        if (!decisionContract.passed) {
-            advisories.decision_contract_advisory = decisionContract.advisory;
-        }
-        // 统一持久化：load 一次，所有修改共享同一个 ctx，最后 save 一次
-        // 避免 setExpansion/updateStatus/setPlanProposalGate 各自 load-save 互相覆盖
-        try {
-            const freshCtx = await taskContext.load(args.task_id);
-            if (freshCtx) {
-                // 1. 写入 expansion
-                await taskContext.setExpansion(args.task_id, expansion, freshCtx);
-                // 2. 写入 artifact（共享同一 ctx，不会重新 load）
-                if (expansion.output_artifact_record) {
-                    await taskContext.setArtifact(args.task_id, expansion.output_artifact_record, freshCtx);
-                }
-                // 3. 状态转换（共享 ctx，校验通过后 save）
-                const nextStatus = isBlocked ? "failed"
-                    : expansion.prompt.startsWith("## 澄清请求") ? "clarifying"
-                        : "executing";
-                await taskContext.updateStatus(args.task_id, nextStatus, freshCtx);
-                // 4. 设置 plan_proposal_gate（共享 ctx，最后一次 save）
-                {
-                    const { evaluatePlanProposalGate, inferPlanGateTaskType } = await import("../../engine/plan_proposal_gate.js");
-                    const routeForGate = expansion?.workflow_trace?.route ?? expansionRoute ?? "code_change";
-                    const taskTypeForGate = inferPlanGateTaskType(ctx.intent);
-                    const isLightweight = routeForGate === "acceptance" || routeForGate === "review"
-                        || routeForGate === "direct_answer" || routeForGate === "analysis"
-                        || taskTypeForGate === "local_acceptance";
-                    if (isLightweight) {
-                        await taskContext.setPlanProposalGate(args.task_id, {
-                            passed: true,
-                            plan_gate_status: "passed",
-                            required_level: "brief_plan",
-                            reason_zh: "轻量路径自动通过",
-                            violations: [],
-                            evidence_refs: [],
-                            blocked_actions: [],
-                        }, freshCtx);
-                    }
-                    else {
-                        const gateResult = evaluatePlanProposalGate({
-                            task_id: args.task_id,
-                            task_type: taskTypeForGate,
-                            user_intent: ctx.intent,
-                            plan_level: "execution_plan",
-                            plan_summary_zh: ctx.intent.slice(0, 200),
-                            proposed_steps: [expansionRoute ?? "execute"],
-                            verification_plan: (expansion.acceptance?.automated ?? []).map((a) => a.description ?? String(a)),
-                            risks: [],
-                            evidence_refs: expansion.matched_knowledge ?? [],
-                        });
-                        await taskContext.setPlanProposalGate(args.task_id, gateResult, freshCtx);
-                    }
-                }
-            }
-        }
-        catch (persistErr) {
-            try {
-                await taskContext.updateStatus(args.task_id, "failed");
-            }
-            catch {
-                // 状态转换非法，忽略
-            }
-            throw persistErr;
-        }
-        const expandPayload = Object.keys(advisories).length > 0
-            ? { ...expansion, advisories }
-            : expansion;
-        return {
-            result: expandPayload,
-        };
-    });
-    // ── sf_verify: 生成验证命令（构建、测试、验收检查） ──
-    registerSafeTool("sf_verify", "根据变更文件生成验证命令（构建、测试、验收检查），由 Claude Code Bash 执行", VerifySchema, async (args) => {
-        const ctx = await taskContext.load(args.task_id);
-        if (!ctx) {
-            return {
-                result: { error: "任务不存在" },
-            };
-        }
-        const implementationFiles = args.changed_files.filter((file) => /\.(?:ts|tsx|js|jsx|java|kt|cs|go|py)$/.test(file)
-            && !/(?:^|\/)tests?\//.test(file));
-        if (implementationFiles.length > 0) {
-            const implementationContents = {};
-            for (const changedFile of implementationFiles) {
-                const absoluteFile = path.resolve(projectPath, changedFile);
-                try {
-                    if (isSameOrDescendantPath(absoluteFile, path.resolve(projectPath), { caseSensitive: false }) && (await fsp.stat(absoluteFile)).isFile()) {
-                        implementationContents[changedFile] = await fsp.readFile(absoluteFile, "utf-8");
-                    }
-                }
-                catch {
-                    // 文件缺失会由验证命令或现有产物检查报告。
-                }
-            }
-            const traceabilityModule = await lazyTraceability();
-            const traceVerification = traceabilityModule.verifyChangedFilesAgainstDesignTraceability(projectPath, implementationFiles, ctx);
-            if (!traceVerification.passed) {
-                ctx.traceability_binding = {
-                    requirement_ids: traceVerification.binding_ids.filter((id) => id.startsWith("REQ-")),
-                    prototype_ids: traceVerification.binding_ids.filter((id) => id.startsWith("PROTO-")),
-                    architecture_ids: traceVerification.binding_ids.filter((id) => id.startsWith("ARCH-")),
-                    detail_design_ids: traceVerification.binding_ids.filter((id) => id.startsWith("DD-")),
-                    phase_ids: traceVerification.binding_ids.filter((id) => id.startsWith("PHASE-")),
-                    slice_ids: traceVerification.binding_ids.filter((id) => id.startsWith("SLICE-")),
-                    acceptance_ids: traceVerification.binding_ids.filter((id) => id.startsWith("AC-")),
-                    status: "missing",
-                    findings: traceVerification.findings.map((finding) => `${finding.code}: ${finding.message_zh}`),
-                };
-                await taskContext.save(ctx);
-                return {
-                    result: {
-                        error: "编码变更未绑定需求/原型/设计/切片/验收追踪链路，需修复后重验",
-                        status: "blocked",
-                        diagnostic_code: TOOL_DIAGNOSTIC_CODES.traceabilityVerifyFailed,
-                        traceability_findings: traceVerification.findings,
-                        recovery: "补齐追踪矩阵并在任务中绑定 PHASE-*、SLICE-*、DD-*、AC-* 后重新执行 sf_verify",
-                    },
-                };
-            }
-            const oodModule = await lazyOodSolid();
-            const oodGate = oodModule.evaluateOodDesignGate({
-                task_id: args.task_id,
-                intent: ctx.intent,
-                route: ctx.expansion?.workflow_trace?.route,
-                changed_files: implementationFiles,
-                summary: ctx.ood_solid_summary,
-            });
-            if (!oodGate.allowed) {
-                return {
-                    result: {
-                        error: oodGate.reason_zh,
-                        status: "blocked",
-                        diagnostic_code: TOOL_DIAGNOSTIC_CODES.oodMissingSummary,
-                        ood_solid_summary: oodGate.required_summary,
-                        recovery: "完成 OOD/SOLID 摘要后重新执行 sf_expand 与 sf_verify",
-                    },
-                };
-            }
-            const backendModule = await lazyBackendImplementation();
-            const backendGate = backendModule.evaluateBackendImplementationGate({
-                task_id: args.task_id,
-                intent: ctx.intent,
-                route: ctx.expansion?.workflow_trace?.route,
-                changed_files: implementationFiles,
-                work_package: ctx.backend_implementation_work_package,
-            });
-            if (!backendGate.allowed) {
-                return {
-                    result: {
-                        error: backendGate.reason_zh,
-                        status: "blocked",
-                        diagnostic_code: TOOL_DIAGNOSTIC_CODES.backendMissingSummary,
-                        backend_implementation_work_package: backendGate.work_package,
-                        recovery: "完成后端工程工作包后重新执行 sf_expand 与 sf_verify",
-                    },
-                };
-            }
-            const solidFindings = oodGate.applicable ? oodModule.reviewSolidCode(implementationContents) : [];
-            const backendFindings = backendGate.applicable ? backendModule.reviewBackendImplementationFiles(implementationContents) : [];
-            if (backendGate.applicable) {
-                const openApiPath = path.join(projectPath, "docs", "api", "openapi.yaml");
-                const apiMarkdownPath = path.join(projectPath, "docs", "architecture", "03-API接口规格文档.md");
-                const migrationDirectory = path.join(projectPath, "db", "migrations");
-                const openapiText = await fsp.access(openApiPath).then(() => true, () => false) ? await fsp.readFile(openApiPath, "utf-8") : undefined;
-                const apiDocumentText = await fsp.access(apiMarkdownPath).then(() => true, () => false) ? await fsp.readFile(apiMarkdownPath, "utf-8") : undefined;
-                let migrationText;
-                if (await fsp.access(migrationDirectory).then(() => true, () => false)) {
-                    const migrationFiles = (await fsp.readdir(migrationDirectory)).filter((name) => /\.sql$/i.test(name));
-                    const migrationContents = await Promise.all(migrationFiles.map((name) => fsp.readFile(path.join(migrationDirectory, name), "utf-8")));
-                    migrationText = migrationContents.join("\n");
-                }
-                backendFindings.push(...backendModule.verifyBackendArtifactAlignment({
-                    openapiText,
-                    apiDocumentText,
-                    migrationText,
-                    sourceFiles: implementationContents,
-                }));
-            }
-            ctx.ood_solid_findings = solidFindings;
-            ctx.backend_implementation_findings = backendFindings;
-            await taskContext.save(ctx);
-            if (oodModule.hasBlockingSolidFindings(solidFindings)) {
-                return {
-                    result: {
-                        error: "OOD/SOLID 代码复验发现阻断项，需修复后重验",
-                        status: "blocked",
-                        diagnostic_code: TOOL_DIAGNOSTIC_CODES.oodDeliveryBlock,
-                        ood_solid_findings: solidFindings,
-                    },
-                };
-            }
-            if (backendModule.hasBlockingBackendFindings(backendFindings)) {
-                return {
-                    result: {
-                        error: "后端实现工程复验发现阻断项，需修复后重验",
-                        status: "blocked",
-                        diagnostic_code: TOOL_DIAGNOSTIC_CODES.backendDeliveryBlock,
-                        backend_implementation_findings: backendFindings,
-                    },
-                };
-            }
-            // 问题六十八: 代码可维护性与可观测性契约
-            const codeObsModule = await lazyCodeObservability();
-            const obsFindings = codeObsModule.verifyChangedFilesObservability({
-                changed_files: implementationFiles,
-                file_contents: implementationContents,
-                intent: ctx.intent,
-            });
-            ctx.code_observability_findings = obsFindings;
-            await taskContext.save(ctx);
-            if (codeObsModule.hasBlockingObservabilityFindings(obsFindings)) {
-                return {
-                    result: {
-                        error: "代码可维护性/可观测性复验发现阻断项，需修复后重验",
-                        status: "blocked",
-                        diagnostic_code: TOOL_DIAGNOSTIC_CODES.codeObservabilityFinding,
-                        code_observability_findings: obsFindings,
-                    },
-                };
-            }
-        }
-        // 问题六十二: 设计产物验证必须读取用户项目真实文件，不接受占位合同自证通过。
-        const verifyWorkflowIntent = ctx.route_decision?.workflow_intent ?? ctx.classification?.route_decision?.workflow_intent;
-        const touchesDesignArtifacts = args.changed_files.some((file) => /docs\/architecture\/|docs\/api\/|openapi|db\/(?:migrations|schema)|架构设计|数据库设计|API接口规格/i.test(file));
-        if (verifyWorkflowIntent === "architecture_design" || touchesDesignArtifacts) {
-            const designModule = await lazyDesignArtifactPack();
-            const designPack = ctx.design_artifact_pack ?? designModule.createDesignArtifactPack(args.task_id);
-            const designVerification = designModule.verifyDesignArtifactPack(projectPath, designPack);
-            ctx.design_artifact_pack = {
-                ...designPack,
-                status: designVerification.status,
-                findings: designVerification.findings,
-                baseline_hashes: designVerification.hashes,
-                verified_at: new Date().toISOString(),
-            };
-            await taskContext.save(ctx);
-            if (!designVerification.passed) {
-                return {
-                    result: {
-                        error: "设计产物包复验未通过，不得继续生成编码或交付结论",
-                        status: "blocked",
-                        diagnostic_code: "SF-DESIGN-PACK-VERIFY-FAILED",
-                        design_artifact_findings: designVerification.findings,
-                        checked_files: designVerification.checked_files,
-                        recovery: "修复设计产物、补充用户确认并重新执行 sf_verify；不得只提交报告绕过缺口",
-                    },
-                };
-            }
-        }
-        // 问题六十三: 模板契约验证 — 按文件逐一匹配契约并校验
-        const sacModule = await lazyStandardAssetContract();
-        const formalArtifactContract = sacModule.matchTemplateContract({
-            output_artifact_kind: ctx.artifact_output?.kind,
-            workflow_intent: verifyWorkflowIntent,
-            route_decision: ctx.route_decision?.workflow_intent,
-        });
-        if (formalArtifactContract || !sacModule.isLowRiskTask({
-            route_decision: verifyWorkflowIntent ?? ctx.classification?.route_decision?.workflow_intent,
-            workflow_intent: verifyWorkflowIntent,
-            changed_files: args.changed_files,
-        })) {
-            for (const changedFile of args.changed_files) {
-                const absFile = path.join(projectPath, changedFile);
-                if (!await fsp.access(absFile).then(() => true, () => false) || !/\.md$/.test(changedFile))
-                    continue;
-                // 按实际文件路径匹配契约（不再使用 changed_files[0] 的契约校验全部文件）
-                const perFileContract = sacModule.matchTemplateContract({
-                    output_artifact_kind: ctx.artifact_output?.kind,
-                    workflow_intent: verifyWorkflowIntent,
-                    route_decision: ctx.route_decision?.workflow_intent,
-                    file_path: changedFile,
-                });
-                if (!perFileContract)
-                    continue;
-                const content = await fsp.readFile(absFile, "utf-8");
-                // 草稿阻断下游消费 — 不再静默跳过
-                if (sacModule.isDraftDocument(content)) {
-                    ctx.repair_reverify_directive = {
-                        contract_id: perFileContract.asset_id,
-                        file_path: changedFile,
-                        status: "draft_blocked",
-                        repair_suggestion: `文件 ${changedFile} 仍为草稿状态，草稿不可用于实现。请完善内容后重新验证。`,
-                        blocked: true,
-                    };
-                    await taskContext.save(ctx);
-                    return {
-                        result: {
-                            error: `草稿文件 ${changedFile} 不可用于实现，需完善后重新验证`,
-                            status: "blocked",
-                            diagnostic_code: "SF-CONTRACT-DRAFT",
-                            template_contract_id: perFileContract.asset_id,
-                            recovery: "完善草稿内容后重新执行 sf_verify",
-                        },
-                    };
-                }
-                const contractResult = sacModule.verifyOutputAgainstContract(perFileContract, content, projectPath);
-                if (!contractResult.passed) {
-                    const repairDirective = sacModule.createRepairReverifyDirective(perFileContract, contractResult);
-                    ctx.repair_reverify_directive = {
-                        contract_id: perFileContract.asset_id,
-                        file_path: changedFile,
-                        status: "repair_required",
-                        repair_suggestion: repairDirective.repair_suggestion,
-                        blocked: true,
-                    };
-                    await taskContext.save(ctx);
-                    return {
-                        result: {
-                            error: `文件 ${changedFile} 模板契约验证未通过，进入修复重验闭环`,
-                            status: "blocked",
-                            diagnostic_code: TOOL_DIAGNOSTIC_CODES.contractDraft,
-                            template_contract_id: perFileContract.asset_id,
-                            missing_fields: contractResult.missing_fields,
-                            messages: contractResult.messages,
-                            repair_suggestion: repairDirective.repair_suggestion,
-                            recovery: "修复文档缺口后重新执行 sf_verify；不得只报告不修复",
-                        },
-                    };
-                }
-            }
-            // 全部契约验证通过 — 清零修复重验指令
-            if (ctx.repair_reverify_directive) {
-                delete ctx.repair_reverify_directive;
-                await taskContext.save(ctx);
-            }
-        }
-        // RouteDecision 合同验证 — 无条件，在状态预检之前
-        const rdFromCtx = ctx.route_decision ?? ctx.classification?.route_decision ?? null;
-        const wtFromCtx = ctx.workflow_trace ?? ctx.expansion?.workflow_trace ?? null;
-        const rdContractInput = {
-            route_decision: rdFromCtx,
-            workflow_trace: wtFromCtx,
-            expansion_input_materials: ctx.expansion?.input_materials?.map((m) => ({ path_or_ref: m.path_or_ref })),
-            expansion_output_artifact: ctx.artifact_output ? { kind: ctx.artifact_output.kind, path: ctx.artifact_output.path } : null,
-            expansion_constraints: ctx.expansion?.contract?.constraints,
-        };
-        const rdFindings = verifyRouteDecisionContract(rdContractInput);
-        const hasHardFail = rdFindings.some(f => f.severity === "hard_fail" || f.severity === "blocked");
-        if (hasHardFail) {
-            return {
-                result: {
-                    error: "RouteDecision 合同检查失败",
-                    route_decision_contract_findings: rdFindings,
-                    status: "blocked",
-                },
-            };
-        }
-        const VALID_VERIFY_STATES = ["executing", "retrying"];
-        if (!VALID_VERIFY_STATES.includes(ctx.status)) {
-            return {
-                result: { error: `任务状态 ${ctx.status} 不可验证，需要 executing 或 retrying`, status: ctx.status },
-            };
-        }
-        const acceptanceItems = ctx.expansion
-            ? [...ctx.expansion.acceptance.automated, ...ctx.expansion.acceptance.manual]
-            : [];
-        // H4: 工作区完整性检查 — advisory 模式，仅警告不阻断
-        const integrity = await ioController.verify();
-        const h4Warning = !integrity.clean
-            ? { warning: `H4 advisory: ${integrity.message}`, dirty_files: integrity.dirty_files }
-            : undefined;
-        const verifyResult = (await lazyVerifier()).generateVerifyCommands(config, args.changed_files, acceptanceItems, ctx?.expansion?.workflow_trace?.route);
-        verifyResult.task_id = args.task_id;
-        // 创建 VerificationPlan（plan_only，非执行结果）
-        const vcModule = await lazyVerificationContract();
-        const allCommands = [
-            ...(verifyResult.checks?.build ?? []),
-            ...(verifyResult.checks?.tests ?? []),
-        ].map((c) => c.command);
-        const vPlan = vcModule.createVerificationPlan(args.task_id, allCommands, acceptanceItems.map((a) => a.description));
-        // sf_verify 仅生成计划，不执行命令 — 始终保存 not_executed
-        // 真实执行结果必须通过 recordVerificationExecution 单独录入
-        const vResult = vcModule.createNotExecutedResult(args.task_id, vPlan.plan_id, "sf_verify 生成命令，等待执行");
-        // 存储验证契约到任务上下文
-        const ctxForV = await taskContext.load(args.task_id);
-        if (ctxForV) {
-            ctxForV.verification_plan = vPlan;
-            ctxForV.verification_result = vResult;
-            await taskContext.save(ctxForV);
-        }
-        // 产物生命周期检查: draft → verified 需要 ArtifactVerificationResult.passed
-        let artifactVerificationResult;
-        let artifactFileMissing = false;
-        if (ctx.artifact_output && ctx.artifact_output.status === "draft") {
-            // 验证前解析产物文件并计算 hash
-            const artifact = ctx.artifact_output;
-            const fullPath = path.join(projectPath, artifact.path);
-            if (await fsp.access(fullPath).then(() => true, () => false)) {
-                const fileContent = await fsp.readFile(fullPath);
-                const hash = crypto.createHash("sha256").update(fileContent).digest("hex");
-                artifact.hash = `sha256:${hash}`;
-                if (!artifact.evidence_refs.some(r => r.startsWith("file:artifact:"))) {
-                    artifact.evidence_refs.push(`file:artifact:path=${artifact.path} hash=sha256:${hash}`);
-                }
-                // 保存更新后的产物（含 hash）
-                const ctxForHash = await taskContext.load(args.task_id);
-                if (ctxForHash?.artifact_output) {
-                    ctxForHash.artifact_output.hash = artifact.hash;
-                    if (!ctxForHash.artifact_output.evidence_refs.some(r => r.startsWith("file:artifact:"))) {
-                        ctxForHash.artifact_output.evidence_refs.push(`file:artifact:path=${artifact.path} hash=sha256:${hash}`);
-                    }
-                    await taskContext.save(ctxForHash);
-                }
-            }
-            else {
-                artifactFileMissing = true;
-            }
-            artifactVerificationResult = verifyArtifact(artifact.kind, artifact);
-        }
-        // 记录变更文件
-        // 写入护栏 — 检查变更文件是否在允许范围
-        if (args.changed_files.length > 0) {
-            const guardModule = await lazyEnforcementGuard();
-            const scopePaths = ctx.expansion?.scope?.allowed_paths ?? [];
-            for (const cf of args.changed_files) {
-                const writeFindings = guardModule.evaluateWriteGuard(ctx.classification?.route_decision?.route ?? "code_execution", cf, scopePaths, "command_execution_contract");
-                if (writeFindings.some((f) => f.blocked)) {
-                    return {
-                        result: {
-                            error: `写入护栏阻断: ${writeFindings[0].reason_zh}`,
-                            blocked_file: cf,
-                            guard_id: writeFindings[0].guard_id,
-                        },
-                    };
-                }
-            }
-        }
-        await taskContext.setExecution(args.task_id, args.changed_files);
-        // 无实际文件变更但存在产物时标记 no_change_artifact
-        if (args.changed_files.length === 0 && ctx.artifact_output) {
-            const execCtx = await taskContext.load(args.task_id);
-            if (execCtx?.execution) {
-                execCtx.execution.no_change_artifact = true;
-                await taskContext.save(execCtx);
-            }
-        }
-        // 生成验证命令成功后再转换状态，避免操作失败导致任务卡在 verifying
-        if (ctx.status === "retrying") {
-            await taskContext.updateStatus(args.task_id, "executing");
-        }
-        await taskContext.updateStatus(args.task_id, "verifying");
-        // 存储验证结果
-        await taskContext.setVerification(args.task_id, verifyResult);
-        // 产物生命周期转换: draft → verified 仅在 ArtifactVerificationResult.passed 时
-        if (ctx.artifact_output && ctx.artifact_output.status === "draft" && artifactVerificationResult?.passed) {
-            const evidenceRef = `verification:${ctx.task_id}:checks=${artifactVerificationResult.checks.length}:summary=${artifactVerificationResult.summary.slice(0, 60)}`;
-            try {
-                await taskContext.updateArtifactStatus(args.task_id, {
-                    status: "verified",
-                    evidenceRef,
-                    hasVerification: true,
-                });
-            }
-            catch {
-                // 转换被阻止 — 产物保持 draft，流水线继续
-            }
-        }
-        // 认知锚点上下文回放（按变更文件相关性）
-        const verifyAnchors = await loadRelevantAnchors({ file_paths: args.changed_files });
-        const verifyExtras = {};
-        if (h4Warning)
-            verifyExtras.h4_advisory = h4Warning;
-        if (verifyAnchors && verifyAnchors.length > 0)
-            verifyExtras.cognitive_anchors = verifyAnchors;
-        if (ctx.artifact_output && ctx.artifact_output.status === "draft" && artifactVerificationResult && !artifactVerificationResult.passed) {
-            const reason = artifactFileMissing
-                ? `产物文件不存在 (${ctx.artifact_output.path})，无法计算 hash`
-                : artifactVerificationResult.summary;
-            verifyExtras.artifact_warning = `产物验收检查未通过: ${reason}`;
-            verifyExtras.artifact_verification = artifactVerificationResult;
-        }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const verifyPayload = Object.keys(verifyExtras).length > 0
-            ? { ...verifyResult, ...verifyExtras }
-            : { ...verifyResult };
-        // 附加验证契约引用到返回结果
-        verifyPayload.verification_plan = vPlan;
-        verifyPayload.verification_result = vResult;
-        // 问题六十：验证结论必须经过 FactClaimVerifier，不得把计划当结果
-        {
-            const { createEvidenceGroundingSystem, assessTaskRisk } = await import("../../engine/evidence_grounding_contract.js");
-            const _vRoute = ctx.route_decision?.route ?? ctx.classification?.route_decision?.route;
-            const _vRisk = assessTaskRisk(ctx.classification?.task_type, _vRoute, ctx.intent);
-            if (_vRisk !== "low") {
-                const _veg = createEvidenceGroundingSystem();
-                // 只有真实执行结果才能作为 validation_result 证据
-                const _hasRealPassed = ctx.verification_result && ctx.verification_result.status === "passed";
-                if (_hasRealPassed) {
-                    _veg.registry.register({
-                        source_type: "validation_result",
-                        authority: "authoritative",
-                        freshness: "current",
-                        permission: "allowed",
-                        scope: "verification",
-                        description: `验证状态: ${ctx.verification_result.status}`,
-                        source_ref: `verification:${args.task_id}`,
-                    });
-                }
-                // 验证计划注册为 task_context，不冒充 validation_result
-                _veg.registry.register({
-                    source_type: "task_context",
-                    authority: "supporting",
-                    freshness: "current",
-                    permission: "allowed",
-                    scope: "verification_plan",
-                    description: `验证计划: ${vPlan ? "已生成" : "未生成"}`,
-                    source_ref: `verification-plan:${args.task_id}`,
-                });
-                if (args.changed_files.length > 0) {
-                    _veg.registry.register({
-                        source_type: "project_file",
-                        authority: "authoritative",
-                        freshness: "current",
-                        permission: "allowed",
-                        scope: "changed_files",
-                        description: `变更文件: ${args.changed_files.join(", ")}`,
-                        source_ref: `files:${args.changed_files.join(",")}`,
-                    });
-                }
-                const _vClaims = [{
-                        id: "claim-verify-1",
-                        category: "validation_result",
-                        claim_text: "验证结果基于真实命令执行",
-                        evidence_ids: _veg.registry.query({ source_type: "validation_result" }).map((e) => e.id),
-                        is_uncertain: false,
-                        risk_level: _vRisk,
-                    }];
-                const _vVerResult = _veg.verifier.verify(_vClaims, _vRisk);
-                const _vMatrix = _veg.builder.buildContext(_vClaims, {
-                    target_claims: _vClaims.map((c) => c.claim_text),
-                    source_types: [], keywords: [], max_results: 10,
-                });
-                _vMatrix.task_id = args.task_id;
-                const _vGate = _veg.gate.evaluate(_vMatrix, _vRisk);
-                // 写回 TaskContext
-                await taskContext.setEvidenceGroundingResult(args.task_id, {
-                    evidence_matrix: _vMatrix,
-                    evidence_gate_result: _vGate,
-                    unsupported_claims: _vGate.unsupported_claims,
-                    conflict_resolutions: _vMatrix.conflicts,
-                });
-                if (_vVerResult.unsupported.length > 0) {
-                    // 高风险：只有 plan 无 result → 写入 payload（不用 verifyExtras）
-                    verifyPayload._evidence_status = "not_verified";
-                    verifyPayload._evidence_reason = "验证结论需真实命令执行结果支撑，验证计划不能当作验证结果。请通过 sf_record_verification_execution 录入真实验证结果。";
-                    if (_vRisk === "high" || _vRisk === "critical") {
-                        verifyPayload._evidence_blocked = true;
-                    }
-                    else {
-                        verifyPayload._evidence_advisory = "验证结论需真实命令执行结果支撑，验证计划不能当作验证结果";
-                    }
-                }
-            }
-        }
-        // 验证后核心体验评估
-        try {
-            const hasVerificationEvidence = (verifyResult.checks?.build?.length ?? 0) > 0 || (verifyResult.checks?.tests?.length ?? 0) > 0;
-            const cepEvalResult = await assessCepAfterVerification({
-                task_id: args.task_id,
-                has_verification_evidence: hasVerificationEvidence,
-            });
-            // 将完整 CEP 结果写入 TaskContext
-            const cepModule = await import("../../engine/core_experience_principle.js");
-            const fullCepEval = cepModule.evaluateCoreExperiencePrinciple({
-                task_id: args.task_id, workflow_id: "sf_verify",
-                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: hasVerificationEvidence,
-                output_too_long_no_summary: false, report_only_no_repair: false,
-                failed_but_marked_done: false, auto_repair_overreach: false,
-                repair_reverified: false, outputs_raw_noise: false,
-            });
-            const ctxForCep = await taskContext.load(args.task_id);
-            if (ctxForCep) {
-                ctxForCep.core_experience_evaluation = fullCepEval;
-                await taskContext.save(ctxForCep);
-            }
-        }
-        catch (cepErr) {
-            internalWarn("CEP评估", "评估异常 (task=" + args.task_id + "):", cepErr?.message ?? cepErr);
-        }
-        return {
-            result: verifyPayload,
-        };
-    });
-    // ── sf_record_verification_execution: 录入真实验证执行结果（唯一 passed 入口） ──
-    registerSafeTool("sf_record_verification_execution", "录入真实验证执行结果，VerificationResult.status=passed 的唯一合法入口", RecordVerificationExecutionSchema, async (args) => {
-        const ctx = await taskContext.load(args.task_id);
-        if (!ctx) {
-            return { result: { error: "任务不存在" } };
-        }
-        // 必须有 VerificationPlan
-        const currentPlan = ctx.verification_plan;
-        if (!currentPlan) {
-            return { result: { error: "任务无 VerificationPlan，先执行 sf_verify 生成计划" } };
-        }
-        // plan_id 必须与 TaskContext 中当前 plan 一致
-        if (args.plan_id !== currentPlan.plan_id) {
-            return {
-                result: {
-                    error: `plan_id 不匹配: 请求 "${args.plan_id}"，当前任务计划 "${currentPlan.plan_id}" [${TOOL_DIAGNOSTIC_CODES.verifyPlanMismatch}]`,
-                    diagnostic_code: TOOL_DIAGNOSTIC_CODES.verifyPlanMismatch,
-                },
-            };
-        }
-        const vcModule = await lazyVerificationContract();
-        const result = vcModule.recordVerificationExecution(args.task_id, args.plan_id, args.execution_records, currentPlan);
-        // 持久化到 TaskContext
-        const ctxForSave = await taskContext.load(args.task_id);
-        if (ctxForSave) {
-            ctxForSave.verification_result = result;
-            await taskContext.save(ctxForSave);
-        }
-        return { result };
-    });
-    // ── sf_learn: 从执行结果中提取知识，支持重试循环控制 ──
-    registerSafeTool("sf_learn", "从任务执行结果中提取知识，低置信度暂存，高置信度直接入库", LearnSchema, async (args) => {
-        const ctx = await taskContext.load(args.task_id);
-        if (!ctx) {
-            return {
-                result: { error: "任务不存在" },
-            };
-        }
-        const VALID_LEARN_STATES = ["verifying", "executing"];
-        if (!VALID_LEARN_STATES.includes(ctx.status)) {
-            return {
-                result: { error: `任务状态 ${ctx.status} 不可学习，需要 verifying 或 executing`, status: ctx.status },
-            };
-        }
-        // 如适用，记录失败
-        if (args.result === "failure" && args.failure_type) {
-            await taskContext.setExecution(args.task_id, [], {
-                attempt: (ctx.execution?.attempt_count ?? 0) + 1,
-                type: args.failure_type,
-                message: args.verify_output
-                    ? `build=${args.verify_output.build_passed} tests=${args.verify_output.tests_passed}`
-                    : "unknown failure",
-                timestamp: new Date().toISOString(),
-            });
-            // 创建 FailureReport（脱敏，非 raw error_output）
-            const frModule = await lazyFailureReport();
-            const failureClass = args.failure_type;
-            const errorOutput = args.verify_output
-                ? `build=${args.verify_output.build_passed} tests=${args.verify_output.tests_passed}`
-                : "unknown failure";
-            const retryCount = (ctx.execution?.attempt_count ?? 0) + 1;
-            const policy = frModule.getRecoveryPolicy(failureClass);
-            const failureReport = frModule.createFailureReport(args.task_id, failureClass, errorOutput, retryCount, policy?.max_retries ?? 0);
-            // 存储 FailureReport 到任务上下文
-            const ctxForFailure = await taskContext.load(args.task_id);
-            if (ctxForFailure) {
-                ctxForFailure.failure_report = failureReport;
-                await taskContext.save(ctxForFailure);
-            }
-            // verifier 不可用时创建 DegradationEvent
-            if (!args.verify_output) {
-                const degModule = await lazyDegradation();
-                const degradationEvent = degModule.createDegradationEvent(args.task_id, "verifier", "full", "验证器输出不可用，无法判断 build/test 结果", ["verification_execution"]);
-                if (degradationEvent) {
-                    const ctxForDeg = await taskContext.load(args.task_id);
-                    if (ctxForDeg) {
-                        ctxForDeg.degradation_event = degradationEvent;
-                        await taskContext.save(ctxForDeg);
-                    }
-                }
-            }
-        }
-        // 转换到学习阶段
-        await taskContext.updateStatus(args.task_id, "learning");
-        const learnResult = await (await lazyEvolver()).evolve({
-            taskContext: ctx,
-            result: args.result,
-            verifyOutput: args.verify_output,
-            failureType: args.failure_type,
-            retryCount: ctx.execution?.attempt_count ?? 0,
-        }, projectPath);
-        // 确定最终状态: 重试或完成
-        const attemptCount = (ctx.execution?.attempt_count ?? 0) + (args.result === "failure" ? 1 : 0);
-        const maxAttempts = ctx.execution?.max_attempts ?? 3;
-        if (args.result === "failure" && attemptCount < maxAttempts && args.failure_type !== "deterministic") {
-            // 可重试: 转换到重试阶段
-            await taskContext.updateStatus(args.task_id, "retrying");
-            learnResult.retry_hint = `第 ${attemptCount}/${maxAttempts} 次尝试失败，${args.failure_type === "scope_insufficient" ? "需要扩大范围" : "请修复后重试"}`;
-        }
-        else {
-            // 检查主链路集成 — 即使 build/test 全绿，孤岛仍阻断 done
-            const integrationBlocked = ctx.verification?.main_path_integration
-                && !ctx.verification.main_path_integration.passed;
-            // 核心工程执行原则门禁 — required 原则失败不能进入 completed
-            const principlesBlocked = ctx.verification?.core_principles
-                && !ctx.verification.core_principles.overall_passed;
-            const finalStatus = args.result === "failure"
-                ? "failed"
-                : (integrationBlocked || principlesBlocked) ? "retrying" : "done";
-            await taskContext.updateStatus(args.task_id, finalStatus);
-            if (integrationBlocked && finalStatus === "retrying") {
-                learnResult.retry_hint = "主链路集成检查失败: 存在孤岛模块，请接入主链路后重试";
-            }
-            if (principlesBlocked && finalStatus === "retrying") {
-                const failedPrinciples = ctx.verification.core_principles.principles
-                    .filter((p) => p.status === "failed")
-                    .map((p) => p.principle_id);
-                learnResult.retry_hint = `核心工程执行原则检查失败: ${failedPrinciples.join(", ")}，请修复后重试`;
-            }
-        }
-        return {
-            result: learnResult,
-        };
-    });
-    // ── sf_status: 任务状态查询（current/recent/resume/cancel） ──
-    registerSafeTool("sf_status", "查询当前任务状态、列出近期任务、恢复中断任务或取消任务", StatusSchema, async (args) => {
-        const action = args.action || "current";
-        // Job 操作 — advisory，独立于任务操作
-        if (args.job_action) {
-            if (!args.job_id) {
-                return {
-                    result: { error: "job 操作需要 job_id" },
-                };
-            }
-            const jm = new (await lazyJob()).JobManager(taskContext.getStateDir());
-            const taskId = args.task_id ?? await jm.resolveTaskId(args.job_id) ?? "";
-            if (args.job_action === "job_status") {
-                const status = await jm.getJobStatus(args.job_id, taskId);
-                if (!status) {
-                    return {
-                        result: { error: `job ${args.job_id} 不存在或已过期` },
-                    };
-                }
-                return {
-                    result: { job: status },
-                };
-            }
-            if (args.job_action === "job_resume") {
-                const checkpoint = await jm.resumeFromCheckpoint(args.job_id, taskId);
-                if (!checkpoint) {
-                    return {
-                        result: { error: `job ${args.job_id} 无可恢复的 checkpoint` },
-                    };
-                }
-                return {
-                    result: {
-                        advisory: "job 恢复为 advisory 操作，需确认 checkpoint 数据与当前状态一致",
-                        job_id: checkpoint.job_id,
-                        task_id: checkpoint.task_id,
-                        phase: checkpoint.phase,
-                        checkpoint_number: checkpoint.checkpoint_number,
-                        cognitive_anchor: checkpoint.cognitive_anchor,
-                    },
-                };
-            }
-            if (args.job_action === "job_cancel") {
-                const removed = await jm.cancelJob(args.job_id, taskId);
-                return {
-                    result: {
-                        advisory: "job 取消为 advisory 操作",
-                        job_id: args.job_id,
-                        cancelled: removed,
-                    },
-                };
-            }
-        }
-        // 读取前自动将过期非终态任务标记为失败
-        try {
-            await taskContext.autoFailStale();
-        }
-        catch (e) {
-            internalWarn("autoFailStale", "出错:", e);
-        }
-        switch (action) {
-            case "current": {
-                const ctx = args.task_id
-                    ? await taskContext.load(args.task_id)
-                    : await taskContext.getCurrentTask();
-                if (!ctx) {
-                    return {
-                        result: { message: "当前无活跃任务" },
-                    };
-                }
-                const resumable = taskContext.isResumable(ctx);
-                const result = {
-                    task_id: ctx.task_id,
-                    intent: ctx.intent,
-                    status: ctx.status,
-                    created_at: ctx.created_at,
-                    resumable,
-                };
-                if (resumable) {
-                    result.resume_hint = taskContext.getResumeHint(ctx);
-                }
-                if (ctx.classification) {
-                    result.task_type = ctx.classification.task_type;
-                    result.risk = ctx.classification.risk;
-                    result.strategy = ctx.classification.strategy;
-                }
-                if (ctx.execution) {
-                    result.changed_files = ctx.execution.changed_files;
-                    result.attempt_count = ctx.execution.attempt_count;
-                }
-                // JobManager advisory: 查询关联 job 状态
-                try {
-                    const jm = new (await lazyJob()).JobManager(taskContext.getStateDir());
-                    const activeJobs = await jm.listActiveJobs();
-                    const relatedJob = activeJobs.find((j) => j.task_id === ctx.task_id);
-                    if (relatedJob) {
-                        result.job = {
-                            job_id: relatedJob.job_id,
-                            phase: relatedJob.current_phase,
-                            checkpoint_count: relatedJob.checkpoint_count,
-                            is_alive: relatedJob.is_alive,
-                            latest_anchor_summary: relatedJob.latest_anchor?.summary,
-                        };
-                    }
-                }
-                catch {
-                    // JobManager advisory — 忽略错误
-                }
-                return {
-                    result: result,
-                };
-            }
-            case "recent": {
-                const recent = await taskContext.listRecent(10);
-                return {
-                    result: { tasks: recent },
-                };
-            }
-            case "resume": {
-                if (!args.task_id) {
-                    return {
-                        result: { error: "恢复任务需要 task_id" },
-                    };
-                }
-                const ctx = await taskContext.load(args.task_id);
-                if (!ctx) {
-                    return {
-                        result: { error: "任务不存在" },
-                    };
-                }
-                if (!taskContext.isResumable(ctx)) {
-                    return {
-                        result: { error: `任务状态 ${ctx.status} 不可恢复`, status: ctx.status },
-                    };
-                }
-                const resumeResult = {
-                    task_id: ctx.task_id,
-                    intent: ctx.intent,
-                    status: ctx.status,
-                    resume_hint: taskContext.getResumeHint(ctx),
-                };
-                if (ctx.execution)
-                    resumeResult.execution = ctx.execution;
-                const resumeAnchors = ctx.execution?.changed_files
-                    ? await loadRelevantAnchors({ file_paths: ctx.execution.changed_files })
-                    : undefined;
-                if (resumeAnchors && resumeAnchors.length > 0)
-                    resumeResult.cognitive_anchors = resumeAnchors;
-                return { result: resumeResult };
-            }
-            case "cancel": {
-                if (!args.task_id) {
-                    return {
-                        result: { error: "取消任务需要 task_id" },
-                    };
-                }
-                const cancelled = await taskContext.cancel(args.task_id);
-                return {
-                    result: { task_id: args.task_id, cancelled },
-                };
-            }
-            case "retry_expand": {
-                if (!args.task_id) {
-                    return {
-                        result: { error: "重试 expand 需要 task_id" },
-                    };
-                }
-                const retried = await taskContext.retryExpand(args.task_id);
-                if (!retried) {
-                    return {
-                        result: { error: "任务不存在、非 failed 状态或缺少 classification，无法重试 expand", task_id: args.task_id },
-                    };
-                }
-                return {
-                    result: { task_id: args.task_id, retried: true, hint: "任务已恢复到 expanding 状态，可重新调用 sf_expand" },
-                };
-            }
-            case "archive_stale": {
-                const stale = await detectStaleCurrentTask(taskContext.getStateDir());
-                const taskId = args.task_id ?? stale.task_id;
-                if (!taskId) {
-                    return {
-                        result: { error: "归档陈旧任务指针需要 task_id，且当前未检测到陈旧任务" },
-                    };
-                }
-                if (!stale.is_stale || stale.task_id !== taskId) {
-                    return {
-                        result: {
-                            error: "当前任务指针未被判定为陈旧，不执行归档",
-                            task_id: taskId,
-                            stale_task: stale.is_stale ? stale : null,
-                        },
-                    };
-                }
-                const archived = await archiveStaleCurrentPointer(taskContext.getStateDir(), taskId);
-                return {
-                    result: {
-                        task_id: taskId,
-                        archived,
-                        archived_pointer_only: true,
-                        task_file_preserved: true,
-                    },
-                };
-            }
-            default:
-                return {
-                    result: { error: `未知操作: ${action}` },
-                };
-        }
-    });
-    // ── sf_plan: 复杂意图任务拆解为子任务列表 ──
-    registerSafeTool("sf_plan", "将复杂意图拆解为子任务列表。支持知识驱动的 pipeline_procedure 流程（自动绑定模板）和仓库边界拆分两种策略。仅在 complexity=high 时有效", PlanSchema, async (args) => {
-        const ctx = await taskContext.load(args.task_id);
-        if (!ctx?.classification) {
-            return {
-                result: { error: "任务不存在或尚未分类" },
-            };
-        }
-        const result = (await lazyPlanner()).planTask({
-            intent: ctx.intent,
-            classification: ctx.classification,
-            config,
-            knowledgeIndex,
-        });
-        result.task_id = args.task_id;
-        await taskContext.setPlanning(args.task_id, result);
-        return {
-            result: result,
-        };
-    });
-    // ── sf_plan_advance: 推进多阶段计划到下一步 ──
-    registerSafeTool("sf_plan_advance", "将多阶段计划推进到下一步。完成当前阶段后调用，自动更新 current_step_index 并返回下一阶段信息", PlanSchema, async (args) => {
-        const ctx = await taskContext.load(args.task_id);
-        if (!ctx?.planning || ctx.planning.sub_tasks.length === 0) {
-            return {
-                result: { error: "任务没有多阶段计划，请先调用 sf_plan" },
-            };
-        }
-        const plan = ctx.planning;
-        const previousStep = plan.sub_tasks[plan.current_step_index];
-        const previousStepTitle = previousStep?.title ?? "未知";
-        const nextIndex = plan.current_step_index + 1;
-        if (nextIndex >= plan.sub_tasks.length) {
-            return { result: {
-                    task_id: args.task_id,
-                    previous_step: previousStepTitle,
-                    current_step_index: plan.current_step_index,
-                    total_steps: plan.sub_tasks.length,
-                    is_completed: true,
-                    message: `所有 ${plan.sub_tasks.length} 个阶段已完成`,
-                } };
-        }
-        // 推进阶段索引
-        plan.current_step_index = nextIndex;
-        await taskContext.setPlanning(args.task_id, plan);
-        const nextStep = plan.sub_tasks[nextIndex];
-        return {
-            result: {
-                task_id: args.task_id,
-                previous_step: previousStepTitle,
-                current_step_index: nextIndex,
-                current_step: {
-                    id: nextStep.id,
-                    title: nextStep.title,
-                    output_path: nextStep.output_path,
-                },
-                total_steps: plan.sub_tasks.length,
-                is_completed: false,
-                message: `阶段推进: ${previousStepTitle} → ${nextStep.title}`,
-            },
-        };
-    });
-    // ── sf_analyze: 影响范围分析，建议是否扩大作用域 ──
-    registerSafeTool("sf_analyze", "分析意图的影响范围，对比声明范围，提示是否需要扩大作用域。建议性，不强制", AnalyzeSchema, async (args) => {
-        const ctx = await taskContext.load(args.task_id);
-        if (!ctx?.expansion) {
-            return {
-                result: { error: "任务尚未膨胀，请先调用 sf_expand" },
-            };
-        }
-        const result = await (await lazyImpact()).analyzeImpact({
-            intent: ctx.intent,
-            classification: ctx.classification,
-            expansion: ctx.expansion,
-            config,
-            projectPath,
-        });
-        result.task_id = args.task_id;
-        // 决策契约 advisory: 校验 analyze 输出
-        const decisionContract = (await lazyDecision()).validateDecisionOutput(result);
-        const advisoryExtras = {};
-        if (!decisionContract.passed) {
-            advisoryExtras.decision_contract_advisory = decisionContract.advisory;
-        }
-        return { result: Object.keys(advisoryExtras).length > 0 ? { ...result, ...advisoryExtras } : result };
-    });
-    // ── sf_review: 代码审查（质量、安全、性能、技术债务） ──
-    registerSafeTool("sf_review", "审查代码变更的质量、安全、性能和技术债务。hotfix 场景可跳过。建议性，不强制修复", ReviewSchema, async (args) => {
-        const ctx = await taskContext.load(args.task_id);
-        if (!ctx) {
-            return {
-                result: { error: "任务不存在" },
-            };
-        }
-        const tracker = new (await lazyDebt()).DebtTracker(projectPath);
-        const result = await (await lazyReviewer()).reviewCode({
-            changedFiles: args.changed_files,
-            projectPath,
-            config,
-            classification: ctx.classification,
-            fileContents: args.file_contents,
-            knowledgeIndex,
-            uncertainty_triggers: ctx.expansion?.uncertainty_triggers,
-        }, tracker);
-        result.task_id = args.task_id;
-        await taskContext.setCodeReview(args.task_id, result);
-        const contractContents = { ...(args.file_contents ?? {}) };
-        for (const changedFile of args.changed_files) {
-            if (contractContents[changedFile] !== undefined)
-                continue;
-            const absoluteFile = path.resolve(projectPath, changedFile);
-            try {
-                if (isSameOrDescendantPath(absoluteFile, path.resolve(projectPath), { caseSensitive: false }) && (await fsp.stat(absoluteFile)).isFile()) {
-                    contractContents[changedFile] = await fsp.readFile(absoluteFile, "utf-8");
-                }
-            }
-            catch {
-                // 无法读取的文件留给现有 reviewer 报告，不制造假结论。
-            }
-        }
-        const oodModule = await lazyOodSolid();
-        const solidFindings = oodModule.requiresOodSolidContract(ctx.intent, ctx.expansion?.workflow_trace?.route, args.changed_files)
-            || ctx.ood_solid_summary
-            ? [
-                ...oodModule.reviewSolidCode(contractContents),
-                ...oodModule.evaluateOverdesignRisk(ctx.intent, ctx.ood_solid_summary),
-            ]
-            : [];
-        const backendModule = await lazyBackendImplementation();
-        const backendFindings = backendModule.requiresBackendImplementationContract(ctx.intent, ctx.expansion?.workflow_trace?.route, args.changed_files)
-            || ctx.backend_implementation_work_package
-            ? backendModule.reviewBackendImplementationFiles(contractContents)
-            : [];
-        // 问题六十八: 代码可维护性与可观测性审查
-        const obsModule = await lazyCodeObservability();
-        const obsFindings = obsModule.requiresCodeObservabilityContract(ctx.intent, ctx.expansion?.workflow_trace?.route, args.changed_files)
-            || ctx.code_observability_work_package
-            ? obsModule.reviewCodeObservability(contractContents)
-            : [];
-        if (solidFindings.length > 0 || backendFindings.length > 0 || obsFindings.length > 0) {
-            const updatedCtx = await taskContext.load(args.task_id);
-            if (updatedCtx) {
-                updatedCtx.ood_solid_findings = solidFindings;
-                updatedCtx.backend_implementation_findings = backendFindings;
-                updatedCtx.code_observability_findings = obsFindings;
-                await taskContext.save(updatedCtx);
-            }
-        }
-        // 决策契约 advisory: 校验 review 输出
-        const decisionContract = (await lazyDecision()).validateDecisionOutput(result);
-        const reviewExtras = {};
-        if (!decisionContract.passed) {
-            reviewExtras.decision_contract_advisory = decisionContract.advisory;
-        }
-        if (solidFindings.length > 0)
-            reviewExtras.ood_solid_findings = solidFindings;
-        if (backendFindings.length > 0)
-            reviewExtras.backend_implementation_findings = backendFindings;
-        if (obsFindings.length > 0)
-            reviewExtras.code_observability_findings = obsFindings;
-        if (oodModule.hasBlockingSolidFindings(solidFindings) || backendModule.hasBlockingBackendFindings(backendFindings) || obsModule.hasBlockingObservabilityFindings(obsFindings)) {
-            reviewExtras.delivery_blocked = true;
-            reviewExtras.diagnostic_code = "SF-IMPLEMENTATION-CONTRACT-REVIEW-BLOCKED";
-        }
-        return { result: Object.keys(reviewExtras).length > 0 ? { ...result, ...reviewExtras } : result };
-    });
-    // ── sf_scaffold: 生成标准化代码骨架 ──
-    registerSafeTool("sf_scaffold", "根据项目模板生成标准化代码骨架（Controller/Service/DTO/测试等）。仅在 task_type=scaffold 时使用", ScaffoldSchema, async (args) => {
-        const ctx = await taskContext.load(args.task_id);
-        if (!ctx?.classification) {
-            return {
-                result: { error: "任务不存在或尚未分类" },
-            };
-        }
-        if (ctx.classification.task_type !== "scaffold") {
-            return {
-                result: {
-                    error: "sf_scaffold 仅适用于 scaffold 类型任务",
-                    current_type: ctx.classification.task_type,
-                },
-            };
-        }
-        const result = await (await lazyScaffolder()).generateScaffold({
-            intent: ctx.intent,
-            classification: ctx.classification,
-            config,
-            projectPath,
-        });
-        result.task_id = args.task_id;
-        return {
-            result: result,
-        };
-    });
-    // ── sf_deliver: 自动提交、推送、创建 PR ──
-    // ── sf_accept: 记录任务验收证据（本地验收 + 产物确认） ──
-    registerSafeTool("sf_accept", "记录任务验收证据，解除 sf_deliver 的本地验收门和产物确认门", AcceptSchema, async (args) => {
-        const ctx = await taskContext.load(args.task_id);
-        if (!ctx) {
-            return { result: { error: "任务不存在" } };
-        }
-        const runMode = args.run_mode;
-        const notes = String(args.acceptance_notes ?? "").trim();
-        const confirmedBy = String(args.confirmed_by ?? "").trim();
-        const confirmationRef = String(args.confirmation_ref ?? "").trim();
-        if (args.confirm !== true || !confirmedBy || !confirmationRef || !notes) {
-            return {
-                result: {
-                    error: "验收必须包含显式确认、确认者、可审计确认引用和验收说明",
-                    diagnostic_code: "SF-ACCEPT-CONFIRMATION-REQUIRED",
-                    recovery_next_tools: ["sf_accept", "sf_status"],
-                    recovery_forbidden_tools: ["sf_verify", "sf_scaffold", "sf_classify", "sf_expand"],
-                },
-            };
-        }
-        const currentVerification = ctx.verification_result;
-        if (currentVerification?.status !== "passed") {
-            return {
-                result: {
-                    error: "验收前必须已有真实执行并通过的 verification_result",
-                    diagnostic_code: "SF-ACCEPT-VERIFICATION-REQUIRED",
-                    recovery_next_tools: ["sf_verify", "sf_record_verification_execution", "sf_status"],
-                    recovery_forbidden_tools: ["sf_verify", "sf_scaffold", "sf_classify", "sf_expand"],
-                },
-            };
-        }
-        const evidenceRef = `acceptance:user_confirmation:${confirmationRef}`;
-        if (runMode === "manual_review") {
-            const acceptanceModule = await lazyLocalAcceptance();
-            if (!args.final_access) {
-                return {
-                    result: {
-                        error: "manual_review 验收缺少 final_access 真实访问证据",
-                        diagnostic_code: "SF-ACCEPT-FINAL-ACCESS-REQUIRED",
-                        recovery_next_tools: ["sf_accept", "sf_status"],
-                        recovery_forbidden_tools: ["sf_verify", "sf_scaffold", "sf_classify", "sf_expand"],
-                    },
-                };
-            }
-            const finalAccessResult = acceptanceModule.validateFinalAccess(args.final_access, "local_dev_server");
-            if (!finalAccessResult.passed) {
-                return {
-                    result: {
-                        error: `manual_review 验收证据不完整: ${finalAccessResult.blocking_reasons.join("; ")}`,
-                        diagnostic_code: "SF-ACCEPT-FINAL-ACCESS-INVALID",
-                        recovery_next_tools: ["sf_accept", "sf_status"],
-                        recovery_forbidden_tools: ["sf_verify", "sf_scaffold", "sf_classify", "sf_expand"],
-                    },
-                };
-            }
-        }
-        // 设置本地验收证据
-        ctx.local_acceptance_evidence = {
-            status: runMode === "manual_review" ? "passed" : "not_applicable",
-            run_mode: runMode,
-            confirmed_by: confirmedBy,
-            confirmation_ref: confirmationRef,
-            final_access: args.final_access ?? {
-                frontend_urls: [],
-                backend_urls: [],
-                docs_or_swagger_urls: [],
-                start_commands: [],
-                stop_commands: [],
-                running_status: "not_started",
-                manual_review_steps_zh: [notes],
-                known_limits_zh: [],
-            },
-            evidence_refs: [evidenceRef],
-        };
-        await taskContext.save(ctx);
-        let updatedCtx = ctx;
-        // 产物确认必须经过统一生命周期校验，不直接改写 status。
-        if (ctx.artifact_output && ctx.artifact_output.status === "verified") {
-            updatedCtx = await taskContext.updateArtifactStatus(args.task_id, {
-                status: "accepted",
-                evidenceRef,
-                hasAcceptance: true,
-            }) ?? ctx;
-        }
-        return {
-            result: {
-                task_id: args.task_id,
-                acceptance_status: "passed",
-                run_mode: runMode,
-                evidence_ref: evidenceRef,
-                artifact_transition: updatedCtx.artifact_output
-                    ? `${updatedCtx.artifact_output.status}`
-                    : "no_artifact",
-            },
-        };
-    });
-    // ── sf_deliver: 自动提交、推送、创建 PR ──
-    registerSafeTool("sf_deliver", "验收后自动提交代码、推送、创建 PR 和生成变更日志", DeliverSchema, async (args) => {
-        const ctx = await taskContext.load(args.task_id);
-        if (!ctx) {
-            return {
-                result: { error: "任务不存在" },
-            };
-        }
-        // H4: 交付前工作区完整性检查 — advisory 模式，仅警告不阻断
-        const deliverIntegrity = await ioController.verify();
-        const h4DeliverWarning = !deliverIntegrity.clean
-            ? { warning: `H4 advisory: ${deliverIntegrity.message}`, dirty_files: deliverIntegrity.dirty_files }
-            : undefined;
-        // 模板契约修复指令优先于通用产物状态提示，确保客户端获得可执行的修复重验路径。
-        if (ctx.repair_reverify_directive) {
-            return {
-                result: {
-                    error: "存在未清零的模板契约修复指令，需完成修复重验后才能交付",
-                    diagnostic_code: TOOL_DIAGNOSTIC_CODES.contractDraft,
-                    repair_directive: ctx.repair_reverify_directive,
-                    recovery: "修复文档缺口后重新执行 sf_verify，验证通过后 repair_reverify_directive 自动清零",
-                    recovery_next_tools: ["sf_learn", "sf_deliver", "sf_status"],
-                    recovery_forbidden_tools: ["sf_verify", "sf_scaffold", "sf_classify", "sf_expand"],
-                },
-            };
-        }
-        // 问题六十六/六十七: 审查或验证阶段产生的工程硬失败不得进入交付。
-        const oodModule = await lazyOodSolid();
-        if (oodModule.hasBlockingSolidFindings(ctx.ood_solid_findings ?? [])) {
-            return {
-                result: {
-                    error: "OOD/SOLID 契约仍存在硬失败，不得交付",
-                    diagnostic_code: TOOL_DIAGNOSTIC_CODES.oodDeliveryBlock,
-                    findings: ctx.ood_solid_findings,
-                    recovery: "按 finding 修复职责或依赖边界，并重新执行 sf_review 与 sf_verify",
-                },
-            };
-        }
-        const backendModule = await lazyBackendImplementation();
-        if (backendModule.hasBlockingBackendFindings(ctx.backend_implementation_findings ?? [])) {
-            return {
-                result: {
-                    error: "后端实现工程契约仍存在硬失败，不得交付",
-                    diagnostic_code: TOOL_DIAGNOSTIC_CODES.backendDeliveryBlock,
-                    findings: ctx.backend_implementation_findings,
-                    recovery: "按 finding 修复后端边界、安全或一致性问题，并重新执行 sf_review 与 sf_verify",
-                },
-            };
-        }
-        // 问题六十八: 代码可维护性与可观测性 P0 阻断交付。
-        const obsModule = await lazyCodeObservability();
-        const obsDeliveryBlock = obsModule.evaluateDeliveryBlock(ctx.code_observability_findings ?? []);
-        if (obsDeliveryBlock.blocked) {
-            return {
-                result: {
-                    error: `代码可维护性/可观测性存在阻断: ${obsDeliveryBlock.reason_zh}`,
-                    diagnostic_code: TOOL_DIAGNOSTIC_CODES.codeObservabilityFinding,
-                    findings: obsDeliveryBlock.blocking_findings,
-                    recovery: "按 finding 修复敏感信息泄漏、缺失日志或吞异常问题，并重新执行 sf_review 与 sf_verify",
-                },
-            };
-        }
-        // 产物状态门控: deliver 需要产物状态为 accepted 且有证据
-        if (ctx.artifact_output) {
-            const status = ctx.artifact_output.status;
-            if (status === "draft") {
-                return {
-                    result: {
-                        error: `产物状态为 ${status}，需先通过验证 (verified) 并确认 (accepted) 才能交付`,
-                        artifact_id: ctx.artifact_output.artifact_id,
-                        current_status: status,
-                    },
-                };
-            }
-            if (status === "verified") {
-                return {
-                    result: {
-                        error: `产物状态为 ${status}，需人工确认或后续 workflow 采用后变为 accepted 才能交付`,
-                        artifact_id: ctx.artifact_output.artifact_id,
-                        current_status: status,
-                    },
-                };
-            }
-            // accepted 必须有确认证据
-            if (status === "accepted") {
-                const hasAcceptanceEvidence = ctx.artifact_output.evidence_refs.some((r) => r.includes("acceptance") || r.includes("workflow_adoption"));
-                if (!hasAcceptanceEvidence) {
-                    return {
-                        result: {
-                            error: `产物状态为 accepted 但缺少确认证据 (acceptance/workflow_adoption evidence_ref)`,
-                            artifact_id: ctx.artifact_output.artifact_id,
-                            current_status: status,
-                        },
-                    };
-                }
-            }
-        }
-        // 问题六十二: 依赖设计产物的任务只有 implementation_ready 后才可交付。
-        if (ctx.design_artifact_pack && ctx.design_artifact_pack.status !== "implementation_ready") {
-            return {
-                result: {
-                    error: `设计产物包状态为 ${ctx.design_artifact_pack.status}，未达到 implementation_ready，不得交付`,
-                    diagnostic_code: "SF-DESIGN-PACK-NOT-READY",
-                    findings: ctx.design_artifact_pack.findings,
-                    recovery: "请完成设计产物真实复验并修复所有阻断项后重新交付",
-                },
-            };
-        }
-        if (ctx.traceability_binding && ctx.traceability_binding.status !== "bound") {
-            return {
-                result: {
-                    error: "追踪绑定未闭合，不得交付编码结果",
-                    diagnostic_code: TOOL_DIAGNOSTIC_CODES.traceabilityDeliveryBlocked,
-                    traceability_binding: ctx.traceability_binding,
-                    recovery: "补齐需求/原型/设计/切片/验收追踪矩阵并重新 sf_expand → sf_verify，通过后再 sf_deliver",
-                },
-            };
-        }
-        // 交付 lease 互斥检查
-        const leaseModule = await lazyWorkspaceLease();
-        const deliverLease = leaseModule.acquireLease(args.task_id, "delivery", [projectPath]);
-        if (deliverLease.lease?.status === "conflicted" || deliverLease.conflicts.length > 0) {
-            return {
-                result: {
-                    error: `交付 lease 冲突: ${deliverLease.conflicts.map((c) => `${c.conflict_type}: ${c.conflict_path}`).join(", ")}`,
-                    conflicts: deliverLease.conflicts,
-                },
-            };
-        }
-        // 交付就绪评估 — delivery_allowed=false 必须阻断交付
-        const drModule = await lazyDeliveryReadiness();
-        const guardModule = await lazyEnforcementGuard();
-        const currentVResult = ctx.verification_result;
-        const currentVPlan = ctx.verification_plan;
-        const guardFindings = guardModule.evaluateDeliveryReadinessGuard(currentVResult, currentVPlan);
-        // 问题五十一: 编码就绪门 — 交付前检查 coding readiness
-        const codingGate = await checkCodingReadinessGate({ ctx });
-        if (!codingGate.allowed) {
-            if (deliverLease.lease) {
-                leaseModule.releaseLease(deliverLease.lease.lease_id);
-            }
-            return {
-                result: {
-                    error: `编码就绪检查未通过: ${codingGate.reason_zh}`,
-                    missing_preconditions: codingGate.missing_preconditions,
-                    status: "blocked",
-                    recovery: "请先满足编码就绪条件（测试计划、验收标准、主链路入口）",
-                },
-            };
-        }
-        const metricsData = await (await lazyObservability()).collectDeliveryMetricSamples(taskContext.getStateDir());
-        // acceptanceConfig: 从项目配置推断 project_run_mode
-        const projectHasFrontend = config.tech_stack.frontend.lang && config.tech_stack.frontend.lang !== "none";
-        const projectHasBackend = config.tech_stack.backend.lang && config.tech_stack.backend.lang !== "none";
-        const readinessReport = drModule.evaluateDeliveryReadiness(args.task_id, currentVResult, guardFindings, true, // scope_check — 已在 sf_verify 写入护栏中检查
-        deliverLease.conflicts.length === 0, // lease_check — 无冲突即通过
-        true, // privacy_check — 已在任务创建时脱敏
-        true, // artifact_acceptance — 上面已检查产物状态
-        metricsData, projectHasFrontend ? { final_access: { frontend_urls: [], backend_urls: [], docs_or_swagger_urls: [], start_commands: [], stop_commands: [], running_status: "not_started", manual_review_steps_zh: [], known_limits_zh: [] }, project_run_mode: "local_dev_server" } : undefined);
-        // 保存就绪报告到任务上下文
-        const ctxForReadiness = await taskContext.load(args.task_id);
-        if (ctxForReadiness) {
-            ctxForReadiness.delivery_readiness = readinessReport;
-            await taskContext.save(ctxForReadiness);
-        }
-        if (!readinessReport.delivery_allowed) {
-            // 释放 lease 并阻断交付
-            if (deliverLease.lease) {
-                leaseModule.releaseLease(deliverLease.lease.lease_id);
-            }
-            return {
-                result: {
-                    error: `交付就绪检查未通过: ${readinessReport.blocking_findings.map((f) => f.message_zh).join("; ")}`,
-                    delivery_readiness: readinessReport,
-                },
-            };
-        }
-        // 问题五十二: 本地验收门 — 前端/全栈交付前必须有本地访问证据（仅在有施工指令契约时强制）
-        const hasInstructionContract = !!ctx?.instruction_contract;
-        if (hasInstructionContract) {
-            const localAcceptanceGate = await checkLocalAcceptanceGate({
-                ctx,
-                hasFrontend: !!projectHasFrontend,
-                hasBackend: !!projectHasBackend,
-                hasDockerCompose: false,
-                hasDockerfile: false,
-            });
-            if (!localAcceptanceGate.allowed) {
-                if (deliverLease.lease) {
-                    leaseModule.releaseLease(deliverLease.lease.lease_id);
-                }
-                return {
-                    result: {
-                        error: `本地验收检查未通过: ${localAcceptanceGate.reason_zh}`,
-                        required_but_missing: localAcceptanceGate.required_but_missing,
-                        status: "blocked",
-                        recovery: "请提供本地运行证据或说明 not_applicable 原因（如纯后端 API 项目）",
-                    },
-                };
-            }
-        }
-        // 问题六十：交付结论必须经过 UnsupportedClaimGate
-        {
-            const { createEvidenceGroundingSystem, assessTaskRisk } = await import("../../engine/evidence_grounding_contract.js");
-            const _dRoute = ctx.route_decision?.route ?? ctx.classification?.route_decision?.route;
-            const _dRisk = assessTaskRisk(ctx.classification?.task_type, _dRoute, ctx.intent);
-            if (_dRisk !== "low") {
-                const _deg = createEvidenceGroundingSystem();
-                // 注册验证结果和交付上下文
-                if (currentVResult) {
-                    _deg.registry.register({
-                        source_type: "validation_result",
-                        authority: "authoritative",
-                        freshness: "current",
-                        permission: "allowed",
-                        scope: "verification",
-                        description: `验证状态: ${currentVResult.status}`,
-                        source_ref: `verification:${args.task_id}`,
-                    });
-                }
-                _deg.registry.register({
-                    source_type: "task_context",
-                    authority: "authoritative",
-                    freshness: "current",
-                    permission: "allowed",
-                    scope: "delivery",
-                    description: "交付上下文",
-                    source_ref: `task:${args.task_id}`,
-                });
-                const _dClaims = [
-                    {
-                        id: "claim-deliver-1",
-                        category: "release_status",
-                        claim_text: "交付基于真实验证结果",
-                        evidence_ids: _deg.registry.query({ source_type: "validation_result" }).map((e) => e.id),
-                        is_uncertain: false,
-                        risk_level: _dRisk,
-                    },
-                ];
-                const _dMatrix = _deg.builder.buildContext(_dClaims, { target_claims: ["交付验证"], source_types: ["validation_result", "task_context"], keywords: ["验证", "交付"], max_results: 10 });
-                _dMatrix.task_id = args.task_id;
-                const _dGateResult = _deg.gate.evaluate(_dMatrix, _dRisk);
-                // 写回 TaskContext（blocked 也保存）
-                await taskContext.setEvidenceGroundingResult(args.task_id, {
-                    evidence_matrix: _dMatrix,
-                    evidence_gate_result: _dGateResult,
-                    unsupported_claims: _dGateResult.unsupported_claims,
-                    conflict_resolutions: _dMatrix.conflicts,
-                });
-                if (!_dGateResult.allowed) {
-                    if (deliverLease.lease) {
-                        leaseModule.releaseLease(deliverLease.lease.lease_id);
-                    }
-                    return {
-                        result: {
-                            error: `证据驱动门禁未通过: ${_dGateResult.reason_zh}`,
-                            diagnostic_code: _dGateResult.diagnostic_code,
-                            unsupported_claims: _dGateResult.unsupported_claims,
-                        },
-                    };
-                }
-            }
-        }
-        // 交付前检查 false completion（通过提取的主链路函数）
-        const cepNfcResult = await assessCepBeforeDelivery({
-            task_id: args.task_id,
-            verification_passed: currentVResult?.status === "passed",
-            build_passed: (currentVResult?.passed_commands ?? 0) > 0,
-            browser_acceptance_passed: ctx.artifact_output?.status === "accepted" || ctx.artifact_output === undefined,
-            guard_passed: guardFindings.length === 0 || guardFindings.every((f) => f.severity !== "hard_fail"),
-            evidence_sufficient: (currentVResult?.evidence_ids?.length ?? 0) > 0,
-            current_status: ctx.status === "done" ? "完成" : ctx.status,
-        });
-        if (cepNfcResult.decision === "blocked" || cepNfcResult.decision === "回退") {
-            if (deliverLease.lease) {
-                leaseModule.releaseLease(deliverLease.lease.lease_id);
-            }
-            const ctxForCep = await taskContext.load(args.task_id);
-            if (ctxForCep) {
-                ctxForCep.core_experience_evaluation = {
-                    task_id: args.task_id,
-                    workflow_id: "sf_deliver",
-                    evaluated_principles: ["auto_repair_no_fake_completion"],
-                    violations: [{
-                            principle: "auto_repair_no_fake_completion",
-                            severity: "blocking",
-                            reason_zh: cepNfcResult.reason_zh,
-                            evidence_refs: [],
-                            required_action: cepNfcResult.decision === "blocked" ? "block_delivery" : "回退",
-                        }],
-                    user_facing_summary_zh: `CEP 检查未通过: ${cepNfcResult.reason_zh}`,
-                    internal_trace_refs: [],
-                    passed: false,
-                };
-                await taskContext.save(ctxForCep);
-            }
-            return {
-                result: {
-                    error: `CEP false completion 检查未通过: ${cepNfcResult.reason_zh}`,
-                    cep_decision: cepNfcResult.decision,
-                },
-            };
-        }
-        const result = await (await lazyDelivery()).deliver({
-            taskContext: ctx,
-            config,
-            knowledgeIndex,
-            projectPath,
-            gitOps: (await lazyGitDeps()).realGitOps,
-            skipPush: args.skip_push,
-            skipPr: args.skip_pr,
-        });
-        await taskContext.setDelivery(args.task_id, result);
-        // 交付完成后释放 lease
-        if (deliverLease.lease) {
-            leaseModule.releaseLease(deliverLease.lease.lease_id);
-        }
-        return {
-            result: h4DeliverWarning ? { ...result, h4_advisory: h4DeliverWarning } : result,
-        };
-    });
-    // ── sf_coord_check: 预测性冲突检测和跨仓库协调 ──
-    registerSafeTool("sf_coord_check", "预测性冲突检测和跨仓库协调提示，检查分支状态、本地变更和潜在冲突", CoordCheckSchema, async (args) => {
-        const result = await (await lazyChangeCoord()).checkConflicts({
-            projectPath,
-            config,
-            branch: args.branch,
-            gitOps: (await lazyGitDeps()).realGitOps,
-        });
-        return {
-            result: result,
-        };
-    });
-    // ── sf_team_status: 团队活动流和工作负载查询 ──
-    registerSafeTool("sf_team_status", "查询团队活动流、成员工作负载、过期分支和知识库更新状态", TeamStatusSchema, async (args) => {
-        const result = await (await lazyTeam()).getTeamStatus({
-            projectPath,
-            config,
-            since: args.since,
-            gitOps: (await lazyGitDeps()).realGitOps,
-            knowledgeIndex: args.include_knowledge ? knowledgeIndex : undefined,
-        });
-        return {
-            result: result,
-        };
-    });
-    // ── sf_contract_check: API 契约变更检测 ──
-    registerSafeTool("sf_contract_check", "检测 API 契约变更（路由、DTO 字段等），评估破坏性影响和跨服务依赖", ContractCheckSchema, async (args) => {
-        let changedFiles = args.changed_files;
-        if (!changedFiles) {
-            const ctx = await taskContext.load(args.task_id);
-            changedFiles = ctx?.execution?.changed_files ?? [];
-        }
-        const result = await (await lazyContractGuard()).checkContractChanges({
-            changedFiles,
-            projectPath,
-            config,
-            gitOps: (await lazyGitDeps()).realGitOps,
-        });
-        return {
-            result: result,
-        };
-    });
-    // ── sf_onboard: 新人分步引导 ──
-    registerSafeTool("sf_onboard", "新人分步引导：项目概览 → 代码导览 → 知识回顾 → 首个任务建议", OnboardSchema, async (args) => {
-        const result = await (await lazyOnboarding()).onboard({
-            config,
-            projectPath,
-            knowledgeIndex,
-            gitOps: (await lazyGitDeps()).realGitOps,
-            currentStep: args.step,
-            reset: args.reset,
-        });
-        return {
-            result: result,
-        };
-    });
-    // ── sf_feasibility_check: 任务可行性评估 ──
-    registerSafeTool("sf_feasibility_check", "分析任务可行性：可行/风险/不可行三档评估，纯建议不阻断流程", FeasibilityCheckSchema, async (args) => {
-        const ctx = await taskContext.load(args.task_id);
-        if (!ctx?.classification) {
-            return {
-                result: { error: "任务不存在或未完成分类，请先调用 sf_classify" },
-            };
-        }
-        const result = (await lazyFeasibility()).checkFeasibility(ctx.classification, config);
-        return {
-            result: result,
-        };
-    });
-    // ── sf_debug: 智能排障（解析错误 → 根因分析 → 修复方案） ──
-    registerSafeTool("sf_debug", "智能排障：解析错误 → 追踪调用链 → 根因分析 → 修复方案 → 测试建议", DebugSchema, async (args) => {
-        const projectScope = [
-            ...config.scope.backend,
-            ...config.scope.frontend,
-        ];
-        const result = (await lazyDebugger()).debugError(args.error_output, args.task_id || `debug-${Date.now()}`, projectScope);
-        return {
-            result: result,
-        };
-    });
-    // ── sf_observability: 系统可观测和运行报告 ──
-    registerSafeTool("sf_observability", "系统可观测：运行指标、成本估算、告警检测、能力状态、周期报告", ObservabilitySchema, async (args) => {
-        const stateDir = taskContext.getStateDir();
-        const result = await (await lazyObservability()).generateReport(stateDir, args.period_days);
-        const capability = (await lazyCapability()).getSummary();
-        const output = { ...result, capability };
-        return {
-            result: output,
-        };
-    });
-    // ── sf_migration_check: 数据库迁移安全性分析 ──
-    registerSafeTool("sf_migration_check", "分析数据库迁移文件安全性：检测破坏性操作（DROP/DELETE/TRUNCATE）并生成回滚建议", MigrationCheckSchema, async (args) => {
-        const result = (await lazyMigration()).analyzeMigration(args.content, args.filename);
-        return {
-            result: result,
-        };
-    });
-    // ── sf_test_guide: 基于变更文件生成测试指引 ──
-    registerSafeTool("sf_test_guide", "根据变更文件类型生成测试指引：推荐测试类型、场景、Mock 点和断言模板", TestGuideSchema, async (args) => {
-        const result = (await lazyTestGen()).generateTestGuide(args.changed_files, [], config);
-        return {
-            result: result,
-        };
-    });
-    // ── sf_test_quality: 测试文件质量五维评分 ──
-    registerSafeTool("sf_test_quality", "评估测试文件质量：断言密度、边界覆盖、命名、重复率、场景覆盖五维评分", TestQualitySchema, async (args) => {
-        const result = (await lazyTestQuality()).analyzeTestQuality(args.content, args.filename);
-        return {
-            result: result,
-        };
-    });
-    // ── sf_dependency_scan: 依赖漏洞扫描 ──
-    registerSafeTool("sf_dependency_scan", "扫描依赖声明文件漏洞：已知 CVE 规则匹配、未锁定版本检测、支持 npm/maven/gradle", DependencyScanSchema, async (args) => {
-        const result = (await lazyDepScan()).scanDependencies(args.content, args.filename);
-        return {
-            result: result,
-        };
-    });
-    // ── sf_debt_report: 技术债务报告生成 ──
-    registerSafeTool("sf_debt_report", "生成技术债务报告：按分类/严重度聚合、30 天趋势、优先级排序 Top 5", {}, async () => {
-        const tracker = new (await lazyDebt()).DebtTracker(projectPath);
-        const result = await (await lazyDebtReport()).generateDebtReport(tracker);
-        return {
-            result: result,
-        };
-    });
-    // ── sf_explore: 自主技术选型与方案证伪 ──
-    registerSafeTool("sf_explore", "自主技术选型引擎：行业基准对比 + 四维权重矩阵 + 最优解宣誓 + 方案证伪 + A/B 决策诱导。禁止凭空捏造，必须基于行业标准", ExploreSchema, async (args) => {
-        let classification;
-        if (args.task_id) {
-            const ctx = await taskContext.load(args.task_id);
-            classification = ctx?.classification;
-        }
-        const result = (await lazyExploration()).exploreSolutions({
-            domain_query: args.domain_query,
-            projectConfig: config,
-            classification,
-            knowledgeIndex,
-        });
-        // 决策契约 advisory: sf_explore 应始终通过（10 字段已内置）
-        const decisionContract = (await lazyDecision()).validateDecisionOutput(result);
-        const exploreExtras = {};
-        if (!decisionContract.passed) {
-            exploreExtras.decision_contract_advisory = decisionContract.advisory;
-        }
-        return { result: Object.keys(exploreExtras).length > 0 ? { ...result, ...exploreExtras } : result };
-    });
-    // ── sf_knowledge_audit: 知识库健康审计 ──
-    registerSafeTool("sf_knowledge_audit", "审计知识库：识别过时条目、重复触发词、格式缺失、覆盖缺口。定期执行或手动触发", {}, async () => {
-        const result = await (await lazyKnowledge()).auditKnowledge(knowledgeIndex, config);
-        return {
-            result: result,
-        };
-    });
-    // ── sf_knowledge_add: 新增知识条目（默认保存为草稿） ──
-    const KnowledgeAddSchema = {
-        title: z.string().describe("知识条目标题（英文 kebab-case，如 payment-rules）"),
-        type: z.enum(["pattern", "procedure", "pipeline_procedure", "domain", "acceptance_template", "review_rule"]).describe("知识类型"),
-        scope: z.array(z.string()).describe("适用范围（如 [backend]、[frontend]、[backend, frontend]）"),
-        when_triggers: z.string().describe("触发关键词（逗号分隔）"),
-        decision_rules: z.string().optional().describe("决策规则（每行一条）"),
-        save_to_drafts: z.boolean().optional().describe("是否保存为草稿（默认 true，需人工 review 后移入正式目录）"),
-        auto_enrich: z.boolean().optional().describe("是否返回行业最佳实践探索指引（默认 true，宿主 AI 将自动执行探索并填充内容）"),
-        confirm: z.boolean().optional().describe("显式确认写入知识库，必须为 true"),
-        authorized: z.boolean().optional().describe("confirm 的兼容别名"),
-    };
-    registerSafeTool("sf_knowledge_add", "新增知识条目。默认保存为草稿到 .soloforge/knowledge/drafts/，人工确认后移入正式目录", KnowledgeAddSchema, async (args) => {
-        const result = await (await lazyKnowledge()).addKnowledge({
-            title: args.title,
-            type: args.type,
-            scope: args.scope,
-            when_triggers: args.when_triggers,
-            decision_rules: args.decision_rules,
-            save_to_drafts: args.save_to_drafts,
-            auto_enrich: args.auto_enrich,
-        }, config);
-        return {
-            result: result,
-        };
-    });
-    // ── sf_knowledge_update: 更新已有知识条目（自动创建备份） ──
-    const KnowledgeUpdateSchema = {
-        entry_name: z.string().describe("要更新的知识条目名称（如 payment-rules）"),
-        when_triggers: z.string().optional().describe("新的触发关键词（替换现有）"),
-        add_decision_rules: z.array(z.string()).optional().describe("追加的决策规则"),
-        add_acceptance_criteria: z.array(z.string()).optional().describe("追加的验收项"),
-        status: z.enum(["active", "deprecated"]).optional().describe("更新条目状态"),
-        confirm: z.boolean().optional().describe("显式确认写入知识库，必须为 true"),
-        authorized: z.boolean().optional().describe("confirm 的兼容别名"),
-    };
-    registerSafeTool("sf_knowledge_update", "更新已有知识条目：追加规则、更新触发词、标记废弃。自动创建备份", KnowledgeUpdateSchema, async (args) => {
-        const result = await (await lazyKnowledge()).updateKnowledge({
-            entry_name: args.entry_name,
-            updates: {
-                when_triggers: args.when_triggers,
-                add_decision_rules: args.add_decision_rules,
-                add_acceptance_criteria: args.add_acceptance_criteria,
-                status: args.status,
-            },
-        }, knowledgeIndex, config);
-        // 重载知识索引
-        if (result.success) {
-            await knowledgeIndex.reload();
-        }
-        return {
-            result: result,
-        };
-    });
-    // ── sf_resume_workspace: 工作区状态唤醒（解决前端刷新导致UUID丢失） ──
-    registerSafeTool("sf_resume_workspace", "扫描 .soloforge/state/ 目录，恢复中断工单并播报当前进度。新会话启动时必须优先调用", {}, async () => {
-        const result = await (await lazyWorkspaceResumer()).scanAndResume(taskContext);
-        // 认知锚点：按恢复任务的 changed_files 相关性加载，禁止全量
-        if (result.task) {
-            const ctx = await taskContext.load(result.task.task_id);
-            const changedFiles = ctx?.execution?.changed_files;
-            if (changedFiles && changedFiles.length > 0) {
-                const anchors = await loadRelevantAnchors({ file_paths: changedFiles });
-                if (anchors && anchors.length > 0) {
-                    result.cognitive_anchors = anchors;
-                }
-            }
-        }
-        // JobManager advisory: 查询活跃 jobs
-        try {
-            const jm = new (await lazyJob()).JobManager(taskContext.getStateDir());
-            const activeJobs = await jm.listActiveJobs();
-            if (activeJobs.length > 0) {
-                result.active_jobs = activeJobs.map((j) => ({
-                    job_id: j.job_id,
-                    task_id: j.task_id,
-                    phase: j.current_phase,
-                    is_alive: j.is_alive,
-                    latest_anchor_summary: j.latest_anchor?.summary,
-                    checkpoint_count: j.checkpoint_count,
-                }));
-            }
-        }
-        catch {
-            // JobManager advisory — 忽略错误
-        }
-        return {
-            result: result,
-        };
-    });
-    // ── sf_audit_sample: 从审计池按风险加权抽样生成抽检清单 ──
-    const AuditSampleSchema = {
-        seed: z.number().optional().describe("抽样种子（默认 0，同种子可复现）"),
-    };
-    registerSafeTool("sf_audit_sample", "从审计池按风险加权抽样，生成抽检清单（SamplingDecision 列表）。只读，不落盘，不生成逃逸报告，不改能力状态", AuditSampleSchema, async (args) => {
-        const stateDir = taskContext.getStateDir();
-        const pool = new (await lazyAuditPool()).AuditPool(stateDir);
-        const items = pool.list();
-        const seed = args.seed ?? 0;
-        const result = (await lazyAuditSampler()).sampleAuditItems(items, seed);
-        return {
-            result: result,
-        };
-    });
-    // ── sf_escape_report: 记录逃逸/误伤/工具故障报告 ──
-    const EscapeReportSchema = {
-        escape_id: z.string().describe("逃逸报告唯一 ID"),
-        task_id: z.string().describe("关联任务 ID"),
-        policy_id: z.string().describe("关联能力 policy ID"),
-        failure_type: z.enum(["rule_gap", "weak_test", "bad_evidence", "ai_escape", "human_miss", "tool_bug", "false_positive"]).describe("失败类型"),
-        expected_guard: z.string().describe("期望的守卫行为"),
-        actual_escape: z.string().describe("实际的逃逸行为"),
-        evidence: z.string().describe("证据"),
-        root_cause: z.string().describe("根因分析"),
-        fix_required: z.string().describe("修复要求"),
-        owner: z.string().describe("负责人"),
-        due_date: z.string().describe("修复截止日期"),
-        capability_action: z.enum(["keep", "downgrade", "disable", "promote_blocked"]).describe("建议的能力动作"),
-        created_at: z.string().optional().describe("报告时间（ISO，默认当前时间）"),
-    };
-    registerSafeTool("sf_escape_report", "记录逃逸、误伤或工具故障报告。只落盘记录，不自动降级，不改能力状态", EscapeReportSchema, async (args) => {
-        const stateDir = taskContext.getStateDir();
-        const store = new (await lazyEscape()).EscapeReportStore(stateDir);
-        const report = {
-            escape_id: args.escape_id,
-            task_id: args.task_id,
-            policy_id: args.policy_id,
-            failure_type: args.failure_type,
-            expected_guard: args.expected_guard,
-            actual_escape: args.actual_escape,
-            evidence: args.evidence,
-            root_cause: args.root_cause,
-            fix_required: args.fix_required,
-            owner: args.owner,
-            due_date: args.due_date,
-            capability_action: args.capability_action,
-            created_at: args.created_at ?? new Date().toISOString(),
-        };
-        store.append(report);
-        return {
-            result: { recorded: true, escape_id: report.escape_id },
-        };
-    });
-    // ── sf_capability_update: 根据复盘结果更新 Capability Registry ──
-    const CapabilityUpdateSchema = {
-        policy_id: z.string().describe("要更新的 policy ID（如 CAP-003）"),
-        target_state: z.enum(["enforced", "advisory", "experimental", "removed"]).describe("目标状态"),
-        reason: z.string().describe("变更原因"),
-        evidence_ids: z.array(z.string()).describe("支撑此变更的 escape report ID 列表"),
-        confirmed_by: z.string().describe("人工确认者标识（如操作者名字）"),
-        dry_run: z.boolean().optional().describe("dry_run 模式：只校验不持久化（默认 false）"),
-        confirm: z.boolean().describe("人工确认标志，必须为 true 才能执行变更"),
-    };
-    registerSafeTool("sf_capability_update", "根据复盘结果更新 Capability Registry 状态。支持 dry_run 校验、证据校验、人工确认。不会自动触发，必须显式调用", CapabilityUpdateSchema, async (args) => {
-        const stateDir = taskContext.getStateDir();
-        const escapeStore = new (await lazyEscape()).EscapeReportStore(stateDir);
-        const stateStore = new (await lazyCapState()).CapabilityStateStore(stateDir);
-        const escapeReports = escapeStore.list();
-        const capabilities = (await lazyCapability()).getAllCapabilities();
-        const cap = capabilities.find((c) => c.policy_id === args.policy_id);
-        const currentState = stateStore.getEffectiveState(args.policy_id, cap?.state ?? "experimental");
-        const result = stateStore.apply({
-            policy_id: args.policy_id,
-            target_state: args.target_state,
-            reason: args.reason,
-            evidence_ids: args.evidence_ids,
-            confirmed_by: args.confirmed_by,
-            dry_run: args.dry_run ?? false,
-            confirm: args.confirm,
-        }, currentState, cap?.id ?? null, escapeReports);
-        return {
-            result: result,
-        };
-    });
-    // ── sf_governance_report: 治理健康报告 ──
-    const GovernanceReportSchema = {
-        seed: z.number().optional().describe("抽样种子（用于计算 sampled_count，默认 0）"),
-    };
-    registerSafeTool("sf_governance_report", "生成治理健康报告：汇总审计池、逃逸报告、能力动作决策。只读，不改状态", GovernanceReportSchema, async (args) => {
-        const stateDir = taskContext.getStateDir();
-        const seed = args.seed ?? 0;
-        const pool = new (await lazyAuditPool()).AuditPool(stateDir);
-        const escapeStore = new (await lazyEscape()).EscapeReportStore(stateDir);
-        const auditItems = pool.list();
-        const auditStats = pool.stats();
-        const escapeReports = escapeStore.list();
-        const escapeStats = escapeStore.stats();
-        // 为所有能力生成动作决策（使用有效状态）
-        const capabilities = (await lazyCapability()).getAllCapabilities();
-        const stateStore = new (await lazyCapState()).CapabilityStateStore(stateDir);
-        const decisions = await Promise.all(capabilities.map(async (cap) => {
-            const effectiveState = stateStore.getEffectiveState(cap.policy_id, cap.state);
-            return (await lazyCapAdvisor()).decideAction(escapeReports, effectiveState, cap.policy_id);
-        }));
-        // 为 sampled_count 生成抽样决策
-        const sampleResult = (await lazyAuditSampler()).sampleAuditItems(auditItems, seed);
-        // 双层机制发现 
-        const dlFindings = (await lazyDualLayer()).validateMechanismLayerMaps();
-        const dlMechanismCount = (await lazyDualLayer()).listMechanismLayerMaps().length;
-        // 收集近期任务的产物记录 
-        const recentTasks = await taskContext.listRecent(20);
-        const artifacts = [];
-        for (const t of recentTasks) {
-            const tCtx = await taskContext.load(t.task_id);
-            if (tCtx?.artifact_output)
-                artifacts.push(tCtx.artifact_output);
-        }
-        // 收集配置解析报告 — 使用共享函数获取真实数据 
-        let configReports = [];
-        let configEntries = [];
-        try {
-            const resolved = await (await lazyConfigPrecedence()).resolveCurrentProjectConfigReports(projectPath);
-            configReports = resolved.reports;
-            configEntries = resolved.entries;
-        }
-        catch (e) {
-            internalWarn("配置报告", "解析失败:", e instanceof Error ? e.message : String(e));
-        }
-        // 同时包含近期任务上下文中的报告
-        for (const t of recentTasks) {
-            const tCtx = await taskContext.load(t.task_id);
-            if (tCtx?.expansion?.config_resolution_reports) {
-                configReports.push(...tCtx.expansion.config_resolution_reports);
-            }
-        }
-        const report = (await lazyGovernance()).generateReport(auditStats, auditItems, escapeReports, escapeStats, decisions, new Date(), sampleResult.decisions, dlFindings, dlMechanismCount, artifacts.length > 0 ? artifacts : undefined, configReports.length > 0 ? configReports : undefined, configEntries.length > 0 ? configEntries : undefined);
-        return {
-            result: report,
-        };
-    });
-    // ── sf_audit_integration: 主链路集成审计 ──
-    const AuditIntegrationSchema = {
-        changed_files: z.array(z.string()).optional().describe("只审计指定的变更文件列表"),
-        json_output: z.boolean().optional().describe("以 JSON 格式输出（默认为人类可读文本）"),
-    };
-    registerSafeTool("sf_audit_integration", "审计生产代码的主链路集成状态，检测孤岛模块（只被测试导入、无生产代码调用的模块）", AuditIntegrationSchema, async (args) => {
-        const projectPath = config._projectPath || process.cwd();
-        // 使用作用域感知的生产文件收集（支持多仓库、多语言）
-        const { collectAllProductionFiles } = await import("../../engine/main_path_integration_contract.js");
-        const allProdFiles = collectAllProductionFiles(projectPath, config);
-        if (allProdFiles.length === 0) {
-            return {
-                result: { error: "未找到生产源文件" },
-            };
-        }
-        const targetFiles = args.changed_files
-            ? allProdFiles.filter((rel) => args.changed_files.some((cf) => rel === cf || rel.startsWith(cf.replace(/\.(ts|tsx|js|jsx|java|kt|go|py)$/, ""))))
-            : allProdFiles;
-        const contracts = (await lazyMainPath()).buildMainPathIntegrationContracts(projectPath, targetFiles, config);
-        const report = (await lazyMainPath()).auditIntegration(contracts);
-        if (args.json_output) {
-            return {
-                result: report,
-            };
-        }
-        const lines = [];
-        lines.push("主链路集成审计报告");
-        lines.push(`受检模块: ${targetFiles.length} | 孤岛: ${report.orphan_modules.length} | 仅测试: ${report.test_only_modules.length} | 仅注册: ${report.registry_only_modules.length}`);
-        lines.push("");
-        for (const finding of report.findings) {
-            const icon = finding.severity === "hard_fail" ? "X" : finding.severity === "warning" ? "~" : "i";
-            lines.push(`${icon} ${finding.module_path}: ${finding.reason}`);
-            if (finding.recommended_action) {
-                lines.push(`  -> ${finding.recommended_action}`);
-            }
-        }
-        if (report.findings.length === 0) {
-            lines.push("所有受检模块已通过集成检查。");
-        }
-        return {
-            result: { text: lines.join("\n") },
-        };
-    });
-    // ── sf_navigation: 工作流导航 — 问题六十五 ──
-    const NavigationSchema = {
-        project_path: z.string().optional().describe("项目路径（可选，默认当前目录）"),
-    };
-    registerSafeTool("sf_navigation", "查询工作流导航: 当前项目阶段、任务阶段、下一步操作和禁止操作。用于\"下一步\"\"继续\"\"现在能写代码吗\"等模糊推进意图。不得靠模型经验回答，必须调用此工具获取真实导航状态", NavigationSchema, async (args) => {
-        const projectPath = args.project_path || config._projectPath || process.cwd();
-        const { planNextAction } = await import("../../engine/next_action_planner.js");
-        const plan = await planNextAction(projectPath);
-        return {
-            result: {
-                project_stage: plan.project_stage,
-                task_stage: plan.task_stage,
-                current_task_id: plan.current_task_id,
-                confidence: plan.confidence,
-                stage_evidence: plan.stage_evidence,
-                blocking_reasons: plan.blocking_reasons,
-                stale_task: plan.stale_task,
-                confirmation_decisions: plan.confirmation_decisions,
-                work_package: plan.work_package ? {
-                    id: plan.work_package.id,
-                    goal_zh: plan.work_package.goal_zh,
-                    description_zh: plan.work_package.description_zh,
-                    action: plan.work_package.action,
-                    tool_name: plan.work_package.tool_name,
-                    must_read: plan.work_package.must_read,
-                    forbidden_changes: plan.work_package.forbidden_changes,
-                    expected_outputs: plan.work_package.expected_outputs,
-                    acceptance_commands: plan.work_package.acceptance_commands,
-                } : null,
-                disallowed_actions: plan.disallowed_actions,
-                recommended_commands: plan.recommended_commands,
-                recommended_prompt_zh: plan.recommended_prompt_zh,
-            },
-        };
-    });
-}
+export { registerTools } from "../../server/tools/index.js";
+export { createToolRegistrar } from "../../server/tools/middleware.js";
 //# sourceMappingURL=tools.js.map