soloforge 1.5.0 → 2.0.0

package/dist/engine/intent_router.js

@@ -1,628 +0,0 @@
-/**
- * Intent Router — 意图路由器
- *
- * 根据用户意图文本确定语义通道 (route) 和执行形态 (execution_shape)。
- * 零 AI 依赖，纯规则匹配。
- *
- * 替代旧的 task_type -> strategy 入口裁决链路。
- * task_type 保留为辅助描述，不再单独决定是否进入 SoloForge。
- *
- * v2: 模块化拆分 — 路由判定由"信号提取 + 归一化 + 打分 + 冲突仲裁"完成，
- *     不再依赖单条整句正则。
- */
-import { getDefaultArtifactPath } from "./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 "./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 "./consumption_trace_store.js";
-import { listConsumableAssetsByConsumer } from "./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