soloforge 1.2.20 → 1.3.1

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"));
@@ -67,6 +69,17 @@ const lazyFailureReport = createLazy(() => import("../../engine/failure_report.j
 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"));
+const lazyArchitectureWorkshop = createLazy(() => import("../../engine/architecture_decision_workshop.js"));
+const lazyDesignArtifactPack = createLazy(() => import("../../engine/design_artifact_pack.js"));
 // ── Zod Schema 定义 ──
 const ClassifySchema = {
     intent: z.string().describe("开发者意图描述"),
@@ -76,6 +89,8 @@ 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.unknown().optional().describe("架构设计前已讨论并确认的六域决策记录"),
+    design_artifact_pack: z.unknown().optional().describe("设计产物包路径映射或已复验状态"),
 };
 const VerifySchema = {
     task_id: z.string().describe("任务 ID"),
@@ -188,13 +203,564 @@ 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 = 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"],
+        };
+    }
+    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 超支
@@ -349,6 +915,120 @@ 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,
+                    };
+                }
+            }
+            // 问题六十二: 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,
+                    };
+                }
+            }
             // 合同验证
             const lastTrace = ctx?.last_tool_trace;
             // 为动态工具构建有效的合同覆盖（如 sf_status cancel）
@@ -468,7 +1148,7 @@ export async function registerTools(server, deps) {
     }
     // 加载认知锚点上下文 — 必须提供相关性参数，禁止全量加载
     async function loadRelevantAnchors(query) {
-        console.error("[soloForge] 工具注册: 加载认知锚点");
+        debug("工具注册", "加载认知锚点");
         return _loadRelevantAnchorsInner(query);
     }
     async function _loadRelevantAnchorsInner(query) {
@@ -522,7 +1202,7 @@ export async function registerTools(server, deps) {
             stale_anchor: a.stale_anchor,
         }));
     }
-    console.error("[soloForge] 工具注册: 批量注册核心/辅助/知识维护工具...");
+    debug("工具注册", "批量注册核心/辅助/知识维护工具...");
     // ── sf_classify: 意图分类入口，创建任务上下文并返回分类结果 ──
     registerSafeTool("sf_classify", "分析开发者意图，返回任务类型、风险、复杂度和执行策略", ClassifySchema, async (args) => {
         // 检查是否存在进行中的任务
@@ -561,9 +1241,19 @@ export async function registerTools(server, deps) {
         if (!ctx || !ctx.classification) {
             return { result: { error: "任务不存在或尚未分类，请先调用 sf_classify" } };
         }
+        if (args.architecture_decision_workshop) {
+            ctx.architecture_decision_workshop = args.architecture_decision_workshop;
+        }
+        if (args.design_artifact_pack) {
+            ctx.design_artifact_pack = args.design_artifact_pack;
+        }
+        if (args.architecture_decision_workshop || args.design_artifact_pack) {
+            await taskContext.save(ctx);
+        }
         // 状态守卫：classifying/expanding/clarifying → expanding
         if (ctx.status === "classifying" || ctx.status === "clarifying") {
             await taskContext.updateStatus(args.task_id, "expanding");
+            ctx.status = "expanding";
         }
         else if (ctx.status !== "expanding") {
             return {
@@ -640,6 +1330,234 @@ export async function registerTools(server, deps) {
             gateway.endTask();
         }
         expansion.task_id = args.task_id;
+        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"
+                || /架构|architecture|系统设计|技术方案|现有系统|差距分析|gap.?analysis/i.test(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}`,
+                    });
+                }
+                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",
+                        },
+                    };
+                }
+            }
+        }
+        // 问题六十一: 架构设计前的六域研讨门独立执行，不得被施工指令契约有无绕过。
+        const existingSourceRoot = ["src", "backend", "frontend", "apps", "services"].some((candidate) => fss.existsSync(path.join(projectPath, candidate)));
+        const existingManifest = ["package.json", "pom.xml", "build.gradle", "settings.gradle"].some((candidate) => fss.existsSync(path.join(projectPath, candidate)));
+        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 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("## 阻塞：输入材料禁止读取")
@@ -659,7 +1577,124 @@ export async function registerTools(server, deps) {
             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}`,
+                });
+            }
+            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 _evIntentText = (ctx.intent ?? "").toLowerCase();
+            const _isArchitectureContext = _evWorkflowIntent === "architecture_design"
+                || _evWorkflowIntent === "existing_system_gap_analysis"
+                || _evRoute === "artifact_generation"
+                || /架构|architecture|系统设计|技术方案|现有系统|差距分析|gap.?analysis/i.test(_evIntentText);
+            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)
@@ -726,6 +1761,34 @@ export async function registerTools(server, deps) {
                 result: { error: "任务不存在" },
             };
         }
+        // 问题六十二: 设计产物验证必须读取用户项目真实文件，不接受占位合同自证通过。
+        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；不得只提交报告绕过缺口",
+                    },
+                };
+            }
+        }
         // RouteDecision 合同验证 — 无条件，在状态预检之前
         const rdFromCtx = ctx.route_decision ?? ctx.classification?.route_decision ?? null;
         const wtFromCtx = ctx.workflow_trace ?? ctx.expansion?.workflow_trace ?? null;
@@ -763,22 +1826,22 @@ 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;
-        // Batch2: 创建 VerificationPlan（plan_only，非执行结果）
+        // 创建 VerificationPlan（plan_only，非执行结果）
         const vcModule = await lazyVerificationContract();
         const allCommands = [
             ...(verifyResult.checks?.build ?? []),
             ...(verifyResult.checks?.tests ?? []),
         ].map((c) => c.command);
-        const batch2Plan = vcModule.createVerificationPlan(args.task_id, allCommands, acceptanceItems.map((a) => a.description));
-        // Batch2: sf_verify 仅生成计划，不执行命令 — 始终保存 not_executed
+        const vPlan = vcModule.createVerificationPlan(args.task_id, allCommands, acceptanceItems.map((a) => a.description));
+        // sf_verify 仅生成计划，不执行命令 — 始终保存 not_executed
         // 真实执行结果必须通过 recordVerificationExecution 单独录入
-        const batch2Result = vcModule.createNotExecutedResult(args.task_id, batch2Plan.plan_id, "sf_verify 生成命令，等待执行");
-        // 存储 Batch2 验证契约到任务上下文
-        const ctxForBatch2 = await taskContext.load(args.task_id);
-        if (ctxForBatch2) {
-            ctxForBatch2.batch2_verification_plan = batch2Plan;
-            ctxForBatch2.batch2_verification_result = batch2Result;
-            await taskContext.save(ctxForBatch2);
+        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;
@@ -810,7 +1873,7 @@ export async function registerTools(server, deps) {
             artifactVerificationResult = verifyArtifact(artifact.kind, artifact);
         }
         // 记录变更文件
-        // Batch2: 写入护栏 — 检查变更文件是否在允许范围
+        // 写入护栏 — 检查变更文件是否在允许范围
         if (args.changed_files.length > 0) {
             const guardModule = await lazyEnforcementGuard();
             const scopePaths = ctx.expansion?.scope?.allowed_paths ?? [];
@@ -819,7 +1882,7 @@ export async function registerTools(server, deps) {
                 if (writeFindings.some((f) => f.blocked)) {
                     return {
                         result: {
-                            error: `Batch2 写入护栏阻断: ${writeFindings[0].reason_zh}`,
+                            error: `写入护栏阻断: ${writeFindings[0].reason_zh}`,
                             blocked_file: cf,
                             guard_id: writeFindings[0].guard_id,
                         },
@@ -875,9 +1938,113 @@ export async function registerTools(server, deps) {
         const verifyPayload = Object.keys(verifyExtras).length > 0
             ? { ...verifyResult, ...verifyExtras }
             : { ...verifyResult };
-        // Batch2: 附加验证契约引用到返回结果
-        verifyPayload.batch2_verification_plan = batch2Plan;
-        verifyPayload.batch2_verification_result = batch2Result;
+        // 附加验证契约引用到返回结果
+        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,
         };
@@ -889,24 +2056,25 @@ export async function registerTools(server, deps) {
             return { result: { error: "任务不存在" } };
         }
         // 必须有 VerificationPlan
-        if (!ctx.batch2_verification_plan) {
+        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 !== ctx.batch2_verification_plan.plan_id) {
+        if (args.plan_id !== currentPlan.plan_id) {
             return {
                 result: {
-                    error: `plan_id 不匹配: 请求 "${args.plan_id}"，当前任务计划 "${ctx.batch2_verification_plan.plan_id}" [SF-VERIFY-5002]`,
+                    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, ctx.batch2_verification_plan);
+        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.batch2_verification_result = result;
+            ctxForSave.verification_result = result;
             await taskContext.save(ctxForSave);
         }
         return { result };
@@ -935,7 +2103,7 @@ export async function registerTools(server, deps) {
                     : "unknown failure",
                 timestamp: new Date().toISOString(),
             });
-            // Batch2: 创建 FailureReport（脱敏，非 raw error_output）
+            // 创建 FailureReport（脱敏，非 raw error_output）
             const frModule = await lazyFailureReport();
             const failureClass = args.failure_type;
             const errorOutput = args.verify_output
@@ -943,21 +2111,21 @@ export async function registerTools(server, deps) {
                 : "unknown failure";
             const retryCount = (ctx.execution?.attempt_count ?? 0) + 1;
             const policy = frModule.getRecoveryPolicy(failureClass);
-            const batch2FailureReport = frModule.createFailureReport(args.task_id, failureClass, errorOutput, retryCount, policy?.max_retries ?? 0);
+            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.batch2_failure_report = batch2FailureReport;
+                ctxForFailure.failure_report = failureReport;
                 await taskContext.save(ctxForFailure);
             }
-            // Batch2: verifier 不可用时创建 DegradationEvent
+            // 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.batch2_degradation_event = degradationEvent;
+                        ctxForDeg.degradation_event = degradationEvent;
                         await taskContext.save(ctxForDeg);
                     }
                 }
@@ -1062,7 +2230,7 @@ export async function registerTools(server, deps) {
             await taskContext.autoFailStale();
         }
         catch (e) {
-            console.error("[soloForge] autoFailStale 出错:", e);
+            internalWarn("autoFailStale", "出错:", e);
         }
         switch (action) {
             case "current": {
@@ -1360,7 +2528,18 @@ export async function registerTools(server, deps) {
                 }
             }
         }
-        // Batch2: 交付 lease 互斥检查
+        // 问题六十二: 依赖设计产物的任务只有 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: "请完成设计产物真实复验并修复所有阻断项后重新交付",
+                },
+            };
+        }
+        // 交付 lease 互斥检查
         const leaseModule = await lazyWorkspaceLease();
         const deliverLease = leaseModule.acquireLease(args.task_id, "delivery", [projectPath]);
         if (deliverLease.lease?.status === "conflicted" || deliverLease.conflicts.length > 0) {
@@ -1371,18 +2550,39 @@ export async function registerTools(server, deps) {
                 },
             };
         }
-        // Batch2: 交付就绪评估 — delivery_allowed=false 必须阻断交付
+        // 交付就绪评估 — delivery_allowed=false 必须阻断交付
         const drModule = await lazyDeliveryReadiness();
         const guardModule = await lazyEnforcementGuard();
-        const guardFindings = guardModule.evaluateDeliveryReadinessGuard(ctx.batch2_verification_result, ctx.batch2_verification_plan);
-        const readinessReport = drModule.evaluateDeliveryReadiness(args.task_id, ctx.batch2_verification_result, guardFindings, true, // scope_check — 已在 sf_verify 写入护栏中检查
+        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);
+        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.batch2_delivery_readiness = readinessReport;
+            ctxForReadiness.delivery_readiness = readinessReport;
             await taskContext.save(ctxForReadiness);
         }
         if (!readinessReport.delivery_allowed) {
@@ -1392,11 +2592,137 @@ export async function registerTools(server, deps) {
             }
             return {
                 result: {
-                    error: `Batch2 交付就绪检查未通过: ${readinessReport.blocking_findings.map((f) => f.message_zh).join("; ")}`,
+                    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 项目）",
+                    },
+                };
+            }
+        }
+        // 问题六十：交付结论必须经过 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 === "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,
@@ -1407,7 +2733,7 @@ export async function registerTools(server, deps) {
             skipPr: args.skip_pr,
         });
         await taskContext.setDelivery(args.task_id, result);
-        // Batch2: 交付完成后释放 lease
+        // 交付完成后释放 lease
         if (deliverLease.lease) {
             leaseModule.releaseLease(deliverLease.lease.lease_id);
         }
@@ -1781,7 +3107,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) {