soloforge 1.2.19 → 1.3.0

package/dist/adapters/claude_code/tools.js

@@ -1,10 +1,11 @@
+import { debug, internalWarn } from "../../engine/logger.js";
 import { z } from "zod";
 import path from "node:path";
 import fss from "node:fs";
 import crypto from "node:crypto";
 import { verifyArtifact } from "../../engine/artifact_contract_registry.js";
 import { verifyRouteDecisionContract } from "../../engine/route_decision_contract_verifier.js";
-import { findToolInvocationContractByName, createToolTrace, validateToolInvocation, } from "../../engine/tool_invocation_contract_registry.js";
+import { findToolInvocationContractByName, createToolTrace, validateToolInvocation, hasWriteSideEffect, } from "../../engine/tool_invocation_contract_registry.js";
 function createLazy(loader) {
     let mod = { loaded: null, promise: null };
     return () => {
@@ -37,6 +38,7 @@ 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 lazyPlanGate = createLazy(() => import("../../engine/plan_proposal_gate.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"));
@@ -59,6 +61,23 @@ const lazyDualLayer = createLazy(() => import("../../engine/dual_layer_mechanism
 const lazyInputMaterial = createLazy(() => import("../../engine/input_material_contract_registry.js"));
 const lazyConfigCmd = createLazy(() => import("../../bin/config_commands.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 lazyRetentionPolicy = createLazy(() => import("../../engine/retention_policy.js"));
+const lazyDiagnosticRegistry = createLazy(() => import("../../engine/diagnostic_registry.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"));
 // ── Zod Schema 定义 ──
 const ClassifySchema = {
     intent: z.string().describe("开发者意图描述"),
@@ -103,6 +122,19 @@ const ReviewSchema = {
 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 DeliverSchema = {
     task_id: z.string().describe("任务 ID"),
     changed_files: z.array(z.string()).optional().describe("变更文件列表（不传则使用任务记录中的文件）"),
@@ -167,13 +199,524 @@ const ExploreSchema = {
  * @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: "SF-PLAN-5001",
+            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 = 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 };
+}
+/**
+ * 架构设计门 — 架构设计类任务膨胀前执行 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 };
+}
+/**
+ * 现有系统分析门 — 现有项目编码前必须先做分析。
+ * 问题五十: 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"],
+        };
+    }
+    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"]);
+/** 技术选型/架构/数据库/框架/高影响决策 → 需 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("; ")}` };
+    }
+    // 有决策记录时评估执行状态
+    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 };
+    }
+    return { allowed: true };
+}
+/**
+ * 脑暴/方案探索门 — 不确定项需多方案+推荐理由+用户确认。
+ * 问题四十一-brainstorm: 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 };
+    }
+    // 脑暴推荐永远不能自动执行 — 需 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");
+    return 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,
+    });
+}
 /**
  * 注册所有 MCP 工具到服务器实例。
  * @param server - McpServer 实例
  * @param deps - 工具依赖项（配置、知识索引、任务上下文）
  */
 export async function registerTools(server, deps) {
-    console.error("[soloForge] 工具注册: 开始注册 MCP 工具...");
+    debug("工具注册", "开始注册 MCP 工具...");
     const { config, knowledgeIndex, taskContext } = deps;
     const projectPath = config._projectPath || process.cwd();
     // H1: LLM Gateway — Token 预算熔断，防止单任务 Token 超支
@@ -198,11 +741,13 @@ export async function registerTools(server, deps) {
     /** State precheck: validate task status before contract guard */
     const STATE_PRECHECKS = {
         sf_verify: ["executing", "retrying"],
+        sf_record_verification_execution: ["verifying", "executing"],
         sf_learn: ["verifying", "executing"],
         sf_expand: ["classifying", "expanding", "clarifying"],
     };
     const STATE_ERROR_LABELS = {
         sf_verify: "不可验证",
+        sf_record_verification_execution: "不可录入验证结果",
         sf_learn: "不可学习",
         sf_expand: "不可膨胀",
     };
@@ -326,6 +871,91 @@ export async function registerTools(server, deps) {
             // read_only_bypass 的旁路处理
             const bypass = effectiveCategory === "read_only_bypass"
                 ? { allowed: true, reason: "read_only" } : undefined;
+            // 计划前置门: 在合同验证之前检查 — 写工具必须有 plan_proposal_gate
+            const hasWriteEffect = hasWriteSideEffect(effectiveSideEffects);
+            if (hasWriteEffect && taskId) {
+                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 ?? "SF-PLAN-5001",
+                                    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: "SF-PLAN-5001",
+                                    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 ?? "SF-INSTR-5801",
+                                    recovery: instrViolation.recovery,
+                                }) }],
+                        isError: true,
+                    };
+                }
+            }
             // 合同验证
             const lastTrace = ctx?.last_tool_trace;
             // 为动态工具构建有效的合同覆盖（如 sf_status cancel）
@@ -445,7 +1075,7 @@ export async function registerTools(server, deps) {
     }
     // 加载认知锚点上下文 — 必须提供相关性参数，禁止全量加载
     async function loadRelevantAnchors(query) {
-        console.error("[soloForge] 工具注册: 加载认知锚点");
+        debug("工具注册", "加载认知锚点");
         return _loadRelevantAnchorsInner(query);
     }
     async function _loadRelevantAnchorsInner(query) {
@@ -499,7 +1129,7 @@ export async function registerTools(server, deps) {
             stale_anchor: a.stale_anchor,
         }));
     }
-    console.error("[soloForge] 工具注册: 批量注册核心/辅助/知识维护工具...");
+    debug("工具注册", "批量注册核心/辅助/知识维护工具...");
     // ── sf_classify: 意图分类入口，创建任务上下文并返回分类结果 ──
     registerSafeTool("sf_classify", "分析开发者意图，返回任务类型、风险、复杂度和执行策略", ClassifySchema, async (args) => {
         // 检查是否存在进行中的任务
@@ -617,6 +1247,101 @@ export async function registerTools(server, deps) {
             gateway.endTask();
         }
         expansion.task_id = args.task_id;
+        // 问题四十九/五十: 架构设计 Contract + 现有系统分析门 — 仅在有施工指令契约时强制执行
+        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: 独立于 hasInstructionContract，由 requires* 触发判定 ──
+        // 问题十六: 技术选型决策主权 gate — 高影响技术决策缺证据时 blocked
+        {
+            const decisionGate = await checkDecisionSovereigntyGate({ ctx, route: expansionRoute });
+            if (!decisionGate.allowed) {
+                return {
+                    result: {
+                        error: decisionGate.reason_zh,
+                        status: "blocked",
+                        recovery: decisionGate.requires_human_gate ? "请提供技术决策确认证据（human_gate_evidence）" : "技术选型决策校验失败，请提供 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,
+                        status: "blocked",
+                        recovery: "高影响任务缺 first_principles_frame，请提供后重新 sf_expand",
+                    },
+                };
+            }
+        }
+        // 问题四十一(brainstorm): 脑暴契约 gate — 不确定项缺方案探索时 blocked
+        {
+            const brainstormGate = await checkBrainstormGate({ ctx, route: expansionRoute });
+            if (!brainstormGate.allowed) {
+                return {
+                    result: {
+                        error: brainstormGate.reason_zh,
+                        violations: brainstormGate.violations,
+                        status: "blocked",
+                        recovery: "不确定项/方案选择缺 brainstorm_session，请提供后重新 sf_expand",
+                    },
+                };
+            }
+        }
         // Input Material Contract: 处理 hard-blocking 结果
         // Privacy Gate: 隐私/敏感信息策略阻断
         const isBlocked = expansion.prompt.startsWith("## 阻塞：输入材料禁止读取")
@@ -740,6 +1465,23 @@ export async function registerTools(server, deps) {
             : 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;
@@ -770,6 +1512,23 @@ export async function registerTools(server, deps) {
             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) {
@@ -814,13 +1573,75 @@ export async function registerTools(server, deps) {
             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;
+            : { ...verifyResult };
+        // 附加验证契约引用到返回结果
+        verifyPayload.verification_plan = vPlan;
+        verifyPayload.verification_result = vResult;
+        // 验证后核心体验评估
+        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 ?? ctx.batch2_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}" [SF-VERIFY-5002]`,
+                    diagnostic_code: "SF-VERIFY-5002",
+                },
+            };
+        }
+        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);
@@ -845,6 +1666,33 @@ export async function registerTools(server, deps) {
                     : "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");
@@ -945,7 +1793,7 @@ export async function registerTools(server, deps) {
             await taskContext.autoFailStale();
         }
         catch (e) {
-            console.error("[soloForge] autoFailStale 出错:", e);
+            internalWarn("autoFailStale", "出错:", e);
         }
         switch (action) {
             case "current": {
@@ -1243,6 +2091,128 @@ export async function registerTools(server, deps) {
                 }
             }
         }
+        // 交付 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 ?? ctx.batch2_verification_result;
+        const currentVPlan = ctx.verification_plan ?? ctx.batch2_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 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: !!config.tech_stack,
+                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 项目）",
+                    },
+                };
+            }
+        }
+        // 交付前检查 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 === "verified" || 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" ? "completed" : ctx.status,
+        });
+        if (cepNfcResult.decision === "blocked" || cepNfcResult.decision === "repair_reverify") {
+            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" : "repair_reverify",
+                        }],
+                    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,
@@ -1253,6 +2223,10 @@ export async function registerTools(server, deps) {
             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,
         };
@@ -1623,7 +2597,7 @@ export async function registerTools(server, deps) {
             configEntries = resolved.entries;
         }
         catch (e) {
-            console.error(`[soloForge] 配置报告解析失败: ${e instanceof Error ? e.message : String(e)}`);
+            internalWarn("配置报告", "解析失败:", e instanceof Error ? e.message : String(e));
         }
         // 同时包含近期任务上下文中的报告
         for (const t of recentTasks) {