soloforge 1.4.10 → 1.4.12

package/dist/engine/intent_expander.js

@@ -33,6 +33,7 @@ import { validateBrainstormSession } from "./brainstorm_contract.js";
 import { resolveTaskScope } from "./scope_resolver.js";
 import { evaluateLifecycleKnowledgeDecision } from "./lifecycle_knowledge_contract.js";
 import { extractTraceabilityIds } from "./traceability.js";
+import { createExpandRoutePhasePolicy } from "./expand_pipeline.js";
 // 配置优先级：委托给 resolveCurrentProjectConfigReports (shared function)
 // ── 产物类型映射 ──
 function mapToArtifactKind(kind) {
@@ -246,7 +247,42 @@ const READ_ONLY_ANALYSIS_TEMPLATE = Handlebars.compile(`## 任务
 - 标注风险和假设
 - 给出建议（如有）
 `);
-// 5. verification_only_prompt: 验证命令生成，不修改源码
+// 5. acceptance_prompt: 验收/就绪检查，不修改源码
+const ACCEPTANCE_TEMPLATE = Handlebars.compile(`## 任务
+{{intent}}
+
+## 工作流: 验收/就绪检查
+- 这是只读检查路径，不修改业务源码，不生成脚手架，不创建实现文件
+- 目标是判断列出的事项是否就绪、通过、满足条件或仍需处理
+- 只输出检查结论、证据、阻塞项和下一步建议
+
+## 项目上下文
+- 技术栈: {{tech_stack}}
+- 产品类型: {{product_profile}}
+
+{{#if matched_knowledge}}
+## 适用知识
+{{#each matched_knowledge}}
+### {{this.name}}
+{{this.content}}
+
+{{/each}}
+{{/if}}
+
+## 检查要求
+- 对每一项给出: passed / blocked / unknown
+- blocked 必须说明阻塞原因和可执行恢复动作
+- unknown 必须说明缺少哪些证据
+- 不要求技术决策契约、架构决策研讨、OOD/SOLID 摘要或代码可观测性工作包
+
+{{#if acceptance.automated}}
+## 验收项
+{{#each acceptance.automated}}
+- [{{this.id}}] {{this.description}}
+{{/each}}
+{{/if}}
+`);
+// 6. verification_only_prompt: 验证命令生成，不修改源码
 const VERIFICATION_ONLY_TEMPLATE = Handlebars.compile(`## 任务
 {{intent}}
 
@@ -506,6 +542,35 @@ function renderPromptInjectionPlan(plan) {
     }
     return sections.length > 0 ? "---\n\n" + sections.join("\n\n") : "";
 }
+function buildBlockedResult(prompt, safeGoal, options) {
+    return {
+        task_id: "",
+        prompt,
+        scope: { allowed_paths: [], readonly_paths: [], new_files_allowed: false },
+        acceptance: { automated: [], manual: [] },
+        matched_patterns: [],
+        matched_knowledge: [],
+        is_legacy_code: false,
+        degraded: true,
+        ...(options.sensitivityLabels?.length ? { sensitivity_labels: options.sensitivityLabels } : {}),
+        ...(options.redactionRecords?.length ? { redaction_records: options.redactionRecords } : {}),
+        ...(options.privacyFindings?.length ? { privacy_findings: options.privacyFindings } : {}),
+        ...(options.inputMaterials ? { input_materials: options.inputMaterials } : {}),
+        ...(options.ingestionEvidences ? { ingestion_evidences: options.ingestionEvidences } : {}),
+        ...(options.promptInjectionPlan ? { prompt_injection_plan: options.promptInjectionPlan } : {}),
+        ...(options.outputArtifactRecord ? { output_artifact_record: options.outputArtifactRecord } : {}),
+        ...(options.injectionReport ? { injection_report: options.injectionReport } : {}),
+        ...(options.projectKnowledge ? { project_knowledge: options.projectKnowledge } : {}),
+        ...(options.workflowTrace ? { workflow_trace: options.workflowTrace } : {}),
+        contract: {
+            goal: safeGoal,
+            scope: [],
+            constraints: options.constraints,
+            verification: [],
+            stop_conditions: options.stopConditions,
+        },
+    };
+}
 /**
  * 根据执行形态选择 prompt 模板。
  * 模板使用独立工作流专属模板，包含对应约束注入。
@@ -515,6 +580,7 @@ function chooseTemplate(templateName) {
         case "single_artifact_prompt": return SINGLE_ARTIFACT_TEMPLATE;
         case "source_extraction_prompt": return SOURCE_EXTRACTION_TEMPLATE;
         case "read_only_analysis_prompt": return READ_ONLY_ANALYSIS_TEMPLATE;
+        case "acceptance_prompt": return ACCEPTANCE_TEMPLATE;
         case "verification_only_prompt": return VERIFICATION_ONLY_TEMPLATE;
         case "direct_answer_prompt": return DIRECT_ANSWER_TEMPLATE;
         case "architecture_design_prompt": return ARCHITECTURE_DESIGN_TEMPLATE;
@@ -593,6 +659,12 @@ export async function expand(input) {
     const { intent, classification, projectPath, config, knowledgeIndex } = input;
     let routeDecision = input.route_decision ?? classification.route_decision;
     const templateName = routeDecision ? selectPromptTemplate(routeDecision) : "code_execution_prompt";
+    const phasePolicy = createExpandRoutePhasePolicy(routeDecision);
+    const skipWorkflowContractStrict = phasePolicy.skip_workflow_contract_strict;
+    const skipInputMaterialHardBlock = phasePolicy.skip_input_material_hard_block;
+    const skipProjectKnowledgeHardBlock = phasePolicy.skip_project_knowledge_hard_block;
+    const skipHeavyContractGates = phasePolicy.skip_heavy_contract_gates;
+    const skipPreImplementationGates = phasePolicy.skip_pre_implementation_gates;
     // 配置优先级解析 — 使用共享函数
     let configResolution;
     try {
@@ -608,36 +680,30 @@ export async function expand(input) {
         routeDecision = resolveClarificationAnswers(routeDecision, intent, input.clarificationAnswers);
     }
     // ── Privacy gate— 提前到所有 early-return 之前 ──
-    const privacyGate = evaluatePrivacyGate({
-        intent,
-        input_materials: input.route_decision?.input_materials?.map((m) => ({ path_or_ref: m.path ?? "" })) ?? [],
-    });
-    const safeIntent = privacyGate.redacted_text ?? redactSensitiveText(intent, "intent").redacted;
-    const safeGoal = redactSensitiveText(intent.slice(0, 200), "intent_goal").redacted;
+    // 轻量路径（acceptance/review/read_only）只做基础脱敏，跳过深度隐私扫描
+    let safeIntent;
+    let safeGoal;
+    let privacyGate;
+    if (phasePolicy.lightweight) {
+        safeIntent = redactSensitiveText(intent, "intent").redacted;
+        safeGoal = redactSensitiveText(intent.slice(0, 200), "intent_goal").redacted;
+        privacyGate = { allowed: true, labels: [], redaction_records: [], findings: [], blocked_sources: [], hard_fail: false };
+    }
+    else {
+        privacyGate = evaluatePrivacyGate({
+            intent,
+            input_materials: input.route_decision?.input_materials?.map((m) => ({ path_or_ref: m.path ?? "" })) ?? [],
+        });
+        safeIntent = privacyGate.redacted_text ?? redactSensitiveText(intent, "intent").redacted;
+        safeGoal = redactSensitiveText(intent.slice(0, 200), "intent_goal").redacted;
+    }
     // 提前创建产物记录 (在所有 early-return 之前)，确保所有路径都携带它
     // task_id 为必需 — block if missing
     let outputArtifactRecord;
     if (routeDecision?.output_artifact && routeDecision.execution_shape !== "none" && routeDecision.execution_shape !== "code_execution") {
         const artifactKind = mapToArtifactKind(routeDecision.output_artifact.kind);
         if (!input.task_id) {
-            // task_id 缺失时始终阻止 for artifact routes
-            return {
-                task_id: "",
-                prompt: `## 阻塞：产物缺少 task_id\n\n任务: ${safeIntent}\n\nexpand() 收到 task_id 为空，无法创建产物记录。`,
-                scope: { allowed_paths: [], readonly_paths: [], new_files_allowed: false },
-                acceptance: { automated: [], manual: [] },
-                matched_patterns: [],
-                matched_knowledge: [],
-                is_legacy_code: false,
-                degraded: true,
-                contract: {
-                    goal: safeGoal,
-                    scope: [],
-                    constraints: ["task_id 缺失"],
-                    verification: [],
-                    stop_conditions: ["task_id 缺失"],
-                },
-            };
+            return buildBlockedResult(`## 阻塞：产物缺少 task_id\n\n任务: ${safeIntent}\n\nexpand() 收到 task_id 为空，无法创建产物记录。`, safeGoal, { constraints: ["task_id 缺失"], stopConditions: ["task_id 缺失"] });
         }
         // 收集源材料引用 from routeDecision.input_materials
         const sourceMaterialRefs = routeDecision.input_materials
@@ -645,15 +711,7 @@ export async function expand(input) {
             .map((m) => m.path);
         // 冲突时拒绝 with input.task_id
         if (routeDecision.output_artifact.taskId && routeDecision.output_artifact.taskId !== input.task_id) {
-            return {
-                task_id: input.task_id,
-                prompt: `## Contract Error: task_id 不一致\n\nrouteDecision.taskId=${routeDecision.output_artifact.taskId} !== input.task_id=${input.task_id}`,
-                scope: { allowed_paths: [], readonly_paths: [], new_files_allowed: false },
-                acceptance: { automated: [], manual: [] },
-                matched_patterns: [], matched_knowledge: [],
-                is_legacy_code: false, degraded: true,
-                contract: { goal: safeGoal, scope: [], constraints: ["task_id 不一致"], verification: [], stop_conditions: ["task_id 不一致"] },
-            };
+            return buildBlockedResult(`## Contract Error: task_id 不一致\n\nrouteDecision.taskId=${routeDecision.output_artifact.taskId} !== input.task_id=${input.task_id}`, safeGoal, { constraints: ["task_id 不一致"], stopConditions: ["task_id 不一致"] });
         }
         // 路径始终使用 input.task_id
         outputArtifactRecord = createOutputArtifact({
@@ -688,95 +746,44 @@ export async function expand(input) {
         });
         recordCepIntegration("workflow_resolve", cepWfResult);
         if (!workflowContract) {
-            return {
-                task_id: "",
-                prompt: `## 阻塞：无工作流契约\n\n任务: ${safeIntent}\n\nroute="${routeDecision.route}" + execution_shape="${routeDecision.execution_shape}" 没有匹配的工作流契约。\n\n请检查意图路由配置。`,
-                scope: { allowed_paths: [], readonly_paths: [], new_files_allowed: false },
-                acceptance: { automated: [], manual: [] },
-                matched_patterns: [],
-                matched_knowledge: [],
-                is_legacy_code: false,
-                degraded: true,
-                workflow_trace: {
-                    workflow_id: "none",
-                    route: routeDecision.route,
-                    execution_shape: routeDecision.execution_shape,
-                    mutation_allowed: routeDecision.mutation_allowed,
+            return buildBlockedResult(`## 阻塞：无工作流契约\n\n任务: ${safeIntent}\n\nroute="${routeDecision.route}" + execution_shape="${routeDecision.execution_shape}" 没有匹配的工作流契约。\n\n请检查意图路由配置。`, safeGoal, {
+                constraints: ["无匹配工作流契约"], stopConditions: ["修复意图路由配置"],
+                outputArtifactRecord: outputArtifactRecord,
+                workflowTrace: {
+                    workflow_id: "none", route: routeDecision.route,
+                    execution_shape: routeDecision.execution_shape, mutation_allowed: routeDecision.mutation_allowed,
                     required_mechanisms: [],
                     governance_findings: [{ severity: "hard_fail", rule: "gc-no-workflow", message: `no workflow contract for ${routeDecision.route}+${routeDecision.execution_shape}` }],
-                    degraded: true,
-                    state_transition_target: "none",
-                },
-                contract: {
-                    goal: safeGoal,
-                    scope: [],
-                    constraints: ["无工作流契约"],
-                    verification: [],
-                    stop_conditions: ["无工作流契约"],
+                    degraded: true, state_transition_target: "none",
                 },
-                output_artifact_record: outputArtifactRecord,
-            };
+            });
         }
-        // mutation_allowed 一致性检查
-        if (workflowContract.mutation_allowed !== routeDecision.mutation_allowed) {
-            return {
-                task_id: "",
-                prompt: `## 阻塞：mutation_allowed 不一致\n\n任务: ${safeIntent}\n\n工作流 "${workflowContract.id}" 的 mutation_allowed=${workflowContract.mutation_allowed} 与 route_decision 的 mutation_allowed=${routeDecision.mutation_allowed} 不一致。`,
-                scope: { allowed_paths: [], readonly_paths: [], new_files_allowed: false },
-                acceptance: { automated: [], manual: [] },
-                matched_patterns: [],
-                matched_knowledge: [],
-                is_legacy_code: false,
-                degraded: true,
-                workflow_trace: {
-                    workflow_id: workflowContract.id,
-                    route: routeDecision.route,
-                    execution_shape: routeDecision.execution_shape,
-                    mutation_allowed: workflowContract.mutation_allowed,
+        // mutation_allowed 一致性检查（轻量路径跳过）
+        if (!skipWorkflowContractStrict && workflowContract.mutation_allowed !== routeDecision.mutation_allowed) {
+            return buildBlockedResult(`## 阻塞：mutation_allowed 不一致\n\n任务: ${safeIntent}\n\n工作流 "${workflowContract.id}" 的 mutation_allowed=${workflowContract.mutation_allowed} 与 route_decision 的 mutation_allowed=${routeDecision.mutation_allowed} 不一致。`, safeGoal, {
+                constraints: ["mutation_allowed 不一致"], stopConditions: ["mutation_allowed 不一致"],
+                outputArtifactRecord: outputArtifactRecord,
+                workflowTrace: {
+                    workflow_id: workflowContract.id, route: routeDecision.route,
+                    execution_shape: routeDecision.execution_shape, mutation_allowed: workflowContract.mutation_allowed,
                     required_mechanisms: workflowContract.required_mechanisms,
                     governance_findings: [{ severity: "hard_fail", rule: "gc-mutation-mismatch", message: `mutation_allowed mismatch: workflow=${workflowContract.mutation_allowed} route=${routeDecision.mutation_allowed}` }],
-                    degraded: true,
-                    state_transition_target: "none",
+                    degraded: true, state_transition_target: "none",
                 },
-                contract: {
-                    goal: safeGoal,
-                    scope: [],
-                    constraints: ["mutation_allowed 不一致"],
-                    verification: [],
-                    stop_conditions: ["mutation_allowed 不一致"],
-                },
-                output_artifact_record: outputArtifactRecord,
-            };
+            });
         }
-        // prompt_template 一致性检查
-        if (workflowContract.prompt_template !== templateName) {
-            return {
-                task_id: "",
-                prompt: `## 阻塞：prompt_template 不一致\n\n任务: ${safeIntent}\n\n工作流 "${workflowContract.id}" 要求 prompt_template="${workflowContract.prompt_template}"，但 selectPromptTemplate 返回 "${templateName}"。`,
-                scope: { allowed_paths: [], readonly_paths: [], new_files_allowed: false },
-                acceptance: { automated: [], manual: [] },
-                matched_patterns: [],
-                matched_knowledge: [],
-                is_legacy_code: false,
-                degraded: true,
-                workflow_trace: {
-                    workflow_id: workflowContract.id,
-                    route: routeDecision.route,
-                    execution_shape: routeDecision.execution_shape,
-                    mutation_allowed: workflowContract.mutation_allowed,
+        // prompt_template 一致性检查（轻量路径跳过）
+        if (!skipWorkflowContractStrict && workflowContract.prompt_template !== templateName) {
+            return buildBlockedResult(`## 阻塞：prompt_template 不一致\n\n任务: ${safeIntent}\n\n工作流 "${workflowContract.id}" 要求 prompt_template="${workflowContract.prompt_template}"，但 selectPromptTemplate 返回 "${templateName}"。`, safeGoal, {
+                constraints: ["prompt_template 不一致"], stopConditions: ["prompt_template 不一致"],
+                workflowTrace: {
+                    workflow_id: workflowContract.id, route: routeDecision.route,
+                    execution_shape: routeDecision.execution_shape, mutation_allowed: workflowContract.mutation_allowed,
                     required_mechanisms: workflowContract.required_mechanisms,
                     governance_findings: [{ severity: "hard_fail", rule: "gc-prompt-template-mismatch", message: `prompt_template mismatch: workflow="${workflowContract.prompt_template}" selected="${templateName}"` }],
-                    degraded: true,
-                    state_transition_target: "none",
-                },
-                contract: {
-                    goal: safeGoal,
-                    scope: [],
-                    constraints: ["prompt_template 不一致"],
-                    verification: [],
-                    stop_conditions: ["prompt_template 不一致"],
+                    degraded: true, state_transition_target: "none",
                 },
-            };
+            });
         }
     }
     // 缺少必需输入时返回澄清，不生成执行 prompt（在 workflow resolution 之后）
@@ -809,40 +816,21 @@ export async function expand(input) {
     // ── 输入材料硬阻断──
     if (inputMaterials) {
         const forbiddenMaterials = inputMaterials.filter((m) => m.access_mode === "forbidden");
-        if (forbiddenMaterials.length > 0) {
+        if (!skipInputMaterialHardBlock && forbiddenMaterials.length > 0) {
             const forbiddenPaths = forbiddenMaterials.map((m) => m.path_or_ref).join(", ");
             debugLog("意图膨胀: 输入材料禁止读取: %s", forbiddenPaths);
-            return {
-                task_id: "",
-                prompt: `## 阻塞：输入材料禁止读取\n\n任务: ${safeIntent}\n\n以下材料路径触发禁止规则，不得读取:\n${forbiddenMaterials.map((m) => "  - " + m.path_or_ref).join("\\n")}\n\n请移除这些材料后重新调用。`,
-                scope: { allowed_paths: [], readonly_paths: [], new_files_allowed: false },
-                acceptance: { automated: [], manual: [] },
-                matched_patterns: [],
-                matched_knowledge: [],
-                is_legacy_code: false,
-                degraded: true,
-                input_materials: inputMaterials,
-                ingestion_evidences: ingestionEvidences,
-                prompt_injection_plan: promptInjectionPlan,
-                contract: {
-                    goal: safeGoal,
-                    scope: [],
-                    constraints: ["输入材料包含禁止路径"],
-                    verification: [],
-                    stop_conditions: [],
-                },
-                output_artifact_record: outputArtifactRecord,
-                workflow_trace: workflowContract ? {
-                    workflow_id: workflowContract.id,
-                    route: routeDecision.route,
-                    execution_shape: routeDecision.execution_shape,
-                    mutation_allowed: workflowContract.mutation_allowed,
+            return buildBlockedResult(`## 阻塞：输入材料禁止读取\n\n任务: ${safeIntent}\n\n以下材料路径触发禁止规则，不得读取:\n${forbiddenMaterials.map((m) => "  - " + m.path_or_ref).join("\\n")}\n\n请移除这些材料后重新调用。`, safeGoal, {
+                constraints: ["输入材料包含禁止路径"], stopConditions: [],
+                inputMaterials: inputMaterials, ingestionEvidences: ingestionEvidences,
+                promptInjectionPlan: promptInjectionPlan, outputArtifactRecord: outputArtifactRecord,
+                workflowTrace: workflowContract ? {
+                    workflow_id: workflowContract.id, route: routeDecision.route,
+                    execution_shape: routeDecision.execution_shape, mutation_allowed: workflowContract.mutation_allowed,
                     required_mechanisms: workflowContract.required_mechanisms,
                     governance_findings: [{ severity: "hard_fail", rule: "gc-forbidden-material", message: `材料禁止读取: ${forbiddenPaths}` }],
-                    degraded: true,
-                    state_transition_target: "none",
+                    degraded: true, state_transition_target: "none",
                 } : undefined,
-            };
+            });
         }
         const confirmations = input.input_material_confirmations ?? [];
         const requiresConfirmationMaterials = inputMaterials.filter((m) => m.access_mode !== "forbidden"
@@ -850,37 +838,17 @@ export async function expand(input) {
             && !confirmations.includes(m.path_or_ref));
         if (requiresConfirmationMaterials.length > 0) {
             const confirmPaths = requiresConfirmationMaterials.map((m) => m.path_or_ref);
-            return {
-                task_id: "",
-                prompt: `## 澄清请求\n\n任务: ${safeIntent}\n\n以下输入材料需要人工确认后才能使用:\n${confirmPaths.map((p) => "  - " + p).join("\\n")}\n\n请确认以上材料安全性后，通过 input_material_confirmations 参数重新调用。`,
-                scope: { allowed_paths: [], readonly_paths: [], new_files_allowed: false },
-                acceptance: { automated: [], manual: [] },
-                matched_patterns: [],
-                matched_knowledge: [],
-                is_legacy_code: false,
-                degraded: true,
-                input_materials: inputMaterials,
-                ingestion_evidences: ingestionEvidences,
-                prompt_injection_plan: promptInjectionPlan,
-                contract: {
-                    goal: safeGoal,
-                    scope: [],
-                    constraints: ["输入材料需要确认"],
-                    verification: [],
-                    stop_conditions: [],
-                },
-                output_artifact_record: outputArtifactRecord,
-                workflow_trace: workflowContract ? {
-                    workflow_id: workflowContract.id,
-                    route: routeDecision.route,
-                    execution_shape: routeDecision.execution_shape,
-                    mutation_allowed: workflowContract.mutation_allowed,
+            return buildBlockedResult(`## 澄清请求\n\n任务: ${safeIntent}\n\n以下输入材料需要人工确认后才能使用:\n${confirmPaths.map((p) => "  - " + p).join("\\n")}\n\n请确认以上材料安全性后，通过 input_material_confirmations 参数重新调用。`, safeGoal, {
+                constraints: ["输入材料需要确认"], stopConditions: [],
+                inputMaterials: inputMaterials, ingestionEvidences: ingestionEvidences,
+                promptInjectionPlan: promptInjectionPlan, outputArtifactRecord: outputArtifactRecord,
+                workflowTrace: workflowContract ? {
+                    workflow_id: workflowContract.id, route: routeDecision.route,
+                    execution_shape: routeDecision.execution_shape, mutation_allowed: workflowContract.mutation_allowed,
                     required_mechanisms: workflowContract.required_mechanisms,
-                    governance_findings: [],
-                    degraded: true,
-                    state_transition_target: "clarifying",
+                    governance_findings: [], degraded: true, state_transition_target: "clarifying",
                 } : undefined,
-            };
+            });
         }
     }
     // ── 隐私硬阻断门禁 (privacyGate 已在顶部计算) ──
@@ -890,52 +858,31 @@ export async function expand(input) {
     // 硬阻断: 意图或输入材料中包含密钥/凭证
     if (privacyGate.hard_fail) {
         debugLog("意图膨胀: 隐私策略阻断，包含 %d 个禁止来源", privacyGate.blocked_sources.length);
-        return {
-            task_id: "",
-            prompt: [
-                "## 阻塞：隐私/敏感信息策略",
-                "",
-                "任务内容已因隐私策略脱敏",
-                "",
-                "隐私门禁触发 hard_fail，以下来源包含禁止级别的敏感信息:",
-                ...privacyGate.blocked_sources.map((s) => "  - " + s),
-                "",
-                "治理发现:",
-                ...privacyGate.findings.map((f) => `  [${f.severity}] ${f.rule}: ${f.message}`),
-                "",
-                "请移除敏感信息后重新调用。",
-            ].join("\n"),
-            scope: { allowed_paths: [], readonly_paths: [], new_files_allowed: false },
-            acceptance: { automated: [], manual: [] },
-            matched_patterns: [],
-            matched_knowledge: [],
-            is_legacy_code: false,
-            degraded: true,
-            sensitivity_labels: privacyLabels.length > 0 ? privacyLabels : undefined,
-            redaction_records: privacyRedactions.length > 0 ? privacyRedactions : undefined,
-            privacy_findings: privacyFindings.length > 0 ? privacyFindings : undefined,
-            contract: {
-                goal: safeGoal,
-                scope: [],
-                constraints: ["隐私/敏感信息策略阻断"],
-                verification: [],
-                stop_conditions: ["隐私/敏感信息策略阻断"],
-            },
-            input_materials: inputMaterials,
-            ingestion_evidences: ingestionEvidences,
-            prompt_injection_plan: promptInjectionPlan,
-            output_artifact_record: outputArtifactRecord,
-            workflow_trace: workflowContract ? {
-                workflow_id: workflowContract.id,
-                route: routeDecision.route,
-                execution_shape: routeDecision.execution_shape,
-                mutation_allowed: workflowContract.mutation_allowed,
+        return buildBlockedResult([
+            "## 阻塞：隐私/敏感信息策略",
+            "",
+            "任务内容已因隐私策略脱敏",
+            "",
+            "隐私门禁触发 hard_fail，以下来源包含禁止级别的敏感信息:",
+            ...privacyGate.blocked_sources.map((s) => "  - " + s),
+            "",
+            "治理发现:",
+            ...privacyGate.findings.map((f) => `  [${f.severity}] ${f.rule}: ${f.message}`),
+            "",
+            "请移除敏感信息后重新调用。",
+        ].join("\n"), safeGoal, {
+            constraints: ["隐私/敏感信息策略阻断"], stopConditions: ["隐私/敏感信息策略阻断"],
+            sensitivityLabels: privacyLabels, redactionRecords: privacyRedactions, privacyFindings: privacyFindings,
+            inputMaterials: inputMaterials, ingestionEvidences: ingestionEvidences,
+            promptInjectionPlan: promptInjectionPlan, outputArtifactRecord: outputArtifactRecord,
+            workflowTrace: workflowContract ? {
+                workflow_id: workflowContract.id, route: routeDecision.route,
+                execution_shape: routeDecision.execution_shape, mutation_allowed: workflowContract.mutation_allowed,
                 required_mechanisms: workflowContract.required_mechanisms,
                 governance_findings: privacyFindings.map((f) => ({ severity: f.severity, rule: f.rule, message: f.message })),
-                degraded: true,
-                state_transition_target: "none",
+                degraded: true, state_transition_target: "none",
             } : undefined,
-        };
+        });
     }
     // 1. 查询知识库（路由驱动匹配）
     const affectedRepos = getAffectedRepos(classification);
@@ -971,57 +918,42 @@ export async function expand(input) {
         severity: finding.severity,
         message_zh: finding.message_zh,
     })));
-    if (projectKnowledgeReport.hard_fail_count > 0) {
+    if (!skipProjectKnowledgeHardBlock && projectKnowledgeReport.hard_fail_count > 0) {
         const lines = projectKnowledgeFindings
             .filter((finding) => finding.severity === "hard_fail")
             .map((finding) => `- [${finding.code}] ${finding.rel_path}: ${finding.message_zh}`);
-        return {
-            task_id: "",
-            prompt: [
-                "## 阻塞：用户项目知识规则不可消费",
-                "",
-                `任务: ${safeIntent}`,
-                "",
-                "项目 .soloforge/knowledge 中存在 hard rule 身份、路由或触发条件问题。",
-                "这些规则如果继续放行，会让 AI 在真实任务中无法稳定知道该遵守哪些项目规则。",
-                "",
-                ...lines,
-                "",
-                "请修复以上项目规则后重新调用。",
-            ].join("\n"),
-            scope: { allowed_paths: [], readonly_paths: [], new_files_allowed: false },
-            acceptance: { automated: [], manual: [] },
-            matched_patterns: [],
-            matched_knowledge: [],
-            is_legacy_code: false,
-            degraded: true,
-            contract: {
-                goal: safeGoal,
-                scope: [],
-                constraints: ["用户项目知识规则不可消费"],
-                verification: ["soloforge audit-project-knowledge"],
-                stop_conditions: ["修复 .soloforge/knowledge hard rule 路由或身份冲突"],
-            },
-            project_knowledge: {
+        return buildBlockedResult([
+            "## 阻塞：用户项目知识规则不可消费",
+            "",
+            `任务: ${safeIntent}`,
+            "",
+            "项目 .soloforge/knowledge 中存在 hard rule 身份、路由或触发条件问题。",
+            "这些规则如果继续放行，会让 AI 在真实任务中无法稳定知道该遵守哪些项目规则。",
+            "",
+            ...lines,
+            "",
+            "请修复以上项目规则后重新调用。",
+        ].join("\n"), safeGoal, {
+            constraints: ["用户项目知识规则不可消费"],
+            stopConditions: ["修复 .soloforge/knowledge hard rule 路由或身份冲突"],
+            projectKnowledge: {
                 total: projectKnowledgeReport.total,
                 hard_fail_count: projectKnowledgeReport.hard_fail_count,
                 warning_count: projectKnowledgeReport.warning_count,
                 selected: [],
                 findings: projectKnowledgeFindings,
             },
-            workflow_trace: workflowContract ? {
-                workflow_id: workflowContract.id,
-                route: routeDecision?.route ?? "",
+            workflowTrace: workflowContract ? {
+                workflow_id: workflowContract.id, route: routeDecision?.route ?? "",
                 execution_shape: routeDecision?.execution_shape ?? "",
                 mutation_allowed: workflowContract.mutation_allowed,
                 required_mechanisms: workflowContract.required_mechanisms,
                 governance_findings: projectKnowledgeFindings
                     .filter((finding) => finding.severity === "hard_fail")
                     .map((finding) => ({ severity: "hard_fail", rule: finding.code, message: `${finding.rel_path}: ${finding.message_zh}` })),
-                degraded: true,
-                state_transition_target: "manual_required",
+                degraded: true, state_transition_target: "manual_required",
             } : undefined,
-        };
+        });
     }
     const projectKnowledgeSelection = lifecycleKnowledgeDecision.knowledge_selection;
     const selectedProjectKnowledge = projectKnowledgeSelection.selected.map((decision) => decision.asset);
@@ -1092,38 +1024,20 @@ export async function expand(input) {
             ? injectionReport.missing_required_knowledge.map((m) => m.reason).join("\n")
             : "";
         const missingSection = missingDesc ? `\n\n缺少的必需知识:\n${missingDesc}` : "";
-        return {
-            task_id: "",
-            prompt: `## 阻塞：注入校验失败\n\n任务: ${safeIntent}\n\n以下硬性校验未通过:\n${failMessages}${missingSection}\n\n请修正后重新调用。`,
-            scope: { allowed_paths: [], readonly_paths: [], new_files_allowed: false },
-            acceptance: { automated: [], manual: [] },
-            matched_patterns: [],
-            matched_knowledge: [],
-            is_legacy_code: false,
-            degraded: true,
-            injection_report: injectionReport,
-            input_materials: inputMaterials,
-            ingestion_evidences: ingestionEvidences,
-            prompt_injection_plan: promptInjectionPlan,
-            contract: {
-                goal: safeGoal,
-                scope: [],
-                constraints: ["注入校验失败，等待修正"],
-                verification: [],
-                stop_conditions: ["注入校验失败"],
-            },
-            output_artifact_record: outputArtifactRecord,
-            workflow_trace: workflowContract ? {
-                workflow_id: workflowContract.id,
-                route: routeDecision?.route ?? "",
+        return buildBlockedResult(`## 阻塞：注入校验失败\n\n任务: ${safeIntent}\n\n以下硬性校验未通过:\n${failMessages}${missingSection}\n\n请修正后重新调用。`, safeGoal, {
+            constraints: ["注入校验失败，等待修正"], stopConditions: ["注入校验失败"],
+            injectionReport: injectionReport,
+            inputMaterials: inputMaterials, ingestionEvidences: ingestionEvidences,
+            promptInjectionPlan: promptInjectionPlan, outputArtifactRecord: outputArtifactRecord,
+            workflowTrace: workflowContract ? {
+                workflow_id: workflowContract.id, route: routeDecision?.route ?? "",
                 execution_shape: routeDecision?.execution_shape ?? "",
                 mutation_allowed: workflowContract.mutation_allowed,
                 required_mechanisms: workflowContract.required_mechanisms,
                 governance_findings: workflowGovernanceFindings,
-                degraded: true,
-                state_transition_target: "none",
+                degraded: true, state_transition_target: "none",
             } : undefined,
-        };
+        });
     }
     // 2. 检测遗留惯例（只对 code_execution 执行）
     const legacyConventions = [];
@@ -1205,8 +1119,8 @@ export async function expand(input) {
     const uncertaintyTriggers = skipHeavyAnalysis
         ? []
         : buildUncertaintyTriggers(classification, intent);
-    // 机制 1: 意图熔断器检查
-    const breakerResult = checkCircuitBreaker({
+    // 机制 1: 意图熔断器检查（轻量路径跳过）
+    const breakerResult = skipPreImplementationGates ? { tripped: false, confidence: 1.0 } : checkCircuitBreaker({
         intent,
         classification,
         matchedEntries: filteredEntries,
@@ -1238,10 +1152,10 @@ ${breakerResult.brainstorm.decision_questions.map((q, i) => `${i + 1}. ${q.quest
             : "请先补齐阻塞输入，或在产物中标记 [Manual Confirm] 后再生成产物。"}
 `;
     }
-    // problem-16: 技术决策验证 — 膨胀涉及架构决策时校验 human gate
+    // problem-16: 技术决策验证 — 仅施工路径 + 高复杂度时校验 human gate
     let technologyDecisionEvidence;
     let techDecisionRequiresManual = false;
-    if (routeDecision?.execution_shape === "code_execution" && classification.complexity === "high") {
+    if (!skipHeavyContractGates && routeDecision?.execution_shape === "code_execution" && classification.complexity === "high") {
         const decisionContract = {
             decision_id: `td-${input.task_id ?? "unknown"}`,
             decision_scope: "architecture",
@@ -1280,34 +1194,62 @@ ${breakerResult.brainstorm.decision_questions.map((q, i) => `${i + 1}. ${q.quest
             });
         }
     }
-    // problem-41: 脑暴完整性校验 — 熔断触发时验证候选方案
+    // problem-41: 脑暴完整性校验 — 仅施工路径校验
+    // 优先使用用户提供的 brainstorm_session，否则从 circuit breaker 自动生成
     let brainstormEvidence;
     let brainstormRequiresClarification = false;
-    if (circuitBreakerOutput?.brainstorm) {
-        const session = {
-            session_id: `bs-${input.task_id ?? "unknown"}`,
-            trigger: "ambiguous_goal",
-            problem_statement: input.intent,
-            options: circuitBreakerOutput.brainstorm.decision_questions.map((q, i) => ({
-                option_id: `opt-${i}`,
-                title: q.question,
-                description: `${q.option_a} vs ${q.option_b}`,
-                pros: [q.option_a],
-                cons: [q.option_b],
-                applicable_when: [],
-                not_applicable_when: [],
-                failure_conditions: [],
-                verification_method: [],
-                estimated_risk: "medium",
-                reversibility: "partially_reversible",
-                required_human_decisions: [],
-            })),
-            recommended_option_id: "opt-0",
-            rejected_option_ids: [],
-            human_gate_required: true,
-            evidence_refs: [],
-            brainstorm_status: "options_ready",
-        };
+    if (!skipHeavyContractGates && (input.brainstorm_session || circuitBreakerOutput?.brainstorm)) {
+        // 优先使用用户提供的 brainstorm_session
+        let session;
+        if (input.brainstorm_session) {
+            session = input.brainstorm_session;
+        }
+        else {
+            const bs = circuitBreakerOutput?.brainstorm;
+            if (!bs) {
+                // 仅在 circuitBreakerOutput?.brainstorm 存在时进入此分支，但 TS 无法推断
+                // 安全跳过：如果 brainstorm 不存在则跳过整个校验
+                return {
+                    task_id: "",
+                    prompt: `## 脑暴数据缺失\n\n任务: ${safeIntent}\n\n内部脑暴数据不可用，跳过脑暴校验。`,
+                    scope: { allowed_paths: [], readonly_paths: [], new_files_allowed: false },
+                    acceptance: { automated: [], manual: [] },
+                    matched_patterns: [],
+                    matched_knowledge: [],
+                    is_legacy_code: false,
+                    degraded: true,
+                    contract: { goal: safeGoal, scope: [], constraints: ["脑暴数据缺失"], verification: [], stop_conditions: [] },
+                };
+            }
+            session = {
+                session_id: `bs-${input.task_id ?? "unknown"}`,
+                trigger: "ambiguous_goal",
+                problem_statement: input.intent,
+                options: bs.decision_questions.map((q, i) => ({
+                    option_id: `opt-${i}`,
+                    title: q.question,
+                    description: `${q.option_a} vs ${q.option_b}`,
+                    pros: [q.option_a],
+                    cons: [q.option_b],
+                    applicable_when: [],
+                    not_applicable_when: [],
+                    // 从 decision question 自动填充失败条件
+                    failure_conditions: [
+                        `选择 ${q.option_a} 失败的条件: ${q.option_a} 的局限性场景`,
+                        `选择 ${q.option_b} 失败的条件: ${q.option_b} 的局限性场景`,
+                    ],
+                    verification_method: [],
+                    estimated_risk: "medium",
+                    reversibility: "partially_reversible",
+                    required_human_decisions: [],
+                })),
+                recommended_option_id: "opt-0",
+                rejected_option_ids: [],
+                human_gate_required: true,
+                evidence_refs: [],
+                brainstorm_status: "options_ready",
+            };
+        }
         const brainstormResult = validateBrainstormSession(session);
         // 治理结果写入 workflow_trace.governance_findings
         if (!brainstormResult.valid) {
@@ -1635,7 +1577,7 @@ function inferTypeFromSubDir(subDir) {
  */
 function queryKnowledgeForRoute(knowledgeIndex, intent, scopeFilters, config, routeDecision, limit) {
     if (!routeDecision) {
-        // 无 route_decision 时回退到旧逻辑
+        // 无 route_decision 时回退到旧逻辑（不传 route，不强制路由匹配）
         return knowledgeIndex.query({
             scope: scopeFilters,
             products: [config.product_profile],
@@ -1643,6 +1585,7 @@ function queryKnowledgeForRoute(knowledgeIndex, intent, scopeFilters, config, ro
             limit,
         });
     }
+    const currentRoute = routeDecision.route;
     const seen = new Set();
     const results = [];
     function addEntries(entries) {
@@ -1660,6 +1603,7 @@ function queryKnowledgeForRoute(knowledgeIndex, intent, scopeFilters, config, ro
             scope: scopeFilters,
             products: [config.product_profile],
             type: "pipeline_procedure",
+            route: currentRoute,
             keywords: extractKeywords(pipelineName),
             limit: 3,
         });
@@ -1680,6 +1624,7 @@ function queryKnowledgeForRoute(knowledgeIndex, intent, scopeFilters, config, ro
                 scope: scopeFilters,
                 products: [config.product_profile],
                 type: "acceptance_template",
+                route: currentRoute,
                 keywords: [],
                 limit: 100,
             });
@@ -1722,6 +1667,7 @@ function queryKnowledgeForRoute(knowledgeIndex, intent, scopeFilters, config, ro
         const keywordResults = knowledgeIndex.query({
             scope: scopeFilters,
             products: [config.product_profile],
+            route: currentRoute,
             keywords: extractKeywords(intent),
             limit: limit,
         });