npm - soloforge - Versions diffs - 1.5.0 → 2.0.0 - Mend

soloforge 1.5.0 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2551) hide show

package/dist/engine/intent_expander.js DELETED Viewed

@@ -1,2190 +0,0 @@
-import Handlebars from "handlebars";
-/**
- * 意图膨胀器 — 将分类结果扩展为包含完整上下文的 AI 执行 prompt。
- *
- * 根据 route_decision.execution_shape 选择不同 prompt 模板:
- * - code_execution_prompt: 代码修改任务
- * - single_artifact_prompt: 单产物生成任务
- * - source_extraction_prompt: 源码/材料提取任务
- * - read_only_analysis_prompt: 只读分析任务
- */
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import fss from "node:fs";
-import matter from "gray-matter";
-import { detectConventions } from "./convention_detector.js";
-import { selectPromptTemplate } from "./intent_router.js";
-import { enforceKnowledgeInjectionBoundary, validateInjectionReport, getInjectedEntryIds } from "./knowledge_injection_boundary.js";
-import { parseFrontmatterVisibility } from "./template_asset_visibility.js";
-import { getContractDecision } from "./template_asset_contract_registry.js";
-import { createInputMaterial, createIngestionEvidence, buildPromptInjectionPlan, classifyIngestionStatus, } from "./input_material_contract_registry.js";
-import { normalizePathCandidate } from "./input_material_extractor.js";
-import { resolveWorkflow } from "./workflow_contract_registry.js";
-import { createOutputArtifact, getDefaultArtifactPath } from "./artifact_contract_registry.js";
-import { findToolInvocationContractByName } from "./tool_invocation_contract_registry.js";
-import { resolveCurrentProjectConfigReports } from "./config_precedence_contract.js";
-import { evaluatePrivacyGate, redactSensitiveText, } from "./privacy_secret_contract.js";
-import { getTaskLevel, getRequiredPrinciples, getEnforcementLevel, listCorePrinciples } from "./core_engineering_principles.js";
-import { listMechanismLayerMaps } from "./dual_layer_mechanism_registry.js";
-import { debugLog } from "./logger.js";
-import { evaluateCoreExperiencePrinciple, recordCepIntegration } from "./core_experience_principle.js";
-import { validateTechnologyDecision } from "./technology_decision.js";
-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) {
-    if (kind === "unknown")
-        return "custom";
-    if (kind === "design_doc")
-        return "design_doc";
-    if (kind === "api_spec")
-        return "api_spec";
-    if (kind === "task_breakdown")
-        return "task_breakdown";
-    if (kind === "root_cause")
-        return "root_cause";
-    if (kind === "acceptance_checklist")
-        return "acceptance_checklist";
-    if (kind === "interaction_spec")
-        return "interaction_spec";
-    if (kind === "domain_model")
-        return "domain_model";
-    // 其他类型均为合法的 ArtifactKind 值
-    return kind;
-}
-// ── Prompt 模板 ──
-// 1. code_execution_prompt: 允许修改业务源码，需要 scope 和验证
-const CODE_EXECUTION_TEMPLATE = Handlebars.compile(`## 任务
-{{intent}}
-## 项目上下文
-- 技术栈: {{tech_stack}}
-- 产品类型: {{product_profile}}
-- 涉及仓库: {{affected_repos}}
-{{#if matched_knowledge}}
-## 适用知识
-{{#each matched_knowledge}}
-### {{this.name}}
-{{this.content}}
-{{/each}}
-{{/if}}
-{{#if relevant_files}}
-## 相关文件
-{{#each relevant_files}}
-- {{this.path}} ({{this.reason}})
-{{/each}}
-{{/if}}
-{{#if is_legacy_code}}
-## 遗留代码注意事项
-以下文件存在与标准模式不一致的惯例，修改时请遵循现有风格:
-{{#each legacy_conventions}}
-- {{this}}
-{{/each}}
-{{/if}}
-## 约束
-- 只允许修改以下路径: {{scope.allowed_paths}}
-{{#unless scope.new_files_allowed}}
-- 不允许新建文件
-{{/unless}}
-{{#if scope.new_file_patterns}}
-- 新建文件必须匹配: {{scope.new_file_patterns}}
-{{/if}}
-## 验收标准
-### 自动验证（系统检查）
-{{#each acceptance.automated}}
-- [{{this.id}}] {{this.description}}
-{{/each}}
-{{#if acceptance.manual}}
-### 人工验证（需你确认）
-{{#each acceptance.manual}}
-- [{{this.id}}] {{this.description}}
-{{/each}}
-{{/if}}
-{{#if degraded}}
-**注意**: 当前无领域知识匹配，请保守操作，只修改必要文件。
-{{/if}}
-`);
-// 2. single_artifact_prompt: 默认不允许修改业务源码，必须有 output_artifact.path
-const SINGLE_ARTIFACT_TEMPLATE = Handlebars.compile(`## 任务
-{{intent}}
-## 产物要求
-- 产物类型: {{output_artifact.kind}}
-- 输出路径: {{output_artifact.path}}
-{{#if output_artifact.template}}
-- 参考模板: {{output_artifact.template}}
-{{/if}}
-## 项目上下文
-- 技术栈: {{tech_stack}}
-- 产品类型: {{product_profile}}
-{{#if matched_knowledge}}
-## 适用知识
-{{#each matched_knowledge}}
-### {{this.name}}
-{{this.content}}
-{{/each}}
-{{/if}}
-## 约束
-- 默认不允许修改业务源码
-- 只允许写入指定产物路径
-- 产物必须结构完整、证据充分、可交接
-## 验收标准
-{{#if acceptance.automated}}
-### 自动验证
-{{#each acceptance.automated}}
-- [{{this.id}}] {{this.description}}
-{{/each}}
-{{/if}}
-### 人工验证
-- 产物完整性: 章节齐全，无空白占位
-- 证据充分: 关键结论有引用或出处
-- 可交接性: 下游可基于此产物继续工作
-{{#if degraded}}
-**注意**: 当前无专用模板，请按同类通用产物结构输出。
-{{/if}}
-`);
-// 3. source_extraction_prompt: 只读输入材料，不允许修改项目源码
-const SOURCE_EXTRACTION_TEMPLATE = Handlebars.compile(`## 任务
-{{intent}}
-## 输入材料
-{{#each input_materials}}
-- 类型: {{this.kind}}{{#if this.path}}，路径: {{this.path}}{{/if}}{{#if this.ingestion_status}}，状态: {{this.ingestion_status}}{{/if}}（只读）
-{{/each}}
-{{#if input_material_contract_notes}}
-## 输入材料契约检查
-{{#each input_material_contract_notes}}
-- {{this}}
-{{/each}}
-{{/if}}
-## 产物要求
-- 产物类型: {{output_artifact.kind}}
-- 输出路径: {{output_artifact.path}}
-{{#if output_artifact.template}}
-- 参考模板: {{output_artifact.template}}
-{{/if}}
-{{#if pipeline_hint}}
-- 流程提示: {{pipeline_hint}}
-{{/if}}
-{{#if matched_knowledge}}
-## 适用知识
-{{#each matched_knowledge}}
-### {{this.name}}
-{{this.content}}
-{{/each}}
-{{/if}}
-## 约束
-- 输入材料只读，不得修改
-- 不允许修改项目业务源码 (src/)
-- 可将 zip 解压到临时目录读取
-- 源码中无法确认的信息必须标记 [Manual Confirm]
-- 必须标注证据来源（哪个文件/哪段代码）
-- 禁止使用 Figma MCP、浏览器运行态、figma.site、截图或纯 Design 文件补充信息
-## 验收标准
-### 产物完整性
-- 产物结构完整、章节齐全
-- 每条信息有源码出处
-- 缺失信息标记 [Manual Confirm]
-{{#if degraded}}
-**注意**: 当前无专用模板，请按通用提取产物结构输出。
-{{/if}}
-`);
-// 4. read_only_analysis_prompt: 只读分析，默认不写文件
-const READ_ONLY_ANALYSIS_TEMPLATE = Handlebars.compile(`## 任务
-{{intent}}
-## 项目上下文
-- 技术栈: {{tech_stack}}
-- 产品类型: {{product_profile}}
-{{#if matched_knowledge}}
-## 适用知识
-{{#each matched_knowledge}}
-### {{this.name}}
-{{this.content}}
-{{/each}}
-{{/if}}
-## 约束
-- 默认不允许修改业务源码
-- 只读分析当前项目或指定材料
-- 输出结论、证据、风险和建议
-- 默认不写文件，除非明确指定输出路径
-{{#if output_artifact}}
-## 输出要求
-- 输出路径: {{output_artifact.path}}
-{{/if}}
-## 分析要求
-- 给出明确结论
-- 列出支撑证据
-- 标注风险和假设
-- 给出建议（如有）
-`);
-// 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}}
-## 验证目标
-{{#if relevant_files}}
-### 相关文件
-{{#each relevant_files}}
-- {{this.path}} ({{this.reason}})
-{{/each}}
-{{/if}}
-## 约束
-- 默认不允许修改业务源码
-- 只生成验证命令和检查逻辑
-- 输出验证结果（通过/失败/需人工确认）
-## 验证要求
-- 列出具体验证命令
-- 标注预期结果
-- 标注不确定项
-`);
-// 6. direct_answer_prompt: 直接回答，不进入代码执行
-const DIRECT_ANSWER_TEMPLATE = Handlebars.compile(`## 任务
-{{intent}}
-## 要求
-- 直接回答用户问题
-- 不修改任何项目文件
-- 给出明确结论和依据
-`);
-// ── 工作流专属模板 ──
-// 7. architecture_design_prompt: 架构设计工作流
-const ARCHITECTURE_DESIGN_TEMPLATE = Handlebars.compile(`## 任务
-{{intent}}
-## 工作流: 架构设计 (architecture_design)
-### 架构决策研讨前置门
-- 正式架构设计前必须先完成六类架构决策研讨: 业务流程、数据架构、安全架构、后端架构、前端架构、基础设施
-- 每个必要决策域必须包含事实/约束、2 至 3 个方案、推荐理由、风险和用户确认引用
-- 任一必要域未确认时，只能输出待讨论清单或草案结构，不得输出可执行的正式架构设计文档
-- 六域闭合后必须生成或引用 \`docs/architecture/00-架构决策记录.md\`
-### 输入材料约束
-- 必须消费所有输入端的原型说明、需求文档、业务流程和已有技术约束
-- 多端输入时必须覆盖每个端的设计要求
-- 未覆盖的输入材料不得声称架构设计已完成
-### 架构边界
-- 必须明确前后端边界、模块划分、API 契约、数据流和部署拓扑
-- 必须包含 Mermaid 序列图（关键业务流程、登录鉴权、权限校验、跨端协作、异步任务）
-- Mermaid 必须语法可渲染，不得使用伪代码
-### 技术栈策略
-- 后端默认优先 Java，除非用户项目已有明确技术栈或用户确认 override
-- 前端默认优先最新稳定 Vue 生态 + TypeScript，除非用户项目已有明确技术栈或用户确认 override
-- 前端技术栈必须说明语言、构建工具、路由、状态管理、接口类型、测试和代码规范
-- 不同前端端默认不同项目仓库或独立应用边界；合并仓库必须用户确认
-### 不确定项处理
-- 不确定项必须给推荐、理由、备选、风险和需要用户确认的问题
-- 架构级不确定项必须先接头脑风暴/多方案探索，再接决策主权和用户确认
-### 输出目录
-- 输出目录名必须由用户确认，不得静默使用任务名或目录名
-### 设计产物包
-- 架构决策闭合后，完整设计以 \`00-架构决策记录.md\`、\`01-架构设计文档.md\`、\`02-数据库设计文档.md\`、\`03-API接口规格文档.md\`、\`99-设计一致性验收报告.md\` 组成
-- API 字段和路径的机器权威为 \`docs/api/openapi.yaml\`；数据库物理结构的机器权威为真实 SQL/migration
-- 每个 API endpoint 必须具备请求和响应字段级说明；仅 JSON 示例不构成规格
-- 既有设计文档必须先复验和确认升级，禁止静默覆盖或直接作为新实现依据
-{{#if output_artifact}}
-## 产物要求
-- 产物类型: {{output_artifact.kind}}
-- 输出路径: {{output_artifact.path}}
-{{/if}}
-{{#if matched_knowledge}}
-## 适用知识
-{{#each matched_knowledge}}
-### {{this.name}}
-{{this.content}}
-{{/each}}
-{{/if}}
-## 验收标准
-- 架构设计文档章节齐全，无空白占位
-- Mermaid 序列图语法正确、可渲染
-- 技术栈选择有依据（默认策略或 override evidence）
-- 不确定项全部列出并有推荐方案
-- 输出目录已请求用户确认
-- 六域决策均有用户确认引用，设计产物包可被真实复验
-- API/OpenAPI/SQL/Markdown 之间不存在关键冲突
-`);
-// 8. gap_analysis_prompt: 现有系统差距分析工作流
-const GAP_ANALYSIS_TEMPLATE = Handlebars.compile(`## 任务
-{{intent}}
-## 工作流: 现有系统差距分析 (existing_system_gap_analysis)
-### 只读分析约束
-- 本工作流为只读分析，不得直接修改项目源码
-- 必须读取真实代码和相关文档，不能只读需求文档
-- 分析结论必须区分 fact / inference / assumption / unknown，并带 confidence 和 evidence_refs
-### 现有系统证据要求
-- 必须先判断项目类型: existing_system / empty_project / new_system / unknown
-- existing_system 必须完成现有系统分析（L1 项目指纹、L2 相关域、L3 影响面）
-- 现有项目技术栈、目录结构、命名风格等优先于 SoloForge 默认策略
-### 差距清单
-- 必须围绕新需求 vs 现有能力，列出现有能力、缺失能力、复用模块
-- 必须包含: required_changes / optional_changes / out_of_scope
-- 必须列出: 兼容风险、数据风险、权限风险、接口风险、前后端影响
-### 影响面与主链路
-- 必须生成 MainlineIntegrationPlan: entry_points / route_bindings / api_bindings / service_calls / data_bindings
-- 实现后必须反查新增文件是否被真实消费
-- VerificationPlan 必须从 RequirementGapAnalysis 生成
-### 禁止直接修改
-- 差距分析完成后不得直接进入编码
-- 必须生成分析报告，等待后续编码工作流消费
-{{#if matched_knowledge}}
-## 适用知识
-{{#each matched_knowledge}}
-### {{this.name}}
-{{this.content}}
-{{/each}}
-{{/if}}
-## 验收标准
-- 项目类型判断正确
-- 现有系统分析基于真实代码，每条结论有 evidence_refs
-- 差距清单完整（现有能力 + 缺失能力 + 风险）
-- MainlineIntegrationPlan 列出所有绑定点
-- 不存在 AI 把 inference/assumption 写成 fact 的情况
-`);
-// 9. test_first_coding_prompt: 测试优先编码工作流
-const TEST_FIRST_CODING_TEMPLATE = Handlebars.compile(`## 任务
-{{intent}}
-## 工作流: 测试优先编码 (test_first_coding)
-### 测试先行约束
-- 编码不是第一步，必须先通过 CodingReadinessGate
-- 必须生成 TestFirstPlan 或合法 not_applicable_with_reason
-- 有测试框架且行为可断言时，必须先写失败测试或回归测试
-- 不能自动测试时，必须先写 verification_case_first 或 manual_acceptance_first
-### 上游约束消费
-- 必须消费上游约束: ExistingSystemAnalysis / RequirementGapAnalysis / ArchitectureDesignContract
-- 未消费上游约束不得开始实现
-- ArchitectureDesignContract 中未确认的不确定项不得编码
-### 最小实现
-- readiness_status=blocked/manual_required 时不得写实现代码
-- 实现必须最小化，不得超出需求范围
-- 新增代码必须被真实主链路消费，未被消费不得 completed
-### 验证结果
-- 实现后必须执行 VerificationPlan
-- 测试失败不得删除测试、降低断言、skip 后声称通过
-- 必须产出 VerificationEvidence
-{{#if matched_knowledge}}
-## 适用知识
-{{#each matched_knowledge}}
-### {{this.name}}
-{{this.content}}
-{{/each}}
-{{/if}}
-## 项目上下文
-- 技术栈: {{tech_stack}}
-- 产品类型: {{product_profile}}
-## 约束
-- 只允许修改以下路径: {{scope.allowed_paths}}
-{{#unless scope.new_files_allowed}}
-- 不允许新建文件
-{{/unless}}
-## 验收标准
-- CodingReadinessGate 已通过
-- TestFirstPlan 已生成并有测试用例
-- 上游约束（差距分析、架构设计）已消费
-- 实现后 VerificationPlan 已执行
-- 新增代码被真实主链路消费
-`);
-// 10. local_acceptance_prompt: 本地浏览器验收工作流
-const LOCAL_ACCEPTANCE_TEMPLATE = Handlebars.compile(`## 任务
-{{intent}}
-## 工作流: 本地浏览器验收 (local_browser_acceptance)
-### 本地服务约束
-- 必须识别项目运行方式: docker_compose > dockerfile > dev_server > manual_required
-- 服务启动后必须健康检查，不得服务未 ready 就跑浏览器验收
-- 健康检查必须验证: container healthy / backend health endpoint / frontend reachable
-### 浏览器/HTTP 验收
-- 验收用例必须覆盖: 任务相关页面、路由、核心交互、API 联动、错误态、loading 态
-- 必须产出截图或 trace 引用作为证据
-- 空验收用例或无 URL 不得通过
-### 截图/trace/URL 证据
-- 必须记录每个验收步骤的 target_url
-- 必须记录 assertion_results（通过/失败）
-- 必须记录 console_errors 和 network_failures（如有）
-- 证据必须关联到 latest run（build hash 或 timestamp）
-### 修复重跑
-- 浏览器验收失败必须在授权范围内自动修复
-- 修复后必须重新 build/redeploy/retest，不得用旧构建结果
-- retry budget 耗尽、scope 不足、外部服务不可用时必须 manual_required
-### 最终交付
-- 必须给用户 frontend/backend/docs/swagger 本地可访问 URL
-- 必须给启动/停止命令和人工查验说明
-- 未给最终本地 URL 不得 delivered
-## 验收标准
-- 服务已启动并健康检查通过
-- 浏览器/HTTP 验收全部通过（或有明确 failure 证据）
-- 最终 URL 已提供给用户
-- build hash/timestamp 已记录
-- 失败用例已触发修复循环或 manual_required
-`);
-/** 保留旧模板名为 CODE_EXECUTION_TEMPLATE 的别名（兼容旧测试） */
-const PROMPT_TEMPLATE = CODE_EXECUTION_TEMPLATE;
-/** 将 PromptInjectionPlan 渲染为 Markdown 段落（统一注入，避免模板内重复） */
-function renderPromptInjectionPlan(plan) {
-    const sections = [];
-    if (plan.evidence_refs.length > 0) {
-        sections.push("## 材料证据引用\n" + plan.evidence_refs.map((r) => "- " + r).join("\n"));
-    }
-    if (plan.required_summary.length > 0) {
-        sections.push("## 必需材料摘要\n" + plan.required_summary.map((s) => "- " + s).join("\n"));
-    }
-    if (plan.forbidden_notes.length > 0) {
-        sections.push("## 禁止/不可用材料\n" + plan.forbidden_notes.map((n) => "- " + n).join("\n"));
-    }
-    if (plan.manual_confirm_list.length > 0) {
-        sections.push("## 人工确认项\n" + plan.manual_confirm_list.map((c) => "- " + c).join("\n"));
-    }
-    if (plan.allowed_sources.length > 0) {
-        sections.push("## 允许的材料来源\n" + plan.allowed_sources.map((s) => "- " + s).join("\n"));
-    }
-    if (plan.forbidden_sources.length > 0) {
-        sections.push("## 禁止的材料来源\n" + plan.forbidden_sources.map((s) => "- " + s).join("\n"));
-    }
-    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 模板。
- * 模板使用独立工作流专属模板，包含对应约束注入。
- */
-function chooseTemplate(templateName) {
-    switch (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;
-        case "gap_analysis_prompt": return GAP_ANALYSIS_TEMPLATE;
-        case "test_first_coding_prompt": return TEST_FIRST_CODING_TEMPLATE;
-        case "local_acceptance_prompt": return LOCAL_ACCEPTANCE_TEMPLATE;
-        case "code_execution_prompt":
-        default: return CODE_EXECUTION_TEMPLATE;
-    }
-}
-/**
- * 解析澄清答案，将路径注入 route_decision.input_materials，
- * 清除已解决的 missing_required_inputs。
- * 返回新的 route_decision（不修改原对象）。
- */
-function resolveClarificationAnswers(decision, intent, answers) {
-    const resolved = {
-        ...decision,
-        input_materials: decision.input_materials.map((m) => ({ ...m })),
-        missing_required_inputs: [...decision.missing_required_inputs],
-    };
-    const addedPaths = [];
-    for (const answer of answers) {
-        // 提取路径 - absolute paths starting with /
-        const absPathPattern = /(?<![^\s])\/[^\s\]]+/g;
-        for (const m of answer.matchAll(absPathPattern)) {
-            const p = m[0];
-            if (p && p.length > 1 && !addedPaths.includes(p)) {
-                addedPaths.push(p);
-            }
-        }
-        // 提取相对路径 (word/word.ext 模式)
-        const relPathPattern = /[\w][\w.\-]*(?:\/[\w.\-]+)+\.[\w]+/g;
-        for (const m of answer.matchAll(relPathPattern)) {
-            const p = m[0];
-            if (p && !addedPaths.includes(p) && !addedPaths.some((ap) => ap.endsWith("/" + p))) {
-                addedPaths.push(p);
-            }
-        }
-    }
-    for (const p of addedPaths) {
-        if (resolved.input_materials.some((m) => m.path === p))
-            continue;
-        let kind = "file";
-        if (/\.(zip|tar\.gz|gz|rar|7z|jar|war)$/i.test(p))
-            kind = "archive";
-        else if (/\.log$/i.test(p))
-            kind = "log";
-        else if (/\.(md|txt|doc|pdf|docx)$/i.test(p))
-            kind = "doc";
-        else if (/\.(java|py|ts|tsx|js|jsx|go|rs)$/i.test(p))
-            kind = "file";
-        resolved.input_materials.push({ kind, path: p, required: true });
-    }
-    // 仅清除路径类型的缺失输入（保留非路径问题如"哪个框架?"）
-    if (addedPaths.length > 0) {
-        resolved.missing_required_inputs = resolved.missing_required_inputs.filter((m) => !/path|路径|目录|文件|folder|directory|file/i.test(m));
-    }
-    return resolved;
-}
-/**
- * 获取 sf_expand 契约的 next_allowed_tools 和 forbidden_tools。
- */
-function getExpandContractTools() {
-    const contract = findToolInvocationContractByName("sf_expand");
-    return {
-        next_allowed_tools: contract?.default_next_tools ?? [],
-        forbidden_tools: contract?.forbidden_next_tools ?? [],
-    };
-}
-/**
- * 将分类结果扩展为完整的 AI 执行 prompt 和配套元数据。
- */
-export async function expand(input) {
-    debugLog("意图膨胀: 开始扩展，路由=%s", input.route_decision?.route ?? input.classification?.task_type ?? "unknown");
-    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 {
-        configResolution = await resolveCurrentProjectConfigReports(projectPath);
-    }
-    catch (e) {
-        debugLog("意图扩展: 配置优先级解析失败 —", e);
-        configResolution = { reports: [], resolutions: [], warnings: [], entries: [] };
-    }
-    const configWarnings = configResolution.warnings;
-    // 消费澄清答案：解析路径，更新 input_materials，清除已解决的 missing_required_inputs
-    if (input.clarificationAnswers && input.clarificationAnswers.length > 0 && routeDecision) {
-        routeDecision = resolveClarificationAnswers(routeDecision, intent, input.clarificationAnswers);
-    }
-    // ── Privacy gate— 提前到所有 early-return 之前 ──
-    // 轻量路径（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) {
-            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
-            .filter((m) => m.path)
-            .map((m) => m.path);
-        // 冲突时拒绝 with input.task_id
-        if (routeDecision.output_artifact.taskId && routeDecision.output_artifact.taskId !== input.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({
-            kind: artifactKind,
-            task_id: input.task_id,
-            workflow_id: "pending",
-            created_by: "intent_expander",
-            path: getDefaultArtifactPath(artifactKind, input.task_id),
-            source_material_refs: sourceMaterialRefs,
-        });
-    }
-    // ── 工作流契约解析 ──
-    let workflowContract = undefined;
-    let workflowGovernanceFindings = [];
-    if (routeDecision) {
-        workflowContract = resolveWorkflow(routeDecision);
-        // 提前绑定 workflow_id to artifact record
-        if (workflowContract && outputArtifactRecord) {
-            outputArtifactRecord.workflow_id = workflowContract.id;
-        }
-        debugLog("意图膨胀: 工作流契约已解析，workflow=%s", workflowContract?.id ?? "none");
-        // CEP: 工作流解析后核心体验评估
-        const cepWfResult = evaluateCoreExperiencePrinciple({
-            task_id: input.task_id ?? "", workflow_id: "workflow_resolve",
-            has_mainline_hooks: !!workflowContract, has_owner_contracts: !!workflowContract,
-            natural_language_entry: true, requires_internal_contract_knowledge: false,
-            user_path_steps: 3, has_failures: !workflowContract, hard_fail_downgraded: false,
-            forced_heavy_process: false, has_sufficient_evidence: !!workflowContract,
-            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,
-        });
-        recordCepIntegration("workflow_resolve", cepWfResult);
-        if (!workflowContract) {
-            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",
-                },
-            });
-        }
-        // 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",
-                },
-            });
-        }
-        // 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",
-                },
-            });
-        }
-    }
-    // 缺少必需输入时返回澄清，不生成执行 prompt（在 workflow resolution 之后）
-    if (routeDecision && routeDecision.missing_required_inputs.length > 0) {
-        debugLog("意图膨胀: 缺少必需输入 %d 项，返回澄清请求", routeDecision.missing_required_inputs.length);
-        return buildClarificationResult(intent, routeDecision, config, workflowContract, safeIntent, safeGoal);
-    }
-    // ── 输入材料契约 ──
-    let inputMaterials;
-    let ingestionEvidences;
-    let promptInjectionPlan;
-    const contractNotes = [];
-    if (routeDecision && routeDecision.input_materials.length > 0) {
-        const pathMaterials = routeDecision.input_materials.filter((m) => m.path);
-        if (pathMaterials.length > 0) {
-            const materials = pathMaterials.map((m) => createInputMaterial({ path_or_ref: normalizePathCandidate(m.path) }));
-            inputMaterials = materials;
-            ingestionEvidences = materials.map((m) => createIngestionEvidence(m));
-            for (const m of materials) {
-                if (m.access_mode === "forbidden") {
-                    contractNotes.push(`[FORBIDDEN] ${m.path_or_ref}: 禁止读取`);
-                }
-                else if (m.trust_level === "external_unverified" || m.trust_level === "derived" || m.trust_level === "ai_generated") {
-                    contractNotes.push(`[Manual Confirm] ${m.path_or_ref}: 信任等级=${m.trust_level}`);
-                }
-            }
-            promptInjectionPlan = buildPromptInjectionPlan(materials, ingestionEvidences);
-        }
-    }
-    // ── 输入材料硬阻断──
-    if (inputMaterials) {
-        const forbiddenMaterials = inputMaterials.filter((m) => m.access_mode === "forbidden");
-        if (!skipInputMaterialHardBlock && forbiddenMaterials.length > 0) {
-            const forbiddenPaths = forbiddenMaterials.map((m) => m.path_or_ref).join(", ");
-            debugLog("意图膨胀: 输入材料禁止读取: %s", forbiddenPaths);
-            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",
-                } : undefined,
-            });
-        }
-        const confirmations = input.input_material_confirmations ?? [];
-        const requiresConfirmationMaterials = inputMaterials.filter((m) => m.access_mode !== "forbidden"
-            && classifyIngestionStatus(m.path_or_ref) === "requires_confirmation"
-            && !confirmations.includes(m.path_or_ref));
-        if (requiresConfirmationMaterials.length > 0) {
-            const confirmPaths = requiresConfirmationMaterials.map((m) => m.path_or_ref);
-            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",
-                } : undefined,
-            });
-        }
-    }
-    // ── 隐私硬阻断门禁 (privacyGate 已在顶部计算) ──
-    const privacyLabels = privacyGate.labels;
-    const privacyRedactions = privacyGate.redaction_records;
-    const privacyFindings = privacyGate.findings;
-    // 硬阻断: 意图或输入材料中包含密钥/凭证
-    if (privacyGate.hard_fail) {
-        debugLog("意图膨胀: 隐私策略阻断，包含 %d 个禁止来源", privacyGate.blocked_sources.length);
-        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",
-            } : undefined,
-        });
-    }
-    // 1. 查询知识库（路由驱动匹配）
-    const affectedRepos = getAffectedRepos(classification);
-    const scopeFilters = affectedRepos.length > 0
-        ? affectedRepos
-        : inferScopeFromIntentAndConfig(intent, classification, config);
-    const knowledgeLimit = classification.strategy === "quick_fix" ? 2 : 5;
-    const skipHeavyAnalysis = classification.strategy === "quick_fix";
-    const lifecycleKnowledgeDecision = evaluateLifecycleKnowledgeDecision({
-        projectPath,
-        consumer: "sf_expand",
-        intent,
-        route: routeDecision?.route,
-        tech_stack: [
-            config.tech_stack?.backend?.lang,
-            config.tech_stack?.backend?.framework,
-            config.tech_stack?.frontend?.lang,
-            config.tech_stack?.frontend?.framework,
-        ].filter(Boolean),
-        lifecycle_stage: routeDecision?.route === "code_change" ? "implementation" : routeDecision?.route === "verification" ? "testing" : undefined,
-        traceability_ids: [
-            ...extractTraceabilityIds(intent),
-            ...(classification.traceability_ids ?? []),
-        ],
-        config,
-        selection_limit: 6,
-        record_trace: true,
-    });
-    const projectKnowledgeReport = lifecycleKnowledgeDecision.project_knowledge;
-    const projectKnowledgeFindings = projectKnowledgeReport.assets.flatMap((asset) => asset.findings.map((finding) => ({
-        rel_path: asset.rel_path,
-        code: finding.code,
-        severity: finding.severity,
-        message_zh: finding.message_zh,
-    })));
-    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 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,
-            },
-            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",
-            } : undefined,
-        });
-    }
-    const projectKnowledgeSelection = lifecycleKnowledgeDecision.knowledge_selection;
-    const selectedProjectKnowledge = projectKnowledgeSelection.selected.map((decision) => decision.asset);
-    const projectKnowledgeEntries = selectedProjectKnowledge.map(projectKnowledgeAssetToEntry).filter(Boolean);
-    const matchedEntries = mergeKnowledgeEntries([
-        ...queryKnowledgeForRoute(knowledgeIndex, intent, scopeFilters, config, routeDecision, knowledgeLimit),
-        ...projectKnowledgeEntries,
-    ]);
-    // 知识注入边界（ 三道门过滤）
-    const productFilters = [config.product_profile];
-    const injectionReport = enforceKnowledgeInjectionBoundary(matchedEntries, routeDecision, scopeFilters, undefined, knowledgeLimit, productFilters);
-    const injectedIds = new Set(getInjectedEntryIds(injectionReport));
-    const filteredEntries = matchedEntries.filter((e) => injectedIds.has(e.id));
-    if (filteredEntries.length > 0) {
-        knowledgeIndex.markUsed(filteredEntries.map((e) => e.id));
-    }
-    // 记录 expander 真实消费 trace — 按 trigger 语义过滤
-    // mechanism:enrich 资产始终消费（机制级规则），output_artifact.kind=X 仅当 route 匹配时消费
-    const { recordConsumptionTrace, CONSUMER_FIELD_CONTRACTS } = await import("./consumption_trace_store.js");
-    const { listConsumableAssetsByConsumer } = await import("./consumable_asset_registry.js");
-    const expanderRegistryAssets = listConsumableAssetsByConsumer("intent_expander")
-        .filter(a => a.consumption_mode === "required");
-    for (const asset of expanderRegistryAssets) {
-        // Route 语义过滤：output_artifact.kind=X 只在 route 需要时消费
-        const artifactMatch = asset.trigger?.match(/^output_artifact\.kind=(.+)$/);
-        if (artifactMatch) {
-            if (routeDecision?.output_artifact?.kind !== artifactMatch[1])
-                continue;
-        }
-        const { getContractByPath } = await import("./template_asset_contract_registry.js");
-        const contract = getContractByPath(asset.path);
-        recordConsumptionTrace({
-            consumer: "expander",
-            asset_id: asset.id,
-            asset_path: asset.path,
-            fields_consumed: CONSUMER_FIELD_CONTRACTS.expander,
-            matched_reason: `route=${routeDecision?.route ?? "unknown"} shape=${routeDecision?.execution_shape ?? "unknown"} trigger=${asset.trigger ?? "none"}`,
-            task_id_or_route: routeDecision?.route ?? "expand",
-            consumed_at: new Date().toISOString(),
-            declared_consumer: contract?.mainline_consumer,
-        });
-    }
-    if (filteredEntries.length > 0 && routeDecision) {
-        for (const entry of filteredEntries.slice(0, 5)) {
-            recordConsumptionTrace({
-                consumer: "expander",
-                asset_id: entry.id,
-                fields_consumed: CONSUMER_FIELD_CONTRACTS.expander,
-                matched_reason: `route=${routeDecision.route} shape=${routeDecision.execution_shape} injected`,
-                task_id_or_route: routeDecision.route,
-                consumed_at: new Date().toISOString(),
-            });
-        }
-    }
-    // 治理校验：validateInjectionReport
-    const governanceFindings = validateInjectionReport(injectionReport);
-    const hardFails = governanceFindings.filter((f) => f.severity === "hard_fail");
-    const hasMissingRequiredKnowledge = injectionReport.missing_required_knowledge && injectionReport.missing_required_knowledge.length > 0;
-    // 存储治理发现 in report
-    injectionReport.governance_findings = governanceFindings;
-    const degraded = filteredEntries.length === 0
-        && injectionReport.injected_required.length === 0;
-    // 任何 hard_fail 都阻止 from validateInjectionReport — not just missing_required_knowledge
-    if (hardFails.length > 0) {
-        debugLog("意图膨胀: 注入校验失败，%d 个 hard_fail", hardFails.length);
-        const failMessages = hardFails.map((f) => f.message).join("\n");
-        const missingDesc = hasMissingRequiredKnowledge
-            ? injectionReport.missing_required_knowledge.map((m) => m.reason).join("\n")
-            : "";
-        const missingSection = missingDesc ? `\n\n缺少的必需知识:\n${missingDesc}` : "";
-        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",
-            } : undefined,
-        });
-    }
-    // 2. 检测遗留惯例（只对 code_execution 执行）
-    const legacyConventions = [];
-    let isLegacyCode = false;
-    if (templateName === "code_execution_prompt" && !skipHeavyAnalysis && !degraded && affectedRepos.length > 0) {
-        try {
-            const repoDirs = affectedRepos
-                .map((r) => config.repos.find((repo) => repo.name === r)?.path)
-                .filter(Boolean);
-            const conventions = await detectConventions(repoDirs.map((d) => `${d}/src`).slice(0, 3), projectPath, config.conventions_file);
-            if (conventions.length > 0) {
-                isLegacyCode = true;
-                legacyConventions.push(...conventions.map((c) => c.convention));
-            }
-        }
-        catch (e) {
-            debugLog("意图扩展: 惯例检测失败 —", e);
-            // 惯例检测为尽力而为
-        }
-    }
-    // 3. 确定 scope（非代码任务使用简化 scope）
-    const scope = resolveScope(config, classification, degraded, routeDecision);
-    // 4. 生成验收标准
-    const acceptance = generateAcceptance(intent, classification, filteredEntries, config, degraded, routeDecision);
-    // 5. 组装 prompt
-    const techStack = buildTechStackLabel(config);
-    const template = chooseTemplate(templateName);
-    const templateData = buildTemplateData(safeIntent, techStack, config, classification, scope, filteredEntries, legacyConventions, isLegacyCode, acceptance, degraded, routeDecision);
-    if (promptInjectionPlan)
-        templateData.prompt_injection_plan = promptInjectionPlan;
-    // ── 双层机制模板注入（ 路由/状态过滤） ──
-    const dlMechanisms = listMechanismLayerMaps();
-    const currentRoute = routeDecision?.route ?? "";
-    const currentWorkflow = workflowContract?.id ?? "";
-    const dlRules = [];
-    for (const mech of dlMechanisms) {
-        // 仅 dual_layer_enforced or experimental_dual_layer mechanisms inject
-        if (mech.status !== "dual_layer_enforced" && mech.status !== "experimental_dual_layer")
-            continue;
-        // 路由必须匹配 mechanism's injected_routes
-        if (mech.injected_routes && mech.injected_routes.length > 0 && currentRoute) {
-            if (!mech.injected_routes.includes(currentRoute))
-                continue;
-        }
-        // 工作流必须匹配 mechanism's injected_workflows
-        if (mech.injected_workflows && mech.injected_workflows.length > 0 && currentWorkflow) {
-            if (!mech.injected_workflows.includes(currentWorkflow))
-                continue;
-        }
-        // 仅注入必需资产; supporting are handled by knowledge injection boundary
-        const requiredAssets = mech.template_assets.filter((ta) => ta.consumption_mode === "required");
-        for (const ra of requiredAssets) {
-            try {
-                const content = fss.readFileSync(ra.path, "utf-8").trim();
-                if (content)
-                    dlRules.push(`[${mech.mechanism_name}] ${content}`);
-            }
-            catch (e) {
-                debugLog("意图扩展: 双层机制模板加载失败 —", e);
-            }
-        }
-    }
-    if (dlRules.length > 0) {
-        templateData.dual_layer_rules = dlRules;
-        const existing = templateData.matched_knowledge;
-        if (existing) {
-            existing.push({ name: "强制机制规则（双层注入）", content: dlRules.join("\n\n") });
-        }
-    }
-    let prompt = template(templateData);
-    debugLog("意图膨胀: Prompt 模板渲染完成，模板=%s", templateName);
-    // 5.1 注入计划阶段上下文
-    if (input.plan_context) {
-        prompt = injectPlanContext(prompt, input.plan_context, knowledgeIndex);
-    }
-    // 7. 生成执行契约（能力 1）
-    const contract = buildExecutionContract(safeIntent, classification, scope, acceptance, routeDecision);
-    // 8. 生成不确定性触发条件（quick_fix 跳过）
-    const uncertaintyTriggers = skipHeavyAnalysis
-        ? []
-        : buildUncertaintyTriggers(classification, intent);
-    // 机制 1: 意图熔断器检查（轻量路径跳过）
-    const breakerResult = skipPreImplementationGates ? { tripped: false, confidence: 1.0 } : checkCircuitBreaker({
-        intent,
-        classification,
-        matchedEntries: filteredEntries,
-        degraded,
-    });
-    let circuitBreakerOutput;
-    if (breakerResult.tripped) {
-        debugLog("意图膨胀: 意图熔断触发，置信度=%.2f", breakerResult.confidence);
-        circuitBreakerOutput = breakerResult;
-        prompt += `
----
-## ⚠ 意图熔断触发（置信度: ${breakerResult.confidence.toFixed(2)}）
-当前需求理解置信度低于 ${CONFIDENCE_THRESHOLD}，以下为分析辅助:
-### 【逻辑盲区】
-${breakerResult.brainstorm.blind_spots.map((s) => `- ${s}`).join("\n")}
-### 【三轨演进】
-- **极简验证路径**: ${breakerResult.brainstorm.evolution_tracks.minimal}
-- **工业级标准路径**: ${breakerResult.brainstorm.evolution_tracks.industrial}
-- **激进重构路径**: ${breakerResult.brainstorm.evolution_tracks.radical}
-### 【闭环逼问】
-${breakerResult.brainstorm.decision_questions.map((q, i) => `${i + 1}. ${q.question}\n   A) ${q.option_a}\n   B) ${q.option_b}`).join("\n\n")}
-**注意**: ${routeDecision?.execution_shape === "code_execution"
-            ? "请等待人类决策后再输出执行代码。"
-            : "请先补齐阻塞输入，或在产物中标记 [Manual Confirm] 后再生成产物。"}
-`;
-    }
-    // problem-16: 技术决策验证 — 仅施工路径 + 高复杂度时校验 human gate
-    let technologyDecisionEvidence;
-    let techDecisionRequiresManual = false;
-    if (!skipHeavyContractGates && routeDecision?.execution_shape === "code_execution" && classification.complexity === "high") {
-        const decisionContract = {
-            decision_id: `td-${input.task_id ?? "unknown"}`,
-            decision_scope: "architecture",
-            options: [],
-            recommended_option: "",
-            rejected_options: [],
-            evidence: [],
-            falsification: [],
-            failure_conditions: [],
-            validation_plan: [],
-            rollback_or_exit_plan: [],
-            human_gate_required: true,
-            human_gate_reason: "高复杂度架构变更需要人工确认",
-            executable_without_human: false,
-        };
-        const decisionResult = validateTechnologyDecision(decisionContract);
-        // 治理结果写入 workflow_trace.governance_findings
-        if (!decisionResult.valid) {
-            for (const violation of decisionResult.violations) {
-                workflowGovernanceFindings.push({
-                    severity: "hard_fail",
-                    rule: "technology_decision_human_gate",
-                    message: `技术决策校验: ${violation}`,
-                });
-            }
-            techDecisionRequiresManual = true;
-            technologyDecisionEvidence = `技术决策校验: 需要人工确认 (${decisionResult.violations.join(", ")})`;
-            prompt += `\n\n---\n\n## ⚠ 技术决策校验\n${technologyDecisionEvidence}\n> 高复杂度架构变更需要人工确认后方可执行。`;
-        }
-        else {
-            // 校验通过也记录结构化 evidence
-            workflowGovernanceFindings.push({
-                severity: "info",
-                rule: "technology_decision_human_gate",
-                message: "技术决策校验通过: 已确认 human gate 合规",
-            });
-        }
-    }
-    // problem-41: 脑暴完整性校验 — 仅施工路径校验
-    // 优先使用用户提供的 brainstorm_session，否则从 circuit breaker 自动生成
-    let brainstormEvidence;
-    let brainstormRequiresClarification = false;
-    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) {
-            for (const violation of brainstormResult.violations) {
-                workflowGovernanceFindings.push({
-                    severity: "hard_fail",
-                    rule: "brainstorm_completeness",
-                    message: `脑暴完整性校验: ${violation}`,
-                });
-            }
-            brainstormRequiresClarification = true;
-            brainstormEvidence = `脑暴校验: ${brainstormResult.violations.join(", ")}`;
-            prompt += `\n\n---\n\n## ⚠ 脑暴完整性校验\n${brainstormEvidence}`;
-        }
-        else {
-            workflowGovernanceFindings.push({
-                severity: "info",
-                rule: "brainstorm_completeness",
-                message: "脑暴完整性校验通过: 候选方案已就绪",
-            });
-        }
-    }
-    const expandTools = getExpandContractTools();
-    if (contractNotes.length > 0) {
-        prompt += "\n\n---\n\n## 输入材料契约检查\n" + contractNotes.join("\n");
-    }
-    // 追加配置优先级警告 to prompt
-    if (configWarnings.length > 0) {
-        prompt += "\n\n---\n\n## 配置优先级警告\n" + configWarnings.join("\n");
-    }
-    if (selectedProjectKnowledge.length > 0) {
-        const projectRuleLines = projectKnowledgeSelection.selected.map((decision) => `- ${decision.asset.name} (${decision.asset.rel_path}, ${decision.enforcement}, ${decision.asset.identity})\n  选中原因: ${decision.reason_zh}\n  复验命令: ${decision.user_visible.verification_command ?? "soloforge audit-project-knowledge"}`);
-        prompt += "\n\n---\n\n## 用户项目规则\n" + projectRuleLines.join("\n");
-        prompt += "\n> 以上规则来自当前项目 .soloforge/knowledge。hard_rule 必须满足；injectable 用于当前任务执行；audit_only/index_only 不进入 prompt 注入。";
-    }
-    // 核心工程执行原则注入
-    const coreTaskLevel = getTaskLevel(routeDecision?.route, routeDecision?.execution_shape);
-    const coreRequiredPrinciples = getRequiredPrinciples(coreTaskLevel);
-    if (coreRequiredPrinciples.length > 0) {
-        const principleLines = listCorePrinciples()
-            .filter((p) => getEnforcementLevel(p.id, coreTaskLevel) !== "not_applicable")
-            .map((p) => {
-            const level = getEnforcementLevel(p.id, coreTaskLevel);
-            const tag = level === "required" ? "[REQUIRED]" : "[advisory]";
-            return `- **${tag} ${p.name} (${p.chinese_name})**: ${p.rule}`;
-        });
-        prompt += "\n\n---\n\n## 核心工程执行原则 (任务等级: " + coreTaskLevel + ")\n" + principleLines.join("\n");
-        prompt += "\n\n> 以上原则中 [REQUIRED] 为硬性要求，违反将导致验证失败。[advisory] 为建议性要求。";
-    }
-    // 注入 prompt_injection_plan 段落 into prompt (unified for all routes)
-    if (promptInjectionPlan) {
-        const rendered = renderPromptInjectionPlan(promptInjectionPlan);
-        if (rendered) {
-            prompt += "\n\n" + rendered;
-        }
-    }
-    // 用真实引用丰富产物 before returning
-    if (outputArtifactRecord) {
-        // 绑定知识引用 from matched knowledge entries
-        outputArtifactRecord.knowledge_refs = filteredEntries.map((e) => e.id);
-        // 绑定摄取证据引用
-        if (ingestionEvidences && ingestionEvidences.length > 0) {
-            outputArtifactRecord.evidence_refs = ingestionEvidences
-                .filter((ie) => ie.access_mode !== "forbidden")
-                .map((ie) => `ingestion:${ie.material_id}:${ie.source_ref}`);
-        }
-        // 解析 workflow_id from workflow contract
-        if (workflowContract) {
-            outputArtifactRecord.workflow_id = workflowContract.id;
-        }
-    }
-    debugLog("意图膨胀: 扩展完成，degraded=%s, 匹配知识=%d 条", degraded ? "true" : "false", filteredEntries.length);
-    return {
-        task_id: "",
-        prompt,
-        scope,
-        scope_resolution: scope.resolution,
-        acceptance,
-        matched_patterns: filteredEntries.map((e) => e.name),
-        matched_knowledge: filteredEntries.map((e) => e.name),
-        injection_report: injectionReport,
-        project_knowledge: {
-            total: projectKnowledgeReport.total,
-            hard_fail_count: projectKnowledgeReport.hard_fail_count,
-            warning_count: projectKnowledgeReport.warning_count,
-            selected: selectedProjectKnowledge.map((asset) => ({
-                id: asset.id,
-                name: asset.name,
-                rel_path: asset.rel_path,
-                consumption: asset.consumption,
-                identity: asset.identity,
-            })),
-            selection_decisions: projectKnowledgeSelection.decisions.map((decision) => ({
-                id: decision.asset.id,
-                name: decision.asset.name,
-                rel_path: decision.asset.rel_path,
-                status: decision.status,
-                enforcement: decision.enforcement,
-                reason_zh: decision.reason_zh,
-                matched_signals: decision.matched_signals,
-                excluded_reasons: decision.excluded_reasons,
-                verification_command: decision.user_visible.verification_command,
-            })),
-            findings: projectKnowledgeFindings,
-        },
-        is_legacy_code: isLegacyCode,
-        legacy_conventions: legacyConventions.length > 0 ? legacyConventions : undefined,
-        degraded,
-        contract,
-        uncertainty_triggers: uncertaintyTriggers.length > 0 ? uncertaintyTriggers : undefined,
-        circuit_breaker: circuitBreakerOutput,
-        next_allowed_tools: expandTools.next_allowed_tools,
-        forbidden_tools: expandTools.forbidden_tools,
-        input_materials: inputMaterials,
-        ingestion_evidences: ingestionEvidences,
-        prompt_injection_plan: promptInjectionPlan,
-        output_artifact_record: outputArtifactRecord,
-        sensitivity_labels: privacyLabels.length > 0 ? privacyLabels : undefined,
-        redaction_records: privacyRedactions.length > 0 ? privacyRedactions : undefined,
-        privacy_findings: privacyFindings.length > 0 ? privacyFindings : undefined,
-        config_resolution_reports: configResolution.reports.length > 0 ? configResolution.reports : undefined,
-        workflow_trace: 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,
-            state_transition_target: techDecisionRequiresManual || brainstormRequiresClarification
-                ? "manual_required"
-                : (workflowContract.allowed_state_transitions[0] ?? "none"),
-            checked_items: buildCheckedItems(workflowContract, routeDecision),
-        } : undefined,
-    };
-}
-function buildCheckedItems(contract, routeDecision) {
-    const items = [
-        "workflow_resolved",
-        "mutation_allowed_checked",
-        "prompt_template_checked",
-        "required_mechanisms_declared",
-    ];
-    if (routeDecision && !routeDecision.mutation_allowed) {
-        items.push("read_only_scope_checked");
-    }
-    return items;
-}
-function mergeKnowledgeEntries(entries) {
-    const seen = new Set();
-    const merged = [];
-    for (const entry of entries) {
-        if (seen.has(entry.id))
-            continue;
-        seen.add(entry.id);
-        merged.push(entry);
-    }
-    return merged;
-}
-function knowledgeTypeForProjectAsset(asset) {
-    if (asset.consumption === "acceptance_template")
-        return "acceptance_template";
-    if (asset.consumption === "review_rule")
-        return "review_rule";
-    if (asset.consumption === "hard_rule")
-        return "governance_rule";
-    if (asset.rel_path.includes("procedures/"))
-        return "procedure";
-    if (asset.rel_path.includes("domain/"))
-        return "domain";
-    return "governance_rule";
-}
-function readProjectKnowledgeBody(asset) {
-    try {
-        const raw = fss.readFileSync(asset.abs_path, "utf-8");
-        if (/\.md$/i.test(asset.abs_path))
-            return matter(raw).content.trim();
-        return raw.trim();
-    }
-    catch {
-        return "";
-    }
-}
-function projectKnowledgeAssetToEntry(asset) {
-    const body = readProjectKnowledgeBody(asset);
-    if (!body)
-        return null;
-    const now = new Date().toISOString();
-    return {
-        id: `project:${asset.id}`,
-        file_path: asset.abs_path,
-        name: asset.name,
-        type: knowledgeTypeForProjectAsset(asset),
-        when: [...asset.routes, ...asset.primary_triggers, ...asset.domains].join(", "),
-        body,
-        scope: ["shared"],
-        products: ["*"],
-        tech_stack: asset.tech_stack.join(","),
-        created_at: now,
-        updated_at: now,
-        usage_count: 0,
-        confidence: asset.hard_rule ? 1 : 0.85,
-        status: "active",
-    };
-}
-/**
- * 缺少必需输入时返回澄清结果（不生成执行 prompt）。
- */
-function buildClarificationResult(intent, routeDecision, config, workflowContract, safeIntent, safeGoal) {
-    const clarification = routeDecision.missing_required_inputs.join("\n");
-    return {
-        task_id: "",
-        prompt: `## 澄清请求\n\n任务: ${safeIntent}\n\n缺少必需输入:\n${clarification}\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: [],
-        },
-        workflow_trace: 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",
-        } : undefined,
-    };
-}
-/**
- * 根据 pipeline_hint 名称加载内置流程模板。
- */
-function loadBuiltinByPipeline(pipelineName) {
-    const entries = [];
-    // pipeline_hint 格式: source-prototype-to-delivery:step-1 → 找源码原型交付流程.md
-    const nameToTemplate = {
-        "source-prototype-to-delivery": "源码原型交付流程.md",
-    };
-    const templateFile = nameToTemplate[pipelineName];
-    if (templateFile) {
-        const entry = loadBuiltinTemplate(templateFile, "procedures");
-        if (entry)
-            entries.push(entry);
-    }
-    return entries;
-}
-/** 包内模板知识库根目录 */
-function getTemplatesRoot() {
-    const thisDir = path.dirname(fileURLToPath(import.meta.url));
-    return path.resolve(thisDir, "..", "..", "templates");
-}
-/**
- * 当知识索引中没有找到内置模板时，从 templates/ 加载为 KnowledgeEntry。
- * 只加载指定名称的文件。
- */
-function loadBuiltinTemplate(fileName, subDir) {
-    const templatesRoot = getTemplatesRoot();
-    const safeName = path.basename(fileName); // basename 防止路径穿越
-    const filePath = path.join(templatesRoot, subDir, safeName);
-    try {
-        if (!fss.existsSync(filePath))
-            return null;
-        // 合同门禁: getContractDecision 统一裁决
-        const relPath = `templates/${subDir}/${safeName}`;
-        const decision = getContractDecision(relPath);
-        if (decision.decision !== "allowed") {
-            debugLog("意图扩展: 内置模板被合同门禁阻断 —", relPath, decision.decision);
-            return null;
-        }
-        const raw = fss.readFileSync(filePath, "utf-8");
-        const fmVis = parseFrontmatterVisibility(raw);
-        if (fmVis === "soloforge_internal" || fmVis === "adapter_runtime_only" || fmVis === "scaffold_only") {
-            debugLog("意图扩展: 内置模板 frontmatter 可见性阻断 —", relPath, fmVis);
-            return null;
-        }
-        const { data, content: body } = matter(raw);
-        const name = data.name || path.basename(fileName, ".md");
-        const type = data.type || inferTypeFromSubDir(subDir);
-        return {
-            id: `builtin-${name}`,
-            file_path: filePath,
-            name,
-            type,
-            when: data.when || "",
-            body,
-            scope: data.scope || ["shared"],
-            products: data.products || ["*"],
-            tech_stack: data.tech_stack,
-            created_at: data.created_at || new Date().toISOString().split("T")[0],
-            updated_at: data.updated_at || new Date().toISOString().split("T")[0],
-            usage_count: 0,
-            confidence: data.confidence ?? 1.0,
-            status: "active",
-        };
-    }
-    catch (e) {
-        debugLog("意图扩展: 内置模板加载失败 —", e);
-        return null;
-    }
-}
-function inferTypeFromSubDir(subDir) {
-    if (subDir.includes("procedures"))
-        return "pipeline_procedure";
-    if (subDir.includes("acceptance_templates"))
-        return "acceptance_template";
-    if (subDir.includes("review_rules"))
-        return "review_rule";
-    if (subDir.includes("domain"))
-        return "domain";
-    return "pattern";
-}
-/**
- * 路由驱动的知识匹配。
- * 优先使用 pipeline_hint、output_artifact.kind、route + execution_shape，
- * 降级为同类型通用产物 prompt，不退化成编码 prompt。
- */
-function queryKnowledgeForRoute(knowledgeIndex, intent, scopeFilters, config, routeDecision, limit) {
-    if (!routeDecision) {
-        // 无 route_decision 时回退到旧逻辑（不传 route，不强制路由匹配）
-        return knowledgeIndex.query({
-            scope: scopeFilters,
-            products: [config.product_profile],
-            keywords: extractKeywords(intent),
-            limit,
-        });
-    }
-    const currentRoute = routeDecision.route;
-    const seen = new Set();
-    const results = [];
-    function addEntries(entries) {
-        for (const e of entries) {
-            if (!seen.has(e.id)) {
-                seen.add(e.id);
-                results.push(e);
-            }
-        }
-    }
-    // 优先级 1: pipeline_hint 精确匹配（不提前 return）
-    if (routeDecision.pipeline_hint) {
-        const pipelineName = routeDecision.pipeline_hint.split(":")[0];
-        const pipelineResults = knowledgeIndex.query({
-            scope: scopeFilters,
-            products: [config.product_profile],
-            type: "pipeline_procedure",
-            route: currentRoute,
-            keywords: extractKeywords(pipelineName),
-            limit: 3,
-        });
-        addEntries(pipelineResults);
-        // 内置模板回退: pipeline_hint 名称未命中时从 templates/ 加载
-        if (pipelineResults.length === 0) {
-            const builtin = loadBuiltinByPipeline(pipelineName);
-            if (builtin)
-                addEntries(builtin);
-        }
-    }
-    // 优先级 2: output_artifact.kind 映射 acceptance_template（不提前 return）
-    if (routeDecision.output_artifact?.kind) {
-        // 先按 template 文件名精确匹配
-        const templateName = routeDecision.output_artifact.template;
-        if (templateName) {
-            const allTemplates = knowledgeIndex.query({
-                scope: scopeFilters,
-                products: [config.product_profile],
-                type: "acceptance_template",
-                route: currentRoute,
-                keywords: [],
-                limit: 100,
-            });
-            const exactMatch = allTemplates.find((e) => matchesTemplateByName(e, templateName));
-            if (exactMatch)
-                addEntries([exactMatch]);
-            // 内置模板回退: template 名称未命中时从 templates/artifacts/shared/ 加载
-            if (!exactMatch) {
-                const builtinTemplate = loadBuiltinTemplate(templateName, "artifacts/shared");
-                if (builtinTemplate)
-                    addEntries([builtinTemplate]);
-            }
-        }
-        // 再按 artifact kind 关键词匹配
-        const artifactKeywords = {
-            prototype_spec: ["原型", "prototype", "原型说明"],
-            api_spec: ["接口", "API", "接口设计"],
-            design_doc: ["设计", "架构", "详细设计"],
-            test_plan: ["测试", "测试计划"],
-            migration_plan: ["迁移", "迁移方案"],
-            review_report: ["审查", "review"],
-            task_breakdown: ["任务", "拆解"],
-            root_cause: ["根因", "分析"],
-            incident_review: ["故障", "复盘"],
-        };
-        const artifactKws = artifactKeywords[routeDecision.output_artifact.kind] ?? [];
-        if (artifactKws.length > 0) {
-            const templateResults = knowledgeIndex.query({
-                scope: scopeFilters,
-                products: [config.product_profile],
-                type: "acceptance_template",
-                keywords: artifactKws,
-                limit: 2,
-            });
-            addEntries(templateResults);
-        }
-    }
-    // 优先级 3: intent keywords 补充（填满 limit）
-    if (results.length < limit) {
-        const keywordResults = knowledgeIndex.query({
-            scope: scopeFilters,
-            products: [config.product_profile],
-            route: currentRoute,
-            keywords: extractKeywords(intent),
-            limit: limit,
-        });
-        addEntries(keywordResults);
-    }
-    // 合同门禁: 对 templates/ 相对路径统一裁决，过滤 denied 和 unregistered
-    const filtered = results.filter((entry) => {
-        if (!entry.file_path)
-            return true;
-        // 只对 templates/ 开头的相对路径执行合同裁决
-        const normalized = entry.file_path.replace(/\\/g, "/");
-        if (!normalized.startsWith("templates/"))
-            return true;
-        const decision = getContractDecision(normalized);
-        if (decision.decision !== "allowed")
-            return false;
-        // 技术栈过滤: 合同声明了 applicable_tech_stack 时必须匹配当前项目技术栈
-        if (decision.contract && decision.contract.applicable_tech_stack.length > 0) {
-            const currentStack = [
-                config.tech_stack?.backend?.framework,
-                config.tech_stack?.frontend?.framework,
-                config.tech_stack?.backend?.lang,
-                config.tech_stack?.frontend?.lang,
-            ].filter(Boolean);
-            const hasMatch = decision.contract.applicable_tech_stack.some((t) => currentStack.some((s) => s.toLowerCase().includes(t.toLowerCase()) || t.toLowerCase().includes(s.toLowerCase())));
-            if (!hasMatch)
-                return false;
-        }
-        return true;
-    });
-    return filtered.slice(0, limit);
-}
-/**
- * 根据执行形态构建模板数据。
- */
-function buildTemplateData(intent, techStack, config, classification, scope, matchedEntries, legacyConventions, isLegacyCode, acceptance, degraded, routeDecision) {
-    const base = {
-        intent,
-        tech_stack: techStack,
-        product_profile: config.product_profile,
-        affected_repos: getAffectedRepos(classification).join(", "),
-        matched_knowledge: matchedEntries.map((e) => ({
-            name: e.name,
-            content: e.body || e.when,
-        })),
-        relevant_files: scope.allowed_paths.slice(0, 10).map((p) => ({ path: p, reason: "scope 允许路径" })),
-        is_legacy_code: isLegacyCode,
-        legacy_conventions: legacyConventions,
-        scope: {
-            allowed_paths: scope.allowed_paths.join(", "),
-            new_files_allowed: scope.new_files_allowed,
-            new_file_patterns: scope.new_file_patterns?.join(", "),
-        },
-        acceptance,
-        degraded,
-    };
-    if (routeDecision) {
-        base.output_artifact = routeDecision.output_artifact;
-        base.input_materials = routeDecision.input_materials;
-        // 根据 ingestion_status 构建 input_material_contract_notes
-        const contractTemplateNotes = [];
-        for (const m of routeDecision.input_materials) {
-            if (m.ingestion_status === "forbidden")
-                contractTemplateNotes.push("FORBIDDEN: " + (m.path ?? "") + " 禁止读取");
-            else if (m.ingestion_status === "requires_confirmation")
-                contractTemplateNotes.push("REQUIRES_CONFIRMATION: " + (m.path ?? "") + " 需确认");
-        }
-        base.input_material_contract_notes = contractTemplateNotes.length > 0 ? contractTemplateNotes : undefined;
-        base.pipeline_hint = routeDecision.pipeline_hint;
-    }
-    return base;
-}
-/**
- * 按模板文件名精确匹配知识条目。
- * 匹配 entry.name、file basename (with/without extension)。
- */
-function matchesTemplateByName(entry, templateName) {
-    const requested = templateName.trim();
-    const fileName = path.basename(entry.file_path);
-    const fileStem = path.basename(entry.file_path, path.extname(entry.file_path));
-    return [entry.name, fileName, fileStem].some((c) => c.trim() === requested);
-}
-/**
- * 注入计划阶段上下文（P2 + P3）
- */
-function injectPlanContext(prompt, planContext, knowledgeIndex) {
-    const { current_step, previous_outputs } = planContext;
-    const sections = [];
-    const prevEntries = Object.entries(previous_outputs);
-    if (prevEntries.length > 0) {
-        sections.push("## 前序阶段产出");
-        for (const [stepId, content] of prevEntries) {
-            if (content) {
-                sections.push(`### ${stepId}\n${content.slice(0, 3000)}`);
-            }
-        }
-    }
-    if (current_step.output_template) {
-        const templateEntries = knowledgeIndex.query({
-            type: "acceptance_template",
-            keywords: [],
-        });
-        const matched = templateEntries.find((e) => matchesOutputTemplate(e, current_step.output_template));
-        if (matched?.body) {
-            sections.push(`## 输出格式参考（模板: ${current_step.output_template}）\n${matched.body}`);
-        }
-    }
-    if (current_step.output_path) {
-        sections.push(`## 产出保存\n将本阶段产出写入: ${current_step.output_path}`);
-    }
-    if (current_step.suggested_tools && current_step.suggested_tools.length > 0) {
-        sections.push(`## 建议工具（可选）\n${current_step.suggested_tools.map((t) => `- ${t}`).join("\n")}`);
-    }
-    if (sections.length === 0)
-        return prompt;
-    return `${prompt}\n\n---\n\n## 当前计划阶段\n正在执行: **${current_step.title}**\n${current_step.description}\n\n${sections.join("\n\n")}`;
-}
-function matchesOutputTemplate(entry, outputTemplate) {
-    const requested = normalizeTemplateName(outputTemplate);
-    const fileName = path.basename(entry.file_path);
-    const fileStem = path.basename(entry.file_path, path.extname(entry.file_path));
-    return [
-        entry.name,
-        fileName,
-        fileStem,
-    ].some((candidate) => normalizeTemplateName(candidate) === requested);
-}
-function normalizeTemplateName(name) {
-    return name.trim();
-}
-function extractKeywords(intent) {
-    return intent
-        .replace(/[的了吗呢把被在从对和与或是]/g, " ")
-        .split(/[\s,，、；;]+/)
-        .filter((w) => w.length >= 2);
-}
-/**
- * 读取分类结果中的受影响仓库。
- * 旧任务上下文或外部适配器可能缺少 affected_repos；这里统一降级为空数组，避免 sf_expand 卡死。
- */
-function getAffectedRepos(classification) {
-    return Array.isArray(classification?.affected_repos)
-        ? classification.affected_repos.filter((repo) => typeof repo === "string" && repo.length > 0)
-        : [];
-}
-const BACKEND_KEYWORD_RE = /后端|backend|server|api|java|spring|数据库|sql|接口实现|服务端|controller|service|mapper|repository|dao|entity|dto/i;
-const FRONTEND_KEYWORD_RE = /前端|frontend|client|react|vue|页面|组件|component|ui|css|html|浏览器|前端路由|route|store|hook|props/i;
-const GENERIC_DEV_RE = /实现|开发|编码|修复|重构|新增|添加|完成|写|修改|变更|改|功能|feature|fix|refactor|implement/i;
-/**
- * 当 affected_repos 为空时，从意图文本和技术栈配置推断 scope。
- *
- * 原则：
- * 1. 意图中含明确前端/后端关键词 → 加入对应 scope
- * 2. 意图含通用开发关键词 + 项目配了对应技术栈 → 加入对应 scope
- * 3. 都推断不出来 → 返回空数组（不限制 scope，由关键词/路由/预算控制精度）
- */
-export function inferScopeFromIntentAndConfig(intent, classification, config) {
-    const text = `${intent} ${classification?.task_type ?? ""}`.toLowerCase();
-    const scopes = ["shared"];
-    // 1. 显式关键词匹配
-    if (BACKEND_KEYWORD_RE.test(text)) {
-        scopes.push("backend");
-    }
-    if (FRONTEND_KEYWORD_RE.test(text)) {
-        scopes.push("frontend");
-    }
-    // 2. 隐式推断：通用开发意图 + 有技术栈配置
-    if (!scopes.includes("backend") && !scopes.includes("frontend")) {
-        const hasBackend = config.tech_stack?.backend?.framework && config.tech_stack.backend.framework !== "unknown";
-        const hasFrontend = config.tech_stack?.frontend?.framework && config.tech_stack.frontend.framework !== "unknown";
-        if (GENERIC_DEV_RE.test(text)) {
-            if (hasBackend)
-                scopes.push("backend");
-            if (hasFrontend)
-                scopes.push("frontend");
-        }
-    }
-    // 3. 只有 shared 且无技术栈 → 不限制 scope
-    if (scopes.length === 1 && scopes[0] === "shared"
-        && (!config.tech_stack?.backend?.framework || config.tech_stack.backend.framework === "unknown")
-        && (!config.tech_stack?.frontend?.framework || config.tech_stack.frontend.framework === "unknown")) {
-        return [];
-    }
-    return [...new Set(scopes)];
-}
-/**
- * 解析 scope: 非代码任务使用简化 scope。
- */
-function resolveScope(config, classification, degraded, routeDecision) {
-    return resolveTaskScope({
-        projectPath: config._projectPath ?? process.cwd(),
-        config,
-        classification,
-        degraded,
-        routeDecision,
-    });
-}
-/**
- * 生成验收标准: 根据执行形态选择不同验收。
- */
-function generateAcceptance(intent, classification, matchedEntries, _config, degraded, routeDecision) {
-    const automated = [];
-    const manual = [];
-    // 非代码任务: 产物验收而非编译/测试
-    if (routeDecision && routeDecision.execution_shape !== "code_execution") {
-        if (routeDecision.output_artifact?.path) {
-            automated.push({
-                id: "A-artifact-exists",
-                description: `产物文件已生成: ${routeDecision.output_artifact.path}`,
-                type: "automated",
-            });
-        }
-        automated.push({
-            id: "A-completeness",
-            description: "产物结构完整，无空白占位",
-            type: "automated",
-        });
-        manual.push({
-            id: "M-quality",
-            description: "产物质量满足可交接标准",
-            type: "manual",
-        });
-        // 从知识中解析验收项
-        for (const entry of matchedEntries) {
-            if (entry.body) {
-                const items = parseAcceptanceItems(entry.body);
-                automated.push(...items);
-            }
-        }
-        return { automated, manual };
-    }
-    // 代码修改任务: 原有逻辑
-    if (degraded) {
-        automated.push({
-            id: "A-build",
-            description: "编译通过，无类型错误",
-            type: "automated",
-        });
-        automated.push({
-            id: "A-test",
-            description: "测试通过",
-            type: "automated",
-        });
-        return { automated, manual };
-    }
-    automated.push({
-        id: "A-build",
-        description: "编译通过，无类型错误",
-        type: "automated",
-    });
-    for (const entry of matchedEntries) {
-        if (entry.body) {
-            const items = parseAcceptanceItems(entry.body);
-            automated.push(...items);
-        }
-    }
-    if (classification.task_type === "feature") {
-        manual.push({
-            id: "M-ux",
-            description: "新增功能的交互是否符合设计规范",
-            type: "manual",
-        });
-    }
-    if (classification.task_type === "bugfix") {
-        manual.push({
-            id: "M-root",
-            description: "修复是否针对了根本原因而非症状",
-            type: "manual",
-        });
-    }
-    return { automated, manual };
-}
-function parseAcceptanceItems(body) {
-    const items = [];
-    if (!body.includes("## 验收项"))
-        return items;
-    const lines = body.split("\n");
-    let inSection = false;
-    for (const line of lines) {
-        if (line.startsWith("## 验收项")) {
-            inSection = true;
-            continue;
-        }
-        if (inSection && line.startsWith("## "))
-            break;
-        if (inSection) {
-            const match = line.match(/- \[([A-Z]+-\d+)\]\s*(.+?)(?:\s*\(check:\s*(.+)\))?$/);
-            if (match) {
-                const item = { id: match[1], description: match[2].trim(), type: "automated" };
-                if (match[3])
-                    item.check_command = match[3].trim();
-                items.push(item);
-            }
-        }
-    }
-    return items;
-}
-function buildTechStackLabel(config) {
-    const parts = [];
-    if (config.tech_stack.backend.framework) {
-        parts.push(`${config.tech_stack.backend.framework} ${config.tech_stack.backend.version}`);
-    }
-    if (config.tech_stack.frontend.framework) {
-        parts.push(`${config.tech_stack.frontend.framework} ${config.tech_stack.frontend.version}`);
-    }
-    return parts.join(" + ") || "未知";
-}
-// ── 能力 1: 执行契约 ──
-function buildExecutionContract(intent, classification, scope, acceptance, routeDecision) {
-    const constraints = [];
-    const stopConditions = [];
-    // 路由级约束优先（如 no_mutation）
-    if (routeDecision?.constraints?.length) {
-        constraints.push(...routeDecision.constraints);
-    }
-    if (classification.risk === "high") {
-        constraints.push("高风险任务：每个变更文件必须有明确来源（任务卡/缺陷/设计锚点）");
-        constraints.push("禁止顺手重构或范围外变更");
-        constraints.push("修复循环上限 3 轮，超过必须升级");
-        stopConditions.push("修复循环超过 3 轮");
-        stopConditions.push("变更文件超出 scope.allowed_paths 范围");
-    }
-    else if (classification.risk === "medium") {
-        constraints.push("中等风险：核心逻辑变更需有回归测试");
-        stopConditions.push("编译失败 2 次以上");
-    }
-    else {
-        constraints.push("低风险：标准变更流程");
-    }
-    if (classification.complexity === "high") {
-        constraints.push("高复杂度：必须先定位根因再编码，禁止试错");
-        constraints.push("一次只修一个问题，禁止跨层大重构");
-    }
-    return {
-        goal: intent.slice(0, 200),
-        scope: scope.allowed_paths,
-        constraints,
-        verification: acceptance.automated.map((a) => `[${a.id}] ${a.description}`),
-        stop_conditions: stopConditions,
-    };
-}
-// ── 能力 4: 不确定性协议 ──
-const UNCERTAINTY_PATTERNS = [
-    {
-        pattern: /(?:表结构|DDL|加字段|删字段|改字段|索引|migration)/i,
-        trigger_type: "ddl_change",
-        description: "涉及数据库结构变更，可能影响现有数据",
-        options: [
-            { label: "向前兼容变更", tradeoff: "需额外兼容逻辑，但可平滑迁移" },
-            { label: "破坏性变更（需迁移脚本）", tradeoff: "直接但需停机或分步迁移" },
-        ],
-        recommendation: "优先向前兼容方案",
-    },
-    {
-        pattern: /(?:权限|角色|授权|鉴权|permission|auth)/i,
-        trigger_type: "permission_change",
-        description: "涉及权限/角色变更，影响用户访问控制",
-        options: [
-            { label: "收紧权限", tradeoff: "安全但可能阻断合法用户" },
-            { label: "放宽权限", tradeoff: "便利但增加安全风险" },
-        ],
-        recommendation: "默认收紧，逐案放开",
-    },
-    {
-        pattern: /(?:金额|价格|费用|支付|退款|计算|结算)/i,
-        trigger_type: "amount_logic",
-        description: "涉及金额计算逻辑，需要精确性验证",
-        options: [
-            { label: "复用现有计算逻辑", tradeoff: "安全但可能不适用新场景" },
-            { label: "新建计算逻辑", tradeoff: "灵活但需全面测试（含边界值/精度/并发）" },
-        ],
-        recommendation: "复用现有逻辑优先",
-    },
-    {
-        pattern: /(?:跨系统|外部接口|第三方|回调|同步|推送)/i,
-        trigger_type: "cross_system",
-        description: "涉及跨系统交互，需要幂等和补偿机制",
-        options: [
-            { label: "同步调用", tradeoff: "简单但强耦合" },
-            { label: "异步+补偿", tradeoff: "解耦但复杂度高" },
-        ],
-        recommendation: "异步+补偿优先",
-    },
-    {
-        pattern: /(?:状态机|状态流转|审批|审核|工作流)/i,
-        trigger_type: "state_transition",
-        description: "涉及状态流转逻辑，需要完整的守卫条件",
-        options: [
-            { label: "扩展现有状态机", tradeoff: "一致但需理解现有流转" },
-            { label: "新建独立流程", tradeoff: "独立但可能重复" },
-        ],
-        recommendation: "扩展现有状态机优先",
-    },
-    {
-        pattern: /(?:删除|清理|归档|批量操作)/i,
-        trigger_type: "destructive_operation",
-        description: "涉及破坏性操作，需要可恢复机制",
-        options: [
-            { label: "软删除（可恢复）", tradeoff: "安全但占存储" },
-            { label: "硬删除+备份", tradeoff: "干净但恢复成本高" },
-        ],
-        recommendation: "优先软删除",
-    },
-    {
-        pattern: /(?:并发|锁|竞争|原子|分布式事务)/i,
-        trigger_type: "concurrency",
-        description: "涉及并发控制，需要确定并发策略",
-        options: [
-            { label: "乐观锁", tradeoff: "高性能但需冲突重试" },
-            { label: "悲观锁", tradeoff: "安全但降低吞吐" },
-        ],
-        recommendation: "乐观锁优先",
-    },
-    {
-        pattern: /(?:敏感信息|加密|解密|脱敏|密码|token)/i,
-        trigger_type: "sensitive_data",
-        description: "涉及敏感数据处理，需要安全策略",
-        options: [
-            { label: "传输+存储加密", tradeoff: "安全但性能有开销" },
-            { label: "仅传输加密", tradeoff: "轻量但存储风险" },
-        ],
-        recommendation: "传输+存储均加密",
-    },
-];
-function buildUncertaintyTriggers(classification, intent) {
-    const triggers = [];
-    for (const pattern of UNCERTAINTY_PATTERNS) {
-        if (pattern.pattern.test(intent)) {
-            triggers.push({
-                trigger_type: pattern.trigger_type,
-                description: pattern.description,
-                options: pattern.options,
-                recommendation: pattern.recommendation,
-            });
-        }
-    }
-    if (classification.risk === "high" && classification.ambiguity === "high") {
-        triggers.push({
-            trigger_type: "high_risk_high_ambiguity",
-            description: "高风险 + 高歧义任务，意图可能存在多种解读",
-            options: [
-                { label: "按最保守方案执行", tradeoff: "安全但可能不满足全部需求" },
-                { label: "先澄清再执行", tradeoff: "准确但增加前置时间" },
-            ],
-            recommendation: "先澄清再执行",
-        });
-    }
-    return triggers;
-}
-const CONFIDENCE_THRESHOLD = 0.95;
-/**
- * 意图熔断器 — 评估意图理解置信度，低于阈值时触发熔断并生成头脑风暴辅助决策。
- * @param params - 熔断器参数，包含意图、分类结果、匹配知识条目和降级标记
- * @returns 熔断结果，包含是否触发、置信度、原因和头脑风暴输出
- */
-export function checkCircuitBreaker(params) {
-    const { intent, classification, matchedEntries, degraded } = params;
-    let confidence = 1.0;
-    if (degraded || matchedEntries.length === 0) {
-        confidence -= 0.35;
-    }
-    else if (matchedEntries.length < 2) {
-        confidence -= 0.15;
-    }
-    if (classification.ambiguity === "high") {
-        confidence -= 0.35;
-    }
-    else if (classification.ambiguity === "medium") {
-        confidence -= 0.15;
-    }
-    const keywords = extractKeywords(intent);
-    if (keywords.length < 2) {
-        confidence -= 0.20;
-    }
-    else if (keywords.length < 3) {
-        confidence -= 0.10;
-    }
-    // degraded 已在上方 L1826 扣除 -0.35，此处不重复扣分
-    confidence = Math.max(0, Math.min(1, confidence));
-    if (confidence < CONFIDENCE_THRESHOLD) {
-        return {
-            tripped: true,
-            confidence,
-            reason: `意图置信度 ${confidence.toFixed(2)} 低于阈值 ${CONFIDENCE_THRESHOLD}`,
-            brainstorm: generateBrainstorm(intent, classification, matchedEntries),
-        };
-    }
-    return { tripped: false, confidence };
-}
-function generateBrainstorm(intent, classification, _matchedEntries) {
-    const taskLabel = classification.task_type === "feature" ? "新功能" :
-        classification.task_type === "bugfix" ? "缺陷修复" :
-            classification.task_type === "refactor" ? "重构" : "任务";
-    return {
-        blind_spots: [
-            `【${taskLabel}】是否存在未声明的隐性依赖？`,
-            `执行后是否有副作用波及非目标模块？`,
-            `极端场景（空数据/并发/超量）是否有防护？`,
-        ],
-        evolution_tracks: {
-            minimal: "极简验证路径: 最小可运行实现 + 核心断言验证",
-            industrial: "工业级标准路径: 完整实现 + 边界测试 + 异常处理 + 日志埋点",
-            radical: "激进重构路径: 重新审视现有架构，考虑是否需结构级调整",
-        },
-        decision_questions: [
-            {
-                question: "优先交付速度还是健壮性？",
-                option_a: "极简路径 — 快速验证核心逻辑",
-                option_b: "工业级路径 — 含完整边界和异常处理",
-            },
-            {
-                question: "实现范围是否需要扩大？",
-                option_a: "限定当前声明范围，后续迭代补充",
-                option_b: "现在就处理关联模块，避免技术债积累",
-            },
-        ],
-    };
-}
-// ── 执行分层 ──
-//# sourceMappingURL=intent_expander.js.map