soloforge 1.1.2 → 1.1.30

package/dist/engine/pipeline/intent_router.js

@@ -0,0 +1,628 @@
+/**
+ * Intent Router — 意图路由器
+ *
+ * 根据用户意图文本确定语义通道 (route) 和执行形态 (execution_shape)。
+ * 零 AI 依赖，纯规则匹配。
+ *
+ * 替代旧的 task_type -> strategy 入口裁决链路。
+ * task_type 保留为辅助描述，不再单独决定是否进入 SoloForge。
+ *
+ * v2: 模块化拆分 — 路由判定由"信号提取 + 归一化 + 打分 + 冲突仲裁"完成，
+ *     不再依赖单条整句正则。
+ */
+import { getDefaultArtifactPath } from "../contracts/artifact_contract_registry.js";
+import { extractInputMaterials } from "./input_material_extractor.js";
+import { extractSignals } from "./intent_signal_extractor.js";
+import { scoreRoute } from "./intent_route_scorer.js";
+import { debugLog } from "../core/logger.js";
+debugLog("意图路由: 模块已加载");
+// ── 规则表（保留用于兼容层） ──
+/** 产物信号规则表 — 保留用于 detectArtifact 回退 */
+const ARTIFACT_SIGNALS = [
+    { pattern: /原型(?:说明|规约|描述|文档|报告|spec)|页面(?:说明|流程)|交互说明|prototype\s*spec/i, artifactKind: "prototype_spec", defaultName: "原型说明", template: "原型说明模版.md" },
+    { pattern: /接口(?:设计|清单|文档|spec|梳理)/, artifactKind: "api_spec", defaultName: "接口设计" },
+    { pattern: /(?:架构设计|详细设计)/, artifactKind: "design_doc", defaultName: "设计文档" },
+    { pattern: /测试计划/, artifactKind: "test_plan", defaultName: "测试计划" },
+    { pattern: /迁移(?:方案|评估|计划)/, artifactKind: "migration_plan", defaultName: "迁移方案" },
+    { pattern: /审查报告|代码审查/, artifactKind: "review_report", defaultName: "审查报告" },
+    { pattern: /(?:任务拆解|开发任务|拆.*任务)/, artifactKind: "task_breakdown", defaultName: "任务拆解" },
+    { pattern: /根因(?:分析|报告)/, artifactKind: "root_cause", defaultName: "根因分析" },
+    { pattern: /故障复盘|故障分析|复盘报告/, artifactKind: "incident_review", defaultName: "故障复盘" },
+    { pattern: /验收(?:清单|标准|checklist)/, artifactKind: "acceptance_checklist", defaultName: "验收清单" },
+    { pattern: /交互(?:规约|规范|说明)/, artifactKind: "interaction_spec", defaultName: "交互规约" },
+    { pattern: /领域(?:模型|图)/, artifactKind: "domain_model", defaultName: "领域模型" },
+    { pattern: /设计(?:文档|方案|说明)/, artifactKind: "design_doc", defaultName: "设计文档" },
+];
+/** 产物动词: 只有明确表达"产出/生成"意图的才算 */
+const ARTIFACT_VERBS = [
+    /生成/, /输出/, /抓取/, /提取/, /整理成/, /写成/,
+    /拆(?:成|分为)/,
+    /导出/, /输出为/, /保存为/, /产出到/, /做一份/, /写一份/, /生成一份/,
+    /做成?/, /形成/, /制作/, /从.*(?:生成|输出|提取|抓取)/,
+];
+/** 源码提取信号 */
+const SOURCE_EXTRACTION_PATTERNS = [
+    { pattern: /\.(zip|tar|gz|rar|7z|jar|war)/i, inputKind: "archive" },
+    { pattern: /源码包|压缩包|zip包|包文件/, inputKind: "archive" },
+    { pattern: /从\s*(?:源码包|压缩包|源码|代码包)/, inputKind: "archive" },
+    { pattern: /(?:logs?\/|\.log|日志(?:文件|目录|路径))/i, inputKind: "log" },
+    { pattern: /从报错日志/, inputKind: "log" },
+];
+/** 提取类动词 */
+const EXTRACTION_VERB_PATTERNS = [
+    /从\s*.*(?:提取|抽取)/,
+    /从\s*.*(?:生成|输出)/,
+    /(?:拿|用)\s*.*(?:做|生成|输出|提取|梳理|整理)/,
+    /读取\s*.*生成/,
+    /抓取.*(?:源码|源代码|原型)/,
+];
+/** 代码修改模式 */
+const CODE_CHANGE_PATTERNS = [
+    /修复/, /fix/i, /bug/i, /错误修复/, /异常处理/,
+    /报错.*(?:修复|解决|处理)/,
+    /新增(?:功能|接口|页面|模块|字段|按钮|服务|路由|组件|一个|一个后台)/,
+    /加(?:一个|个|上|载)\s*(?:接口|功能|模块|页面|字段|按钮|服务|路由|组件)/,
+    /加(?:一个|个)?\s*(?:导出|查询|校验|权限|配置|逻辑|规则|支持|特性)/,
+    /新增用户/, /新增一个/,
+    /重构/, /优化结构/, /实现/, /开发/, /补(?:单元)?测试/, /写测试/,
+    /删除/, /添加/, /修改/, /变更/, /移除/, /替换/,
+    /脚手架/, /scaffold/i, /新建模块/,
+];
+/** 分析类模式 */
+const ANALYSIS_PATTERNS = [
+    /分析.*(?:模块|系统|架构|性能|安全|风险|影响)/,
+    /评估.*(?:风险|可行性|影响|质量)/,
+    /梳理.*(?:模型|架构|流程|依赖)/,
+    /看看.*(?:风险|问题|有没有)/,
+    /影响(?:哪些|范围)/,
+    /为什么(?:容易|总是|频繁)/,
+    /(?:报错|错误).*(?:是什么意思|怎么回事)/,
+    /分析.*(?:报错|错误|异常).*(?:意思|原因|为什么)/,
+];
+/** 审查类模式 */
+const REVIEW_PATTERNS = [
+    /审查/, /\breview\b/i, /检查代码/, /代码质量/,
+];
+/** 验收/就绪检查模式：只表达检查，不表达施工 */
+const ACCEPTANCE_PATTERNS = [
+    /(?:检查|确认|验证).{0,12}(?:就绪|完成|通过|状态|条件|可用)/,
+    /(?:是否|有没有).{0,12}(?:就绪|完成|通过|满足|可用)/,
+    /(?:验收|acceptance|readiness|ready)/i,
+];
+const IMPLEMENTATION_VERB_PATTERN = /修复|实现|开发|新增|添加|修改|变更|重构|删除|移除|替换|补(?:单元)?测试|写测试|编码/;
+/** 规划类模式 */
+const PLANNING_PATTERNS = [
+    /拆(?:成|分为)\s*(?:任务|阶段|步骤|模块)/,
+    /(?:实施|开发|发布)\s*计划/,
+    /排期/, /里程碑/,
+];
+/** 全流程信号模式 */
+const FULL_PIPELINE_SIGNALS = [
+    /从.*(?:到|至).*(?:交付|完成|上线|部署)/,
+    /全流程/, /端到端/, /完整流水/, /整套完成/,
+    /从设计到交付/, /从头到尾/,
+];
+/** 操作类模式 */
+const OPERATION_PATTERNS = [
+    /运行测试/, /执行构建/, /\bbuild\b/i, /\bci\b/i, /\bcd\b/i,
+    /跑测试/,
+    /准备.*(?:发布前|检查清单)/,
+    /发布前(?:检查|准备)/,
+];
+/** 跳过类模式 */
+const SKIP_PATTERNS = [
+    { pattern: /^(你好|hi|hello|hey|嗨|早上好|下午好|晚上好)[\s!！.。]*$/i, reason: "greeting" },
+    { pattern: /^(今天|现在|几号|什么时候|什么时候了)/, reason: "casual_question" },
+    { pattern: /不用\s*(soloForge|solo\s*forge)/i, reason: "explicit_skip" },
+    { pattern: /直接(告诉|说|回答|给)/, reason: "explicit_skip" },
+];
+/** 通用知识问答模式 */
+const GENERAL_QA_PATTERNS = [
+    /(?:什么(?:是|叫|意思))\s*(?:REST|API|DTO|DAO|SOA|DDD|TDD|BDD|CI\/CD|SQL|NoSQL|TypeScript|JavaScript|Java|Python|Go|Docker|K8s|Kubernetes|React|Vue|Spring|Node|Nginx|Redis|MySQL|MongoDB|GraphQL|gRPC|WebSocket|OAuth|JWT|SOLID|DRY|KISS|YAGNI)/i,
+    /^(?:TypeScript|Java|Python|Go|React|Vue|Spring)\s*(?:union type|泛型|接口|类|装饰器|闭包|协程|通道|组件|生命周期|状态管理|中间件)/i,
+];
+/** 纯解释类模式 */
+const PURE_EXPLAIN_PATTERNS = [
+    /(?:解释|说明)(?:一下|下)?\s*(?:这个|这|这模块|这代码|这段|这个模块)\s*(?:怎么|如何|是什么|是什么意思|的|了)/,
+    /^(?:解释|说明)(?:一下|下)?\s/,
+    /^(?:这个|这)\s*(?:是|什么)/,
+];
+// ── 路径提取兼容函数（调用新模块） ──
+/**
+ * 从意图文本中提取输入路径。
+ * 保留原函数签名，内部委托给 input_material_extractor。
+ */
+function extractInputPaths(intent) {
+    const result = extractInputMaterials(intent);
+    return result.materials.map((m) => ({
+        kind: m.kind,
+        path: m.path,
+        ingestion_status: m.ingestion_status,
+    }));
+}
+// ── 产物检测（保留兼容） ──
+function detectArtifact(intent, taskId) {
+    const id = taskId || "01";
+    for (const signal of ARTIFACT_SIGNALS) {
+        if (signal.pattern.test(intent)) {
+            return {
+                kind: signal.artifactKind,
+                path: getDefaultArtifactPath(signal.artifactKind, id),
+                template: signal.template,
+                taskId,
+            };
+        }
+    }
+    if (/(?:文档|方案|规约|计划|清单|报告|说明文档)$/.test(intent)) {
+        const match = intent.match(/([一-龥]+(?:文档|方案|规约|计划|清单|报告|说明文档))$/);
+        const name = match ? match[1] : "产物";
+        return { kind: "unknown", path: `.soloforge/output/${id}/01-${name}.md`, taskId };
+    }
+    return undefined;
+}
+function hasArtifactVerb(intent) {
+    return ARTIFACT_VERBS.some((p) => p.test(intent));
+}
+function hasArtifactNoun(intent) {
+    return ARTIFACT_SIGNALS.some((s) => s.pattern.test(intent))
+        || /(?:文档|方案|规约|计划|清单|报告|说明文档)$/.test(intent);
+}
+function inferMissingInputs(intent, hasPath) {
+    if (hasPath)
+        return { materials: [], missing: [] };
+    const missing = [];
+    const materials = [];
+    if (/源码包|压缩包|zip包|包文件|源码/.test(intent)) {
+        materials.push({ kind: "archive", required: true });
+        missing.push("请提供源码包 zip 或已解压源码目录路径");
+    }
+    else if (/报错日志|日志/.test(intent)) {
+        materials.push({ kind: "log", required: true });
+        missing.push("请提供日志文件路径或内容");
+    }
+    else {
+        materials.push({ kind: "archive", required: true });
+        missing.push("请提供输入材料路径");
+    }
+    return { materials, missing };
+}
+/**
+ * 主路由函数 — 根据用户意图文本确定语义路由和执行形态。
+ * v2: 调用结构化信号提取 → 打分 → 冲突仲裁，不再依赖单条正则句子匹配。
+ *
+ * @param input - 路由输入参数，包含意图文本和可选的项目路径/任务 ID
+ * @returns 意图路由决策，包含路由类型、执行形态和置信度
+ */
+function logRouteHit(decision) {
+    debugLog(JSON.stringify({
+        sf_route_hit: true,
+        route: decision.route,
+        execution_shape: decision.execution_shape,
+        input_materials: decision.input_materials.map((m) => m.kind).join(",") || "none",
+        output_artifact: decision.output_artifact?.kind ?? "-",
+        prompt_template: selectPromptTemplate(decision),
+        confidence: decision.confidence,
+    }));
+}
+export function routeIntent(input) {
+    const decision = routeIntentCore(input);
+    logRouteHit(decision);
+    // 知识消费: router 消费 routes/primary_triggers/specificity
+    recordRouterConsumption(decision);
+    return decision;
+}
+/**
+ * 知识消费钩子: 记录 intent_router 的知识资产消费到统一 trace store。
+ */
+import { recordConsumptionTrace, getTracesByConsumer, CONSUMER_FIELD_CONTRACTS } from "../templates/consumption_trace_store.js";
+import { listConsumableAssetsByConsumer } from "../templates/consumable_asset_registry.js";
+function recordRouterConsumption(decision) {
+    const routerAssets = listConsumableAssetsByConsumer("intent_router")
+        .filter(a => a.consumption_mode === "required");
+    if (routerAssets.length === 0)
+        return;
+    for (const asset of routerAssets) {
+        recordConsumptionTrace({
+            consumer: "router",
+            asset_id: asset.id,
+            fields_consumed: CONSUMER_FIELD_CONTRACTS.router,
+            matched_reason: `route=${decision.route} shape=${decision.execution_shape} intent=${decision.workflow_intent || "none"} evidence=${(decision.evidence || []).slice(0, 3).join(",")}`,
+            task_id_or_route: decision.route,
+            consumed_at: new Date().toISOString(),
+        });
+    }
+}
+/** 获取路由消费追踪 */
+export function getRouterConsumptionTrace() {
+    return getTracesByConsumer("router").map(t => ({
+        route: t.task_id_or_route,
+        execution_shape: t.matched_reason.split("shape=")[1]?.split(" ")[0] || "",
+        consumed_triggers: t.fields_consumed,
+        consumed_at: t.consumed_at,
+    }));
+}
+function routeIntentCore(input) {
+    const { intent, task_id: taskId } = input;
+    const normalized = intent.toLowerCase();
+    debugLog("意图路由: 开始意图路由 (v2 signal-based)");
+    // ── 阶段 1: 信号提取 ──
+    const signals = extractSignals(intent);
+    const materialResult = extractInputMaterials(intent);
+    const scoredResult = scoreRoute(intent, signals, materialResult, taskId);
+    // ── 阶段 1.5: 工作流意图优先检查 ──
+    // 在所有标准路由之前检查 工作流意图，确保精准路由
+    if (signals.workflow_intent) {
+        const workflowResolveResult = buildresolveWorkflowDecision(signals, materialResult, scoredResult, taskId);
+        if (workflowResolveResult) {
+            debugLog(`意图路由: 工作流意图命中 workflow_intent=${signals.workflow_intent}`);
+            return workflowResolveResult;
+        }
+    }
+    // ── 阶段 2: 兼容层 — 将新模块结果映射回原有分层逻辑 ──
+    // 这确保所有现有测试用例的行为不变
+    const inputPaths = materialResult.materials.map((m) => ({
+        kind: m.kind,
+        path: m.path,
+        ingestion_status: m.ingestion_status,
+    }));
+    const hasInputPaths = inputPaths.length > 0;
+    // 层 0: 跳过类
+    if (signals.is_skip) {
+        debugLog(`意图路由: 匹配跳过模式 (${signals.skip_reason})，路由到 skip_chat`);
+        const skipRejected = scoredResult.score_breakdown
+            .filter(s => s.route !== "skip_chat")
+            .slice(0, 3)
+            .map(s => ({ route: s.route, reason: s.reasons.join("; "), score: s.score }));
+        const skipConflicts = signals.negations.length > 0
+            ? signals.negations.map(n => ({ description: `negation: ${n.negates}`, resolution: `skip_chat via ${signals.skip_reason}` }))
+            : [];
+        return {
+            ...mk("skip_chat", "none", false, [], [], undefined, undefined, 0.95),
+            skip_reason: signals.skip_reason,
+            evidence: ["skip:" + signals.skip_reason],
+            rejected_routes: skipRejected,
+            conflicts: skipConflicts,
+            decision_version: 2,
+        };
+    }
+    if (signals.is_general_qa) {
+        debugLog("意图路由: 匹配通用问答模式，路由到 direct_answer");
+        const qaRejected = scoredResult.score_breakdown
+            .filter(s => s.route !== "direct_answer")
+            .slice(0, 3)
+            .map(s => ({ route: s.route, reason: s.reasons.join("; "), score: s.score }));
+        return {
+            ...mk("direct_answer", "none", false, [], [], undefined, undefined, 0.9),
+            evidence: ["general_qa"],
+            rejected_routes: qaRejected,
+            decision_version: 2,
+        };
+    }
+    const artifactVerbPresent = hasArtifactVerb(intent);
+    const hasArtifactSignal = artifactVerbPresent && hasArtifactNoun(intent);
+    const artifact = detectArtifact(intent, taskId);
+    const hasArchiveLogSignal = SOURCE_EXTRACTION_PATTERNS.some((s) => s.pattern.test(intent));
+    const hasExtractionVerb = EXTRACTION_VERB_PATTERNS.some((p) => p.test(intent));
+    const hasSourceExtraction = hasArchiveLogSignal
+        || (hasExtractionVerb && (hasInputPaths || /源码/.test(intent)));
+    const isFullPipeline = FULL_PIPELINE_SIGNALS.some((p) => p.test(intent));
+    // ── 冲突仲裁：检查否定/约束信号 ──
+    const hasNoMutation = signals.negations.some((n) => n.negates === "mutation");
+    const hasNoPipeline = signals.negations.some((n) => n.negates === "pipeline");
+    // 层 1: 源码/材料提取
+    if (hasSourceExtraction && (hasArtifactSignal || artifact)) {
+        debugLog("意图路由: 路由到 source_extraction");
+        const materials = hasInputPaths
+            ? inputPaths.map((p) => ({ kind: p.kind, path: p.path, required: true, ingestion_status: p.ingestion_status }))
+            : inferMissingInputs(intent, false).materials.map((m) => ({ kind: m.kind, required: m.required }));
+        const missing = hasInputPaths
+            ? []
+            : inferMissingInputs(intent, false).missing;
+        const inferred = hasInputPaths ? undefined : inferMissingInputs(intent, false).materials;
+        const rejectedRoutes = scoredResult.score_breakdown
+            .filter(s => s.route !== "source_extraction")
+            .slice(0, 3)
+            .map(s => ({ route: s.route, reason: s.reasons.join("; "), score: s.score }));
+        return {
+            ...mk("source_extraction", "single_artifact", false, materials, missing, artifact ?? { kind: "custom", path: `.soloforge/output/${taskId ?? "01"}/01-提取产物.md`, taskId }, inferPipelineHint(intent, artifact?.kind), 0.8),
+            inferred_materials: inferred,
+            needs_clarification: missing.length > 0,
+            route_reason: scoredResult.route_reason,
+            signal_evidence: scoredResult.signal_evidence,
+            evidence: scoredResult.signal_evidence,
+            rejected_routes: rejectedRoutes,
+            decision_version: 2,
+        };
+    }
+    // 层 2: 规划
+    if (PLANNING_PATTERNS.some((p) => p.test(normalized)) || isFullPipeline) {
+        debugLog("意图路由: 路由到 planning");
+        if (isFullPipeline && !hasNoPipeline) {
+            return {
+                ...mk("planning", "multi_stage_plan", false, inputPaths.map((p) => ({ kind: p.kind, path: p.path, required: false, ingestion_status: p.ingestion_status })), [], artifact, inferPipelineHint(intent, artifact?.kind), 0.75),
+                route_reason: scoredResult.route_reason,
+                signal_evidence: scoredResult.signal_evidence,
+                decision_version: 2,
+            };
+        }
+        return {
+            ...mk("planning", "single_artifact", false, inputPaths.map((p) => ({ kind: p.kind, path: p.path, required: false, ingestion_status: p.ingestion_status })), [], { kind: "task_breakdown", path: `.soloforge/output/${taskId ?? "01"}/01-任务拆解.md`, taskId }, undefined, 0.8),
+            route_reason: scoredResult.route_reason,
+            signal_evidence: scoredResult.signal_evidence,
+            decision_version: 2,
+        };
+    }
+    // 层 3: 操作
+    if (OPERATION_PATTERNS.some((p) => p.test(normalized))) {
+        debugLog("意图路由: 路由到 operation");
+        return {
+            ...mk("operation", "verification_only", false, [], [], undefined, undefined, 0.8),
+            route_reason: scoredResult.route_reason,
+            decision_version: 2,
+        };
+    }
+    // 层 3.5: 分析
+    if (ANALYSIS_PATTERNS.some((p) => p.test(normalized)) && !artifactVerbPresent) {
+        debugLog("意图路由: 路由到 analysis（分析优先）");
+        return {
+            ...mk("analysis", "read_only_analysis", false, inputPaths.map((p) => ({ kind: p.kind, path: p.path, required: false, ingestion_status: p.ingestion_status })), [], undefined, undefined, 0.8),
+            route_reason: scoredResult.route_reason,
+            decision_version: 2,
+        };
+    }
+    // 层 4: 产物生成
+    if (hasArtifactSignal || (artifactVerbPresent && artifact && !PURE_EXPLAIN_PATTERNS.some((p) => p.test(intent)))) {
+        debugLog("意图路由: 路由到 artifact_generation");
+        const missing = [];
+        if (/根据\s*(?:PRD|需求文档|原型|接口文档|设计文档|源码)/i.test(intent) && inputPaths.length === 0) {
+            const refMatch = intent.match(/根据\s*(PRD|需求文档|原型|接口文档|设计文档|源码)/i);
+            if (refMatch)
+                missing.push(`请提供 ${refMatch[1]} 文件路径或内容`);
+        }
+        return {
+            ...mk("artifact_generation", "single_artifact", false, inputPaths.map((p) => ({ kind: p.kind, path: p.path, required: false, ingestion_status: p.ingestion_status })), missing, artifact ?? { kind: "custom", path: `.soloforge/output/${taskId ?? "01"}/01-产物.md`, taskId }, inferPipelineHint(intent, artifact?.kind), 0.8),
+            needs_clarification: missing.length > 0,
+            route_reason: scoredResult.route_reason,
+            signal_evidence: scoredResult.signal_evidence,
+            decision_version: 2,
+        };
+    }
+    // 层 5: 纯验收/就绪检查
+    // "检查脚手架是否就绪" 是只读验收，不应因出现"脚手架"就进入 scaffold/code_change。
+    // 但 "验收失败后修复代码" 仍是施工任务，交给 code_change。
+    if (ACCEPTANCE_PATTERNS.some((p) => p.test(normalized)) && !IMPLEMENTATION_VERB_PATTERN.test(normalized)) {
+        debugLog("意图路由: 路由到 acceptance（只读验收/就绪检查）");
+        return {
+            ...mk("acceptance", "read_only_analysis", false, inputPaths.map((p) => ({ kind: p.kind, path: p.path, required: false, ingestion_status: p.ingestion_status })), [], undefined, undefined, 0.9),
+            route_reason: scoredResult.route_reason || "acceptance_readiness_check",
+            signal_evidence: scoredResult.signal_evidence.length > 0 ? scoredResult.signal_evidence : ["acceptance"],
+            evidence: scoredResult.signal_evidence.length > 0 ? scoredResult.signal_evidence : ["acceptance"],
+            decision_version: 2,
+        };
+    }
+    // 层 6: 代码修改
+    if (CODE_CHANGE_PATTERNS.some((p) => p.test(normalized))) {
+        debugLog("意图路由: 路由到 code_change");
+        return {
+            ...mk("code_change", "code_execution", true, inputPaths.map((p) => ({ kind: p.kind, path: p.path, required: false, ingestion_status: p.ingestion_status })), [], undefined, undefined, 0.85),
+            route_reason: scoredResult.route_reason,
+            decision_version: 2,
+        };
+    }
+    // 层 7: 审查
+    if (REVIEW_PATTERNS.some((p) => p.test(normalized))) {
+        debugLog("意图路由: 路由到 review");
+        return {
+            ...mk("review", "read_only_analysis", false, inputPaths.map((p) => ({ kind: p.kind, path: p.path, required: false, ingestion_status: p.ingestion_status })), [], undefined, undefined, 0.85),
+            route_reason: scoredResult.route_reason,
+            decision_version: 2,
+        };
+    }
+    // 层 8: 通用分析
+    if (ANALYSIS_PATTERNS.some((p) => p.test(normalized))) {
+        debugLog("意图路由: 路由到 analysis（通用）");
+        return {
+            ...mk("analysis", "read_only_analysis", false, inputPaths.map((p) => ({ kind: p.kind, path: p.path, required: false, ingestion_status: p.ingestion_status })), [], undefined, undefined, 0.8),
+            route_reason: scoredResult.route_reason,
+            decision_version: 2,
+        };
+    }
+    // 层 9: 灰区
+    if (/整理(?:一下|下)?/.test(intent)) {
+        if (!hasArtifactNoun(intent)) {
+            return {
+                ...mk("direct_answer", "none", false, inputPaths.map((p) => ({ kind: p.kind, path: p.path, required: false, ingestion_status: p.ingestion_status })), [], undefined, undefined, 0.6),
+                route_reason: "gray_zone:organize",
+                decision_version: 2,
+            };
+        }
+    }
+    // 层 10: 纯解释
+    if (PURE_EXPLAIN_PATTERNS.some((p) => p.test(intent))) {
+        if (/(?:这个|这|项目里|项目中的|当前|现有)/.test(intent)) {
+            return {
+                ...mk("analysis", "read_only_analysis", false, [], [], undefined, undefined, 0.7),
+                route_reason: "pure_explain+context",
+                decision_version: 2,
+            };
+        }
+        return {
+            ...mk("direct_answer", "none", false, [], [], undefined, undefined, 0.85),
+            route_reason: "pure_explain",
+            decision_version: 2,
+        };
+    }
+    // 层 11: "看看" 灰区
+    if (/看看|看下/.test(intent)) {
+        if (/(?:风险|问题|有没有)/.test(intent)) {
+            return {
+                ...mk("review", "read_only_analysis", false, inputPaths.map((p) => ({ kind: p.kind, path: p.path, required: false, ingestion_status: p.ingestion_status })), [], undefined, undefined, 0.7),
+                route_reason: "gray:review",
+                decision_version: 2,
+            };
+        }
+        return {
+            ...mk("direct_answer", "none", false, inputPaths.map((p) => ({ kind: p.kind, path: p.path, required: false, ingestion_status: p.ingestion_status })), [], undefined, undefined, 0.6),
+            route_reason: "gray:look",
+            decision_version: 2,
+        };
+    }
+    // 兜底
+    debugLog("意图路由: 未匹配任何规则，兜底路由到 direct_answer");
+    return {
+        ...mk("direct_answer", "none", false, [], [], undefined, undefined, 0.3),
+        decision_version: 2,
+    };
+}
+const EXTENSION_WORKFLOW_MAP = {
+    architecture_design: {
+        route: "artifact_generation",
+        execution_shape: "multi_stage_plan",
+        mutation_allowed: false,
+        prompt_template: "architecture_design_prompt",
+        pipeline_hint: "architecture-design",
+        confidence: 0.9,
+    },
+    existing_system_gap_analysis: {
+        route: "analysis",
+        execution_shape: "multi_stage_plan",
+        mutation_allowed: false,
+        prompt_template: "gap_analysis_prompt",
+        pipeline_hint: "existing-system-gap-analysis",
+        confidence: 0.9,
+    },
+    test_first_coding: {
+        route: "code_change",
+        execution_shape: "multi_stage_plan",
+        mutation_allowed: true,
+        prompt_template: "test_first_coding_prompt",
+        pipeline_hint: "test-first-coding",
+        confidence: 0.9,
+    },
+    local_browser_acceptance: {
+        route: "operation",
+        execution_shape: "read_only_analysis",
+        mutation_allowed: false,
+        prompt_template: "local_acceptance_prompt",
+        pipeline_hint: "local-browser-acceptance",
+        confidence: 0.9,
+    },
+};
+/**
+ * 根据 工作流意图信号构建完整路由决策。
+ * 在标准路由之前检查，确保精准路由到扩展平台工作流。
+ */
+function buildresolveWorkflowDecision(signals, materialResult, scoredResult, taskId) {
+    const workflowIntent = signals.workflow_intent;
+    if (!workflowIntent)
+        return null;
+    const mapping = EXTENSION_WORKFLOW_MAP[workflowIntent];
+    if (!mapping)
+        return null;
+    // 有源码提取材料（archive 等）时优先走 source_extraction，不拦截到扩展平台工作流
+    const hasArchiveMaterial = materialResult.materials.some((m) => m.kind === "archive");
+    if (hasArchiveMaterial)
+        return null;
+    const inputPaths = materialResult.materials.map((m) => ({
+        kind: m.kind,
+        path: m.path,
+        ingestion_status: m.ingestion_status,
+    }));
+    const artifact = workflowIntent === "architecture_design"
+        ? detectArtifact("架构设计", taskId)
+        : undefined;
+    const rejectedRoutes = scoredResult.score_breakdown
+        .filter(s => s.route !== mapping.route)
+        .slice(0, 3)
+        .map(s => ({ route: s.route, reason: s.reasons.join("; "), score: s.score }));
+    return {
+        ...mk(mapping.route, mapping.execution_shape, mapping.mutation_allowed, inputPaths.length > 0
+            ? inputPaths.map((p) => ({ kind: p.kind, path: p.path, required: true, ingestion_status: p.ingestion_status }))
+            : [], [], artifact, mapping.pipeline_hint, mapping.confidence),
+        workflow_intent: workflowIntent,
+        route_reason: `workflow_resolve:${workflowIntent}`,
+        signal_evidence: [`workflow_intent:${workflowIntent}`],
+        evidence: [`workflow_resolve:${workflowIntent}`],
+        rejected_routes: rejectedRoutes,
+        decision_version: 2,
+    };
+}
+// ── 构造函数 ──
+function mk(route, execution_shape, mutation_allowed, input_materials, missing, output_artifact, pipeline_hint, confidence) {
+    return {
+        route, execution_shape, mutation_allowed, input_materials,
+        output_artifact, pipeline_hint, missing_required_inputs: missing, confidence,
+        scope: { read_only: !mutation_allowed, description: route + " scope" },
+        constraints: mutation_allowed ? [] : ["no_mutation"],
+        language_policy: { primary: "zh-CN", fallback: "en" },
+        evidence: [],
+        rejected_routes: [],
+        conflicts: [],
+    };
+}
+// ── 流水线提示 ──
+function inferPipelineHint(intent, artifactKind) {
+    if (/源码.*原型|原型.*源码|源码包.*原型|prototype/i.test(intent)) {
+        return "source-prototype-to-delivery:step-1";
+    }
+    if (/从.*(?:设计|需求|原型).*到.*(?:交付|完成)/.test(intent)) {
+        return "source-prototype-to-delivery";
+    }
+    switch (artifactKind) {
+        case "prototype_spec": return "source-prototype-to-delivery:step-1";
+        case "api_spec": return "source-prototype-to-delivery:step-4";
+        case "design_doc": return "source-prototype-to-delivery:step-3";
+        case "test_plan": return "source-prototype-to-delivery:step-5";
+        default: return undefined;
+    }
+}
+// ── 外部 API（保持不变） ──
+export function shouldEnterSoloForge(decision) {
+    debugLog("意图路由: 判断是否进入 SoloForge，当前路由: " + decision.route);
+    return decision.route !== "skip_chat" && decision.route !== "direct_answer";
+}
+export function selectPromptTemplate(decision) {
+    debugLog("意图路由: 选择 Prompt 模板，路由: " + decision.route + ", 执行形态: " + decision.execution_shape + ", workflow_intent: " + (decision.workflow_intent ?? "none"));
+    // 工作流意图优先选择对应模板
+    if (decision.workflow_intent) {
+        const mapping = EXTENSION_WORKFLOW_MAP[decision.workflow_intent];
+        if (mapping)
+            return mapping.prompt_template;
+    }
+    if (decision.route === "source_extraction")
+        return "source_extraction_prompt";
+    if (decision.route === "direct_answer")
+        return "direct_answer_prompt";
+    if (decision.route === "acceptance")
+        return "acceptance_prompt";
+    switch (decision.execution_shape) {
+        case "code_execution": return "code_execution_prompt";
+        case "single_artifact": return "single_artifact_prompt";
+        case "read_only_analysis": return "read_only_analysis_prompt";
+        case "verification_only": return "verification_only_prompt";
+        case "multi_stage_plan": return "single_artifact_prompt";
+        case "none": return "direct_answer_prompt";
+        default: return "code_execution_prompt";
+    }
+}
+export function debugRouteIntent(input) {
+    const { intent, task_id: taskId } = input;
+    const materialResult = extractInputMaterials(intent);
+    const signals = extractSignals(intent);
+    const scored = scoreRoute(intent, signals, materialResult, taskId);
+    const decision = routeIntent(input);
+    const whyNotSkip = signals.is_skip
+        ? `skip detected: ${signals.skip_reason}`
+        : signals.is_general_qa
+            ? "general QA pattern"
+            : "has SoloForge-relevant signals";
+    return {
+        intent,
+        extracted_materials: materialResult,
+        signals,
+        scored,
+        final_decision: decision,
+        why_not_skip: whyNotSkip,
+    };
+}
+//# sourceMappingURL=intent_router.js.map