@winspan/claude-forge 0.5.2 → 0.6.0

package/dist/daemon/handlers/user-prompt-handler.js

@@ -1,17 +1,26 @@
 import { BaseHookHandler } from './base-handler.js';
-import { ConversationalConfigHandler } from './conversational-config-handler.js';
-import { logger } from '../../utils/logger.js';
-import { ForgeFormatter } from '../../utils/formatter.js';
-import { parsePipelineChoice, PIPELINE_OPTIONS } from '../../pipeline/pipeline-options.js';
-import { readPlanFile, getPlanFilePath, buildSessionStartPlanContext, readActivePlanSummary } from '../../utils/plan-reader.js';
-import { ContextInjector, INJECT_PRIORITY } from '../context-injector.js';
-import { TreeIndexEngine } from '../../distill/tree-index.js';
+import { logger, relPath } from '../../utils/logger.js';
 import { TemplateRegistry } from '../../pipeline/template-registry.js';
 import { TemplateRouter } from '../../pipeline/template-router.js';
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { isForgeManaged } from '../lifecycle.js';
+import { FailureSignalStage } from './stages/01-failure-signal.js';
+import { ActiveInterventionStage } from './stages/02-active-intervention.js';
+import { InitPromptStage } from './stages/03-init-prompt.js';
+import { SkillSuggestionsStage } from './stages/04-skill-suggestions.js';
+import { ConversationalConfigStage } from './stages/05-conv-config.js';
+import { EngineCheckStage } from './stages/06-engine-check.js';
+import { PipelineReplyStage } from './stages/07-pipeline-reply.js';
+import { EscInterruptStage } from './stages/08-esc-interrupt.js';
+import { PipelineActiveStage } from './stages/09-pipeline-active.js';
+import { CooldownStage } from './stages/10-cooldown.js';
+import { IntentAnalysisStage } from './stages/11-intent-analysis.js';
+import { StrategyAdviceStage } from './stages/12-strategy-advice.js';
+import { TemplateRouteStage } from './stages/13-template-route.js';
+import { PlanResumeStage } from './stages/14-plan-resume.js';
+import { PlanEnforcementStage } from './stages/15-plan-enforcement.js';
+import { InterventionLevelStage } from './stages/16-intervention-level.js';
+import { SimpleTaskStage } from './stages/17-simple-task.js';
+import { ComplexTaskStage } from './stages/18-complex-task.js';
+import { ModerateTaskStage } from './stages/19-moderate-task.js';
 export class UserPromptHandler extends BaseHookHandler {
     /**
      * 上一轮是否向用户展示了 pipeline 建议（按 project_path 隔离）
@@ -30,16 +39,11 @@ export class UserPromptHandler extends BaseHookHandler {
     injectionCache = new Map();
     /** 已处理过负向重启检测的 session（key=sessionId），避免同 session 重复触发 */
     negativeRestartChecked = new Set();
-    static ANALYSIS_COOLDOWN_MS = 800;
-    /** Map 条目超过此时长（1 小时）后在下次写入时清理 */
-    static MAX_STATE_AGE_MS = 60 * 60 * 1000;
-    configHandler;
     /** Batch 4：统一编排模板注册表 + 路由器 */
     templateRegistry = null;
     templateRouter = null;
     constructor(ctx) {
         super(ctx);
-        this.configHandler = new ConversationalConfigHandler(ctx);
         // 初始化模板路由器（仅在 sharedApi 可用时）
         if (ctx.sharedApi) {
             this.templateRegistry = new TemplateRegistry();
@@ -52,1085 +56,68 @@ export class UserPromptHandler extends BaseHookHandler {
     /** initPromptedSessions 条目的写入时间，用于 TTL 清理 */
     initPromptedAt = new Map();
     async handle(event) {
-        const { intentEngine } = this.ctx;
         const userPrompt = event.tool_input?.user_prompt || '';
         if (!userPrompt)
             return;
-        // 失败信号检测（异步写入，不阻塞主流程）
-        if (this.ctx.retrospectiveEngine) {
-            const toolCallCount = this.ctx.storage.queryEvents({
-                session_id: event.session_id,
-                project_path: event.project_path,
-                hook_type: 'PostToolUse',
-            }).length;
-            const signal = this.ctx.retrospectiveEngine.detectFailureSignal(userPrompt, {
-                preceding_tool_count: toolCallCount,
-                current_phase: this.ctx.pipelineEngine?.getCurrentPhase(event.project_path) ?? undefined,
-                timestamp: event.timestamp ?? new Date().toISOString(),
-            });
-            if (signal) {
-                this.ctx.retrospectiveEngine.recordFailureSignal({
-                    ...signal,
-                    session_id: event.session_id,
-                    project_path: event.project_path,
-                }).catch(err => logger.debug(`[Forge:任务复盘] 记录失败信号异常：${err}`));
-            }
-            // P4：负向重启回溯修正（仅在 session 内首条 UserPromptSubmit 时触发）
-            if (!this.negativeRestartChecked.has(event.session_id)) {
-                this.negativeRestartChecked.add(event.session_id);
-                if (signal?.signal_type === 'dissatisfied') {
-                    this.applyNegativeRestartPenalty(event.project_path, event.session_id).catch(err => logger.debug(`[Forge:满意度] 负向重启回溯失败：${err}`));
-                }
-            }
-        }
-        // 主动干预：检测卡死循环（fix_attempt_count >= 3 时注入建议）
-        if (this.ctx.retrospectiveEngine) {
-            const sessionMetrics = this.ctx.storage.getSessionMetrics(event.session_id);
-            const fixAttempts = Number(sessionMetrics?.['fix_attempt_count'] ?? 0);
-            if (fixAttempts >= 3) {
-                logger.info(`[Forge:主动干预] 检测到卡死循环（修复尝试次数=${fixAttempts}），注入干预建议`);
-                return {
-                    allow: true,
-                    additionalContext: ForgeFormatter.wrapInQuote(`[Forge 主动干预] 检测到您已进行 ${fixAttempts} 次修复尝试，建议：\n` +
-                        `1. 回退到上一个稳定状态（git stash 或 git checkout）\n` +
-                        `2. 重新分析根本原因，而非症状\n` +
-                        `3. 考虑使用 cf pipeline 启动结构化编排`),
-                };
-            }
-        }
-        // 0. 检测项目是否已初始化，未初始化时提示用户（每个 session 只提示一次）
-        const sessionKey = `${event.session_id}:${event.project_path}`;
-        if (!this.initPromptedSessions.has(sessionKey) && !isForgeManaged(event.project_path)) {
-            logger.info(`项目未初始化，已注入配置引导提示`);
-            this.initPromptedSessions.add(sessionKey);
-            this.initPromptedAt.set(sessionKey, Date.now());
-            return {
-                allow: true,
-                additionalContext: ForgeFormatter.wrapInQuote(`[Claude Forge 提示]\n当前项目（${event.project_path}）尚未加入 Claude Forge 管理。\n请询问用户："是否将当前项目加入 Claude Forge 管理？（将自动分析技术栈并生成项目规范）（是/否）"\n如果用户确认，请执行：\`\`\`bash\nmkdir -p "${event.project_path}/.claude-forge" && cd "${event.project_path}" && cf convention distill\n\`\`\`\n执行完成后告知用户项目已加入管理并生成了自定义规范。`),
-            };
-        }
-        try {
-            // 0a. 技能优化建议注入（每次 session 首条消息，读取后删除文件，仅注入一次）
-            const skillSuggestions = this.readAndDeleteSkillSuggestions(event.project_path);
-            if (skillSuggestions) {
-                logger.info('[Forge:技能建议] 注入技能优化建议并删除建议文件');
-                return {
-                    allow: true,
-                    additionalContext: ForgeFormatter.wrapInQuote(`[Forge 技能优化建议]\n以下是上次 Forge 分析生成的技能改进建议，供参考：\n\n${skillSuggestions}`),
-                };
-            }
-            // 0. 对话式配置意图检测（pattern-based，不依赖 AI，优先执行）
-            const configMsg = await this.configHandler.handle(userPrompt, event.project_path);
-            if (configMsg) {
-                logger.info('检测到配置意图，已执行并注入确认消息');
-                // 注入确认消息后继续让 Claude 处理原始消息
-                return { allow: true, additionalContext: ForgeFormatter.wrapInQuote(configMsg) };
-            }
-            if (!intentEngine) {
-                logger.info('AI 引擎不可用，跳过意图分析');
-                return;
-            }
-            // 1. 检查是否是对 Pipeline 选择的回复（优先处理）
-            const pipelineReply = await this.handlePipelineReply(userPrompt, event);
-            if (pipelineReply !== undefined)
-                return pipelineReply;
-            // 1.2 检测 ESC 中断待确认状态
-            const interruptedState = this.ctx.pipelineEngine?.getInterruptedState(event.project_path);
-            if (interruptedState) {
-                const interruptReply = this.handleInterruptReply(userPrompt, event, interruptedState);
-                if (interruptReply !== undefined)
-                    return interruptReply;
-                // 首次进入中断状态：注入消歧提示，等待用户回复
-                const { phase, completedCount } = interruptedState;
-                const PHASE_LABELS_MAP = {
-                    analyze: '需求分析', design: '架构设计', code: '编码实现', test: '测试', review: '代码审查',
-                };
-                const phaseLabel = PHASE_LABELS_MAP[phase] ?? phase;
-                logger.info(`[Pipeline] 注入 ESC 中断消歧提示（阶段=${phaseLabel}，已完成=${completedCount}）`);
-                return {
-                    allow: true,
-                    additionalContext: ForgeFormatter.wrapInQuote(`[Forge Pipeline 中断恢复]\n检测到上次执行被中断（${phaseLabel}阶段，已完成 ${completedCount} 个任务）。\n\n请询问用户：\n"上次执行被中断，请选择处理方式：\nA. 继续 — 从中断处继续执行当前阶段\nB. 重做 — 重新执行当前阶段（清除本阶段进度）\nC. 取消 — 关闭当前 Pipeline，回到普通模式\n\n请输入 A、B 或 C："`),
-                };
-            }
-            // 1.5 Pipeline 活跃时短路：只注入规范，跳过意图分析和 profile/decisions 注入
-            // Pipeline 运行中已通过 PreToolUse 注入阶段指令，UserPrompt 侧无需重复注入
-            if (this.ctx.pipelineEngine?.hasActivePipeline(event.project_path)) {
-                const conventionPrompt = this.ctx.conventionManager.getActivePrompt(event.project_path) ?? undefined;
-                logger.info('[Forge:Pipeline] Pipeline 活跃，跳过意图分析和低优先级上下文注入');
-                if (!conventionPrompt)
-                    return;
-                return {
-                    allow: true,
-                    additionalContext: ForgeFormatter.wrapInQuote(conventionPrompt),
-                };
-            }
-            // 2. 冷却检查（冷却期内仍注入规范上下文，避免 Claude 无任何约束）
-            if (!this.checkCooldown(event.project_path)) {
-                const conventionPrompt = this.ctx.conventionManager.getActivePrompt(event.project_path);
-                if (conventionPrompt) {
-                    logger.info('[Forge:冷却期] 分析冷却中，仅注入规范上下文');
-                    return {
-                        allow: true,
-                        additionalContext: ForgeFormatter.wrapInQuote(conventionPrompt),
-                    };
-                }
-                return;
-            }
-            // 3. 意图分析（带会话上下文 + 活跃计划状态）
-            const history = this.buildConversationHistory(event.session_id, event.project_path);
-            // 前置读取活跃计划——意图分析必须感知到跨 session 的任务续接状态
-            const activePlan = readActivePlanSummary(event.project_path) ?? undefined;
-            // 预热：在 await analyze() 之前同步完成不依赖 analysis 的 IO，
-            // 利用 AI 网络等待期间（2-3s）将结果写入 injectionCache，analyze 完成后直接命中缓存
-            this.ctx.conventionManager.getActiveConventions(event.project_path);
-            this.buildPlanStartContext(event.project_path);
-            this.buildProfileContext(event.project_path);
-            this.readDecisionsFile(event.project_path);
-            // 构建用户上下文（从 ProfileManager + 历史满意度）
-            const userContext = this.buildUserContext(event.project_path);
-            const analysis = await this.ctx.latencyTracer.trace({
-                session_id: event.session_id,
-                project_path: event.project_path,
-                trace_type: 'intent_analysis',
-                engine_name: 'IntentEngine',
-            }, () => intentEngine.analyze(userPrompt, event.project_path, undefined, history, isForgeManaged(event.project_path), activePlan, userContext));
-            this.logAnalysis(analysis);
-            if (analysis.searchKeywords?.length) {
-                this.ctx.skillRegistry.setIntentKeywords(analysis.searchKeywords);
-            }
-            // 3.1 历史失败模式预防建议注入
-            if (this.ctx.retrospectiveEngine) {
-                const strategies = this.ctx.retrospectiveEngine.getStrategies(analysis.requirement || userPrompt);
-                if (strategies) {
-                    logger.info('[Forge:策略建议] 注入历史失败模式预防建议');
-                    return {
-                        allow: true,
-                        additionalContext: ForgeFormatter.wrapInQuote(strategies),
-                    };
-                }
-            }
-            // 3.5 模板路由（Batch 4：统一编排模板，优先于 Pattern 路由）
-            const templateResponse = await this.handleTemplateRoute(userPrompt, analysis.complexity, event, analysis);
-            if (templateResponse !== undefined)
-                return templateResponse;
-            // 3.7 计划续接路由：有活跃计划时，优先注入计划上下文，跳过 Plan Mode 强制和 Pipeline 建议
-            if (activePlan && analysis.complexity !== 'simple') {
-                const resumeResponse = this.handlePlanResume(activePlan, userPrompt, analysis.requirement, event.project_path);
-                if (resumeResponse !== undefined)
-                    return resumeResponse;
-            }
-            // 3.8 计划强制检查（moderate/complex 任务有代码变更意图时，若无计划则强制先写计划）
-            if (analysis.complexity !== 'simple') {
-                const enforcement = this.checkPlanEnforcement(analysis.requirement, event.project_path);
-                if (enforcement)
-                    return enforcement;
-            }
-            // 4. 干预级别
-            const interventionLevel = this.ctx.profileManager.getInterventionLevel(analysis.complexity);
-            logger.info(`用户偏好介入程度：${interventionLevel}（任务复杂度：${analysis.complexity}）`);
-            if (interventionLevel === 'silent') {
-                // Forge 管理项目：即使静默模式，requiresPipeline=true 时仍需走编排（代码变更必须有产物）
-                if (isForgeManaged(event.project_path) && analysis.requiresPipeline) {
-                    logger.info(`[Forge:Pipeline] 静默模式但 Forge 管理项目需要 Pipeline，继续编排`);
-                }
-                else {
-                    logger.info(`用户偏好静默模式，跳过编排`);
-                    return;
-                }
-            }
-            // 5. 简单任务：轻量注入（只注入规范和画像，跳过执行卡片和 Pipeline）
-            // Forge 管理项目：有代码改动意图时，提升为 moderate 并走 Pipeline 建议，确保产物生成
-            if (analysis.complexity === 'simple') {
-                const hasCodeChange = (analysis.estimatedFiles ?? 0) > 0;
-                if (isForgeManaged(event.project_path) && hasCodeChange) {
-                    logger.info('[Forge:Pipeline] Forge 管理项目检测到代码改动，提升为 moderate 并走 Pipeline 建议');
-                    analysis.complexity = 'moderate';
-                    analysis.requiresPipeline = true;
-                    // 继续执行，不 return，走后续 Pipeline 建议逻辑
-                }
-                else {
-                    return this.buildLightweightResponse(analysis, event.project_path);
-                }
-            }
-            // 6. 执行路径卡片（moderate/complex）
-            const card = this.buildExecutionCard(analysis);
-            // 7. 复杂任务 Pipeline 决策
-            if (analysis.requiresPipeline) {
-                const pipelineResponse = await this.handleComplexTask(analysis, card, event, interventionLevel);
-                if (pipelineResponse !== undefined)
-                    return pipelineResponse;
-            }
-            // 8. 中等任务：知识搜索 + 指令注入
-            const response = await this.buildSimpleResponse(analysis, card, event.project_path);
-            return response;
-        }
-        catch (err) {
-            logger.error(`意图分析失败：${err}`);
-        }
-    }
-    // ── 私有方法 ──────────────────────────────────────────────────────────────
-    /**
-     * 处理用户对 Pipeline 选择的回复（A/B/C）。
-     * 返回 HookResponse 表示已处理，返回 undefined 表示不是 pipeline 回复。
-     */
-    async handlePipelineReply(userPrompt, event) {
-        const { pipelineEngine, profileManager } = this.ctx;
-        if (!pipelineEngine || pipelineEngine.hasActivePipeline(event.project_path))
-            return undefined;
-        const choice = parsePipelineChoice(userPrompt);
-        if (choice) {
-            this.setSuggestionPending(event.project_path, false);
-            logger.info(`用户选择了工作流方案：${choice}`);
-            profileManager.recordBehavior({ type: 'accept', context: `pipeline:${choice}`, timestamp: new Date().toISOString() });
-            return this.startPipelineFromChoice(choice, event);
-        }
-        if (this.suggestionPending.get(event.project_path)) {
-            this.setSuggestionPending(event.project_path, false);
-            logger.info('用户忽略了工作流建议');
-            profileManager.recordBehavior({ type: 'skip', context: 'pipeline:ignored', timestamp: new Date().toISOString() });
-        }
-        return undefined;
-    }
-    /** 冷却检查，通过返回 true，并清理过期条目 */
-    checkCooldown(projectPath) {
-        const now = Date.now();
-        this.evictStaleEntries(now);
-        const lastAt = this.lastAnalysisAt.get(projectPath) ?? 0;
-        if (now - lastAt < UserPromptHandler.ANALYSIS_COOLDOWN_MS) {
-            logger.info(`分析冷却中，跳过（${projectPath}）`);
-            return false;
-        }
-        this.lastAnalysisAt.set(projectPath, now);
-        return true;
-    }
-    /**
-     * 构建会话上下文：最近的用户输入 + 工具调用摘要。
-     * 帮助意图引擎理解当前对话在做什么，避免孤立判断单条输入。
-     */
-    buildConversationHistory(sessionId, projectPath) {
-        try {
-            const { storage } = this.ctx;
-            // 查询最近 10 条事件（含 UserPromptSubmit 和工具调用）
-            const recentEvents = storage.queryEvents({
-                session_id: sessionId,
-                project_path: projectPath,
-                limit: 15,
-            });
-            if (recentEvents.length === 0)
-                return undefined;
-            const lines = [];
-            // 提取最近的用户输入（最多 3 条，不含当前输入）
-            const userPrompts = recentEvents
-                .filter(e => e.hook_type === 'UserPromptSubmit' && e.tool_input)
-                .slice(0, 4) // 多取一条因为第一条是当前输入
-                .slice(1) // 去掉当前输入
-                .reverse(); // 按时间正序
-            if (userPrompts.length > 0) {
-                lines.push('### 最近的用户指令');
-                for (const e of userPrompts) {
-                    const prompt = e.tool_input?.user_prompt || '';
-                    if (prompt) {
-                        lines.push(`- ${prompt.substring(0, 150)}`);
-                    }
-                }
-            }
-            // 提取最近的工具调用摘要（最多 5 条）
-            const toolEvents = recentEvents
-                .filter(e => (e.hook_type === 'PostToolUse' || e.hook_type === 'PreToolUse') && e.tool_name)
-                .slice(0, 5)
-                .reverse();
-            if (toolEvents.length > 0) {
-                lines.push('### 最近的工具调用');
-                for (const e of toolEvents) {
-                    const inputStr = e.tool_input ? JSON.stringify(e.tool_input).substring(0, 100) : '';
-                    lines.push(`- ${e.tool_name}: ${inputStr}`);
-                }
-            }
-            if (lines.length === 0)
-                return undefined;
-            return lines.join('\n');
-        }
-        catch {
-            return undefined;
-        }
-    }
-    /** 清理超过 MAX_STATE_AGE_MS 的 Map 条目，防止内存无限增长 */
-    evictStaleEntries(now) {
-        const cutoff = now - UserPromptHandler.MAX_STATE_AGE_MS;
-        for (const [key, ts] of this.lastAnalysisAt) {
-            if (ts < cutoff) {
-                this.lastAnalysisAt.delete(key);
-                this.suggestionPending.delete(key);
-                this.injectionCache.delete(key);
-            }
-        }
-        // 清理 initPromptedSessions 中超过 TTL 的条目
-        for (const [key, ts] of this.initPromptedAt) {
-            if (ts < cutoff) {
-                this.initPromptedAt.delete(key);
-                this.initPromptedSessions.delete(key);
-            }
-        }
-    }
-    setSuggestionPending(projectPath, value) {
-        this.suggestionPending.set(projectPath, value);
-        // 确保 lastAnalysisAt 有对应条目，使 evict 能清理 suggestionPending
-        if (!this.lastAnalysisAt.has(projectPath)) {
-            this.lastAnalysisAt.set(projectPath, Date.now());
-        }
-    }
-    /**
-     * 构建用户画像上下文。每个项目的 session 内只注入一次（首条消息），后续跳过。
-     */
-    buildProfileContext(projectPath) {
-        const cache = this.injectionCache.get(projectPath);
-        if (cache?.profileInjected)
-            return undefined;
-        const profile = this.ctx.profileManager.get();
-        if (!profile.initialized)
-            return undefined;
-        // 标记已注入
-        this.injectionCache.set(projectPath, {
-            ...(cache ?? { decisionsKey: '', decisionsResult: '', decisionsRawTail: '', profileInjected: false, planContextInjected: false, skillSuggestionsInjected: false }),
-            profileInjected: true,
-        });
-        // 读取项目人设（优先级：.forge-modules.yaml > .claude-forge/persona.md）
-        const persona = this.readProjectPersona(projectPath);
-        logger.info(`注入用户画像：角色=${profile.role} 经验=${profile.experience_level} 风格=${profile.work_style}${persona ? ' 人设=已加载' : ''}`);
-        return ForgeFormatter.formatProfileContext(profile, persona);
-    }
-    /** 读取项目人设文本，无则返回 undefined */
-    readProjectPersona(projectPath) {
-        try {
-            // 1. .forge-modules.yaml persona 字段
-            const modulesYaml = path.join(projectPath, '.forge-modules.yaml');
-            if (fs.existsSync(modulesYaml)) {
-                const raw = fs.readFileSync(modulesYaml, 'utf-8');
-                const match = raw.match(/^persona:\s*["']?(.+?)["']?\s*$/m);
-                if (match?.[1]?.trim())
-                    return match[1].trim();
-            }
-            // 2. .claude-forge/persona.md
-            const personaFile = path.join(projectPath, '.claude-forge', 'persona.md');
-            if (fs.existsSync(personaFile)) {
-                const stored = fs.readFileSync(personaFile, 'utf-8').trim();
-                if (stored)
-                    return stored;
-            }
-        }
-        catch {
-            // 读取失败静默忽略
-        }
-        return undefined;
-    }
-    /**
-     * 构建计划进度上下文。每个项目的 session 内只注入一次（首条消息），后续跳过。
-     * 优先级 -2，早于画像（-1）展示。
-     */
-    buildPlanStartContext(projectPath) {
-        const cache = this.injectionCache.get(projectPath);
-        if (cache?.planContextInjected)
-            return undefined;
-        this.injectionCache.set(projectPath, {
-            ...(cache ?? { decisionsKey: '', decisionsResult: '', decisionsRawTail: '', profileInjected: false, skillSuggestionsInjected: false }),
-            planContextInjected: true,
-        });
-        const ctx = buildSessionStartPlanContext(projectPath);
-        if (ctx) {
-            logger.info(`注入计划上下文：${projectPath}`);
-        }
-        return ctx ?? undefined;
-    }
-    /**
-     * 读取技能优化建议文件（~/.claude-forge/skill-suggestions.md），读取后立即删除。
-     * 每个项目的 session 内只读一次（InjectionCache 标记），防止重复注入。
-     */
-    readAndDeleteSkillSuggestions(projectPath) {
-        const cache = this.injectionCache.get(projectPath);
-        if (cache?.skillSuggestionsInjected)
-            return undefined;
-        this.injectionCache.set(projectPath, {
-            ...(cache ?? { decisionsKey: '', decisionsResult: '', decisionsRawTail: '', profileInjected: false, planContextInjected: false, skillSuggestionsInjected: false }),
-            skillSuggestionsInjected: true,
-        });
-        try {
-            const suggestionsFile = path.join(os.homedir(), '.claude-forge', 'skill-suggestions.md');
-            if (!fs.existsSync(suggestionsFile))
-                return undefined;
-            const content = fs.readFileSync(suggestionsFile, 'utf-8').trim();
-            fs.unlinkSync(suggestionsFile);
-            if (!content)
-                return undefined;
-            // 去掉文件头行（"# 技能优化建议\n\n"），只返回建议正文
-            return content.replace(/^#\s*.+\n+/, '').trim() || undefined;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    /** 判断用户输入是否含有代码变更意图 */
-    isCodeChangeIntent(requirement) {
-        return /implement|add|fix|refactor|create|write|edit|update|build|删除|修复|实现|新增|添加|编写|创建|重构|开发/i.test(requirement);
-    }
-    /**
-     * 处理 ESC 中断后用户的 A/B/C 选择回复。
-     * 返回 HookResponse 表示已处理；返回 undefined 表示不是选择回复（首次进入，需注入提示）。
-     */
-    handleInterruptReply(userPrompt, event, interruptedState) {
-        const choice = userPrompt.trim().toUpperCase();
-        const pipelineEngine = this.ctx.pipelineEngine;
-        if (!pipelineEngine)
-            return undefined;
-        if (choice === 'A' || /^继续/.test(userPrompt)) {
-            pipelineEngine.resumeAfterInterrupt(event.project_path);
-            logger.info(`[Pipeline] 用户选择继续，恢复 ${interruptedState.phase} 阶段`);
-            return {
-                allow: true,
-                additionalContext: ForgeFormatter.wrapInQuote(`[Forge Pipeline] 已恢复执行。继续 ${interruptedState.phase} 阶段，请从上次中断处继续工作。`),
-            };
-        }
-        if (choice === 'B' || /^重做/.test(userPrompt)) {
-            // 重做：取消当前 pipeline，让用户重新触发
-            pipelineEngine.cancelAfterInterrupt(event.project_path);
-            logger.info(`[Pipeline] 用户选择重做，关闭 Pipeline`);
-            return {
-                allow: true,
-                additionalContext: ForgeFormatter.wrapInQuote(`[Forge Pipeline] 已关闭当前 Pipeline。请重新描述需求，系统将重新启动编排流程。`),
-            };
-        }
-        if (choice === 'C' || /^取消/.test(userPrompt)) {
-            pipelineEngine.cancelAfterInterrupt(event.project_path);
-            logger.info(`[Pipeline] 用户选择取消，关闭 Pipeline`);
-            return {
-                allow: true,
-                additionalContext: ForgeFormatter.wrapInQuote(`[Forge Pipeline] Pipeline 已取消，回到普通模式。`),
-            };
-        }
-        // 不是 A/B/C 回复，说明是首次进入中断状态，返回 undefined 让外层注入提示
-        return undefined;
-    }
-    /**
-     * 计划续接路由：有活跃计划时，判断用户输入是"续接"还是"新任务"。
-     *
-     * - 续接意图（"继续"/"下一步"/任务关键词匹配）→ 注入计划上下文，让 Claude 直接执行
-     * - 新任务意图 → 注入冲突提示，让用户选择覆盖还是挂起
-     * - 无法判断 → 返回 undefined，交给后续逻辑处理
-     */
-    handlePlanResume(activePlan, userPrompt, requirement, projectPath) {
-        const lower = userPrompt.toLowerCase().trim();
-        // 明确续接信号：通用续接词
-        const resumePatterns = /^(继续|下一步|接着|continue|next|开始|go ahead|执行)/i;
-        const isExplicitResume = resumePatterns.test(lower);
-        // 任务关键词匹配：用户输入的任务名与计划中的待处理任务高度重叠
-        const allPlanTasks = [...activePlan.inProgress, ...activePlan.pending];
-        const isTaskMatch = allPlanTasks.some(task => task.length > 4 && lower.includes(task.toLowerCase().substring(0, Math.min(task.length, 10))));
-        const isResume = isExplicitResume || isTaskMatch;
-        if (isResume) {
-            // 续接路径：注入完整计划上下文，Claude 直接执行
-            logger.info(`[Forge:计划续接] 检测到续接意图，注入计划上下文（${activePlan.relPath}）`);
-            const inProgressList = activePlan.inProgress.length > 0
-                ? `**进行中**：\n${activePlan.inProgress.map(t => `  - [~] ${t}`).join('\n')}`
-                : '';
-            const pendingList = activePlan.pending.length > 0
-                ? `**待处理**：\n${activePlan.pending.map(t => `  - [ ] ${t}`).join('\n')}`
-                : '';
-            const context = [
-                `[Forge 计划续接] 当前活跃计划：${activePlan.title}（${activePlan.relPath}）`,
-                `已完成 ${activePlan.doneCount} 个任务。`,
-                inProgressList,
-                pendingList,
-                `\n请从上述任务继续执行。完成每个任务后，将计划文件中对应任务的 \`[ ]\` 或 \`[~]\` 改为 \`[x]\`。`,
-            ].filter(Boolean).join('\n');
-            return {
-                allow: true,
-                additionalContext: ForgeFormatter.wrapInQuote(context),
-            };
-        }
-        // 新任务意图：检查是否与计划明显无关（有明确的新需求动词）
-        const newTaskSignal = this.isCodeChangeIntent(requirement);
-        if (newTaskSignal) {
-            // 注入冲突提示，让用户决策
-            logger.info(`[Forge:计划续接] 检测到新任务意图，注入冲突提示`);
-            const inProgressSummary = activePlan.inProgress.length > 0
-                ? activePlan.inProgress[0]
-                : activePlan.pending[0] ?? '未知';
-            return {
-                allow: true,
-                additionalContext: ForgeFormatter.wrapInQuote(`[Forge 计划冲突提示] 项目当前有未完成的计划：「${activePlan.title}」\n` +
-                    `当前进行中任务：${inProgressSummary}\n\n` +
-                    `您的新请求「${requirement}」与现有计划可能冲突。\n\n` +
-                    `请选择：\n` +
-                    `A. 继续现有计划（忽略新请求，专注完成当前任务）\n` +
-                    `B. 处理新请求（暂停现有计划，处理完后再回来）\n` +
-                    `C. 替换计划（放弃现有计划，为新请求重新制定计划）`),
-            };
-        }
-        return undefined;
-    }
-    /**
-     * 计划强制检查：检测到代码变更意图但今日无活跃计划时，自动启动 plan mode。
-     */
-    checkPlanEnforcement(requirement, projectPath) {
-        if (!this.isCodeChangeIntent(requirement))
-            return undefined;
-        const planFile = readPlanFile(projectPath);
-        if (planFile?.hasInProgress || planFile?.hasIncomplete)
-            return undefined;
-        const planPath = getPlanFilePath(projectPath);
-        const msg = `[Forge 计划优先] 检测到代码变更意图，但项目 docs/ 下没有含待处理任务的计划文件。
-
-正在自动启动 Plan Mode，请先规划任务步骤...`;
-        logger.info(`[Forge:计划] 自动启动 Plan Mode，产物将同步至：${planPath}`);
-        return {
-            allow: true,
-            systemMessage: `You are now in PLAN MODE. The user wants to: "${requirement}"
-
-Before implementing, you must:
-1. Use EnterPlanMode tool to start planning
-2. Create a detailed implementation plan with clear task breakdown
-3. Break down the work into discrete tasks with clear acceptance criteria
-4. Use ExitPlanMode when the plan is complete
-5. IMMEDIATELY after ExitPlanMode is approved, use the Write tool to save the plan to: ${planPath}
-   - Create parent directories as needed
-   - The file content must be the full plan document (same content as the plan)
-   - This is MANDATORY — the plan MUST land in the project docs directory, not only in ~/.claude/plans/
-
-Do NOT write any code until the plan is approved and saved to ${planPath}. Start by calling EnterPlanMode.`,
-            additionalContext: msg
+        const ctx = {
+            event,
+            userPrompt,
+            handlerCtx: this.ctx,
+            suggestionPending: this.suggestionPending,
+            lastAnalysisAt: this.lastAnalysisAt,
+            injectionCache: this.injectionCache,
+            negativeRestartChecked: this.negativeRestartChecked,
+            initPromptedSessions: this.initPromptedSessions,
+            initPromptedAt: this.initPromptedAt,
+            templateRegistry: this.templateRegistry,
+            templateRouter: this.templateRouter,
         };
-    }
-    logAnalysis(analysis) {
-        const pipelineStr = analysis.requiresPipeline ? '需要多步骤编排' : '直接执行';
-        logger.info(`意图分析：${analysis.complexity} | ${pipelineStr} | ` +
-            `预估文件=${analysis.estimatedFiles} | 需求="${analysis.requirement}"`);
-        logger.info(`分析理由：${analysis.reasoning}`);
-    }
-    /**
-     * 模板路由（Batch 4）：若命中 PipelineTemplate，直接启动模板驱动的 Pipeline。
-     * 未命中或模板路由不可用时返回 undefined，继续走 Pattern 路由。
-     */
-    async handleTemplateRoute(userPrompt, complexity, event, analysis) {
-        const { pipelineEngine } = this.ctx;
-        if (!this.templateRegistry || !this.templateRouter || !pipelineEngine)
-            return undefined;
-        // Pipeline 活跃时跳过模板路由
-        if (pipelineEngine.hasActivePipeline(event.project_path))
-            return undefined;
-        // simple 任务不走模板路由
-        if (complexity === 'simple')
-            return undefined;
-        try {
-            const templates = this.templateRegistry.getTemplates(event.project_path);
-            if (templates.length === 0)
-                return undefined;
-            this.templateRouter.setTemplates(templates);
-            const result = await this.ctx.latencyTracer.trace({
-                session_id: event.session_id,
-                project_path: event.project_path,
-                trace_type: 'pattern_route',
-                engine_name: 'TemplateRouter',
-            }, () => this.templateRouter.route(userPrompt, complexity));
-            if (!result.template || result.confidence < 0.6)
-                return undefined;
-            logger.info(`[模板路由] 命中：${result.template.id}（方式=${result.method}, 置信度=${result.confidence.toFixed(2)}）`);
-            const pipeline = await pipelineEngine.startPipelineFromTemplate(analysis.requirement, event.project_path, event.session_id, result.template);
-            if (this.ctx.qualityGate)
-                this.ctx.qualityGate.setRequirement(analysis.requirement);
-            const card = this.buildExecutionCard(analysis);
-            const msg = ForgeFormatter.formatModuleNotification('pipeline', `已启动模板编排（${result.template.name}），共 ${pipeline.tasks.length} 个任务\n阶段：${result.template.phases.map(p => p.name).join(' → ')}`);
-            return { allow: true, systemMessage: card, additionalContext: ForgeFormatter.wrapInQuote(msg) };
-        }
-        catch (err) {
-            logger.warn(`[模板路由] 路由失败，降级到 Pattern 路由：${err}`);
-            return undefined;
-        }
-    }
-    buildExecutionCard(analysis) {
-        return ForgeFormatter.formatExecutionCard({
-            intent: analysis.requirement,
-            complexity: analysis.complexity,
-            path: analysis.requiresPipeline ? '编排流程' : '直接执行',
-            plan: analysis.suggestedPhases.length > 0 ? analysis.suggestedPhases : ['分析', '执行', '验证'],
-            estimatedTime: analysis.requiresPipeline ? '30-45分钟' : undefined,
-            clarifyQuestions: analysis.clarifyQuestions,
-        });
-    }
-    /** 处理复杂任务的 Pipeline 决策，返回 HookResponse 或 undefined（继续走简单路径） */
-    async handleComplexTask(analysis, card, event, interventionLevel) {
-        const { pipelineEngine, qualityGate, config } = this.ctx;
-        if (!pipelineEngine || !config.autopilot.auto_start_pipeline)
-            return undefined;
-        if (pipelineEngine.hasActivePipeline(event.project_path)) {
-            logger.info('已有活跃的编排流程');
-            return undefined;
-        }
-        const confirmMode = config.autopilot.pipeline_confirm_mode;
-        if (interventionLevel === 'auto' || confirmMode === 'auto') {
-            return this.autoStartPipeline(analysis, card, event, qualityGate);
-        }
-        if (confirmMode === 'prompt') {
-            return this.promptPipelineChoice(analysis, card, event);
-        }
-        // preview 模式：仅展示，不启动
-        logger.info('预览模式，不启动编排流程');
-        return undefined;
-    }
-    async autoStartPipeline(analysis, card, event, qualityGate) {
-        const pipeline = await this.ctx.pipelineEngine.startPipeline(analysis.requirement, event.project_path, event.session_id);
-        if (qualityGate)
-            qualityGate.setRequirement(analysis.requirement);
-        logger.info(`[Forge:Pipeline] 自动启动：id=${pipeline.id} | tasks=${pipeline.tasks.length}`);
-        const autoMsg = ForgeFormatter.formatModuleNotification('pipeline', `已自动启动完整编排，共 ${pipeline.tasks.length} 个任务\n阶段：${analysis.suggestedPhases.join(' → ')}`);
-        // 加载项目规范并记录
-        const activeConventions = this.ctx.conventionManager.getActiveConventions(event.project_path);
-        const conventionPrompt = this.ctx.conventionManager.getActivePrompt(event.project_path) ?? undefined;
-        if (activeConventions.length > 0) {
-            logger.info(`已加载项目规范：${ForgeFormatter.formatConventionSummary(activeConventions)}`);
-        }
-        const decisionsCtx = await this.readDecisionsContext(analysis.requirement, event.project_path);
-        const context = ForgeFormatter.wrapInQuote(ContextInjector.build({ content: this.buildPlanStartContext(event.project_path), priority: INJECT_PRIORITY.PLAN, topic: 'plan' }, { content: this.buildProfileContext(event.project_path), priority: INJECT_PRIORITY.PROFILE, topic: 'profile' }, { content: conventionPrompt, priority: INJECT_PRIORITY.CONVENTION, topic: 'convention' }, { content: autoMsg, priority: INJECT_PRIORITY.PIPELINE, topic: 'pipeline' }, { content: decisionsCtx, priority: INJECT_PRIORITY.DECISIONS, topic: 'decisions' }));
-        if (analysis.clarifyQuestions?.length) {
-            logger.info(`[Forge:Pipeline] 自动启动 + 注入澄清问题 ${analysis.clarifyQuestions.length} 个`);
-            const clarify = ForgeFormatter.formatClarifyRequest(analysis.clarifyQuestions);
-            return { allow: true, systemMessage: card, additionalContext: ForgeFormatter.mergeContexts(context, clarify) };
-        }
-        // 汇总注入内容
-        const pipelineInjected = ['Pipeline指令'];
-        if (conventionPrompt)
-            pipelineInjected.push(`规范(${activeConventions.map(c => c.id).join(',')})`);
-        logger.info(`自动启动多步骤编排 | 任务数=${pipeline.tasks.length} | 注入=[${pipelineInjected.join(', ')}]`);
-        return { allow: true, systemMessage: card, additionalContext: context };
-    }
-    promptPipelineChoice(analysis, card, event) {
-        const options = ForgeFormatter.formatPipelineOptions(analysis.suggestedPhases, analysis.requirement);
-        this.setSuggestionPending(event.project_path, true);
-        if (analysis.clarifyQuestions?.length) {
-            const clarify = ForgeFormatter.formatClarifyRequest(analysis.clarifyQuestions);
-            logger.info('向用户展示澄清问题 + 编排方案选项');
-            return { allow: true, systemMessage: card, additionalContext: ForgeFormatter.mergeContexts(ForgeFormatter.wrapInQuote(options), clarify) };
-        }
-        logger.info('向用户展示编排方案选项');
-        return { allow: true, systemMessage: card, additionalContext: ForgeFormatter.wrapInQuote(options) };
-    }
-    /**
-     * 简单任务的轻量注入：只注入规范和画像，不生成执行卡片和阶段计划。
-     */
-    buildLightweightResponse(analysis, projectPath) {
-        const activeConventions = this.ctx.conventionManager.getActiveConventions(projectPath);
-        const conventionPrompt = this.ctx.conventionManager.getActivePrompt(projectPath) ?? undefined;
-        if (activeConventions.length > 0) {
-            logger.info(`[轻量注入] 规范：${ForgeFormatter.formatConventionSummary(activeConventions)}`);
-        }
-        const similarSessionCtx = analysis.searchKeywords?.length
-            ? this.buildSimilarSessionContext(analysis.searchKeywords, projectPath)
-            : undefined;
-        const body = ContextInjector.build({ content: this.buildPlanStartContext(projectPath), priority: INJECT_PRIORITY.PLAN, topic: 'plan' }, { content: this.buildProfileContext(projectPath), priority: INJECT_PRIORITY.PROFILE, topic: 'profile' }, { content: similarSessionCtx, priority: INJECT_PRIORITY.HISTORY, minBudget: 500, topic: 'history' }, { content: conventionPrompt, priority: INJECT_PRIORITY.CONVENTION, topic: 'convention' });
-        const injected = [];
-        if (this.injectionCache.get(projectPath)?.profileInjected)
-            injected.push('画像');
-        if (similarSessionCtx)
-            injected.push('相似历史场景');
-        if (conventionPrompt)
-            injected.push(`规范(${activeConventions.map(c => c.id).join(',')})`);
-        logger.info(`处理完成：轻量注入 | 复杂度=simple | 注入=[${injected.join(', ') || '无'}]`);
-        if (!body)
-            return undefined;
-        return {
-            allow: true,
-            additionalContext: ForgeFormatter.wrapInQuote(body),
-        };
-    }
-    async buildSimpleResponse(analysis, card, projectPath) {
-        const directive = this.ctx.intentEngine.generateDirective(analysis);
-        const decisionsContext = await this.readDecisionsContext(analysis.requirement, projectPath);
-        const similarSessionCtx = analysis.searchKeywords?.length
-            ? this.buildSimilarSessionContext(analysis.searchKeywords, projectPath)
-            : undefined;
-        const graphContext = analysis.searchKeywords?.length
-            ? await this.buildGraphContext(analysis.searchKeywords, projectPath)
-            : undefined;
-        // 加载项目规范并记录
-        const activeConventions = this.ctx.conventionManager.getActiveConventions(projectPath);
-        const conventionPrompt = this.ctx.conventionManager.getActivePrompt(projectPath) ?? undefined;
-        if (activeConventions.length > 0) {
-            logger.info(`已加载项目规范：${ForgeFormatter.formatConventionSummary(activeConventions)}`);
-        }
-        if (analysis.clarifyQuestions?.length) {
-            const clarify = ForgeFormatter.formatClarifyRequest(analysis.clarifyQuestions);
-            logger.info(`注入澄清问题 ${analysis.clarifyQuestions.length} 个`);
-            return {
-                allow: true,
-                systemMessage: card,
-                additionalContext: clarify,
-            };
-        }
-        const body = ContextInjector.build({ content: this.buildPlanStartContext(projectPath), priority: INJECT_PRIORITY.PLAN, topic: 'plan' }, { content: this.buildProfileContext(projectPath), priority: INJECT_PRIORITY.PROFILE, topic: 'profile' }, { content: conventionPrompt, priority: INJECT_PRIORITY.CONVENTION, topic: 'convention' }, { content: directive ?? undefined, priority: INJECT_PRIORITY.DIRECTIVE, topic: 'directive' }, { content: similarSessionCtx, priority: INJECT_PRIORITY.HISTORY, minBudget: 500, topic: 'history' }, { content: graphContext, priority: INJECT_PRIORITY.HISTORY - 1, minBudget: 300, topic: 'graph' }, { content: decisionsContext, priority: INJECT_PRIORITY.DECISIONS, topic: 'decisions' });
-        // 汇总注入内容
-        const injected = [];
-        if (this.injectionCache.get(projectPath)?.profileInjected)
-            injected.push('画像');
-        if (conventionPrompt)
-            injected.push(`规范(${activeConventions.map(c => c.id).join(',')})`);
-        if (directive)
-            injected.push('执行指令');
-        if (decisionsContext)
-            injected.push('决策历史');
-        if (similarSessionCtx)
-            injected.push('相似历史场景');
-        if (graphContext)
-            injected.push('图谱成功路径');
-        const inferredRole = this.inferCurrentRole(analysis.requirement, activeConventions);
-        const roleStr = inferredRole ? ` | 当前角色=${inferredRole.name}` : '';
-        logger.info(`处理完成：直接执行 | 复杂度=${analysis.complexity}${roleStr} | 注入=[${injected.join(', ') || '无'}]`);
-        return {
-            allow: true,
-            systemMessage: card,
-            additionalContext: body ? ForgeFormatter.wrapInQuote(body) : undefined,
-        };
-    }
-    /**
-     * 知识图谱上下文：查找历史成功路径，注入为参考上下文
-     */
-    async buildGraphContext(keywords, projectPath) {
-        const graph = this.ctx.retrospectiveEngine?.getKnowledgeGraph();
-        if (!graph || keywords.length === 0)
-            return undefined;
-        try {
-            const paths = await graph.findSimilarSuccessfulPaths(projectPath, keywords, 3);
-            if (paths.length === 0)
-                return undefined;
-            const lines = ['[历史成功路径参考]'];
-            for (const p of paths) {
-                lines.push(`- 需求：${p.requirement}`);
-                if (p.decisions.length > 0)
-                    lines.push(`  决策：${p.decisions.join(' → ')}`);
-                lines.push(`  结果：${p.outcome}`);
-            }
-            return lines.join('\n');
-        }
-        catch {
-            return undefined;
-        }
-    }
-    /**
-     * FTS5 历史场景检索：按 searchKeywords 查找最相似的历史 session，
-     * 读取对应 decisions.md 片段注入为"相似历史场景"上下文。
-     * 每个项目 session 内首次调用时执行；无结果或已注入则返回 undefined。
-     */
-    buildSimilarSessionContext(keywords, projectPath) {
-        if (!keywords || keywords.length === 0)
-            return undefined;
-        try {
-            const { storage } = this.ctx;
-            const hits = storage.searchByKeywords(keywords, projectPath, 10);
-            if (hits.length === 0)
-                return undefined;
-            // 按 session_id 去重，取最近 3 个不同 session
-            const sessionIds = [];
-            for (const ev of hits) {
-                if (!sessionIds.includes(ev.session_id) && sessionIds.length < 3) {
-                    sessionIds.push(ev.session_id);
-                }
-            }
-            if (sessionIds.length === 0)
-                return undefined;
-            // 优先从 injectionCache 取已读取的 rawTail，避免重复 readFileSync
-            const cache = this.injectionCache.get(projectPath);
-            let rawTail;
-            if (cache?.decisionsRawTail) {
-                rawTail = cache.decisionsRawTail;
-            }
-            else {
-                const fileData = this.readDecisionsFile(projectPath);
-                if (!fileData)
-                    return undefined;
-                rawTail = fileData.tail;
-            }
-            if (!rawTail.trim())
-                return undefined;
-            const snippet = rawTail.length > 600 ? '...\n' + rawTail.slice(-600) : rawTail;
-            const sessionList = sessionIds.map(id => `- ${id.slice(0, 8)}...`).join('\n');
-            return `[相似历史场景]\n关键词：${keywords.slice(0, 5).join('、')}\n匹配会话：\n${sessionList}\n\n历史决策摘要：\n\`\`\`\n${snippet}\n\`\`\``;
-        }
-        catch {
-            return undefined;
-        }
-    }
-    /**
-     * 增量读取 decisions.md 末尾 tailBytes 字节，写入 injectionCache。
-     * 指纹使用 size:mtimeMs，只需 stat() 即可判断缓存有效性。
-     * 返回 null 表示文件不存在或读取失败。
-     */
-    readDecisionsFile(projectPath, tailBytes = 2048) {
-        try {
-            const decisionsPath = path.join(projectPath, '.claude-forge', 'decisions.md');
-            if (!fs.existsSync(decisionsPath))
-                return null;
-            const stat = fs.statSync(decisionsPath);
-            if (stat.size === 0)
-                return null;
-            const readSize = Math.min(tailBytes, stat.size);
-            const buf = Buffer.alloc(readSize);
-            const fd = fs.openSync(decisionsPath, 'r');
+        const stages = this.createStages();
+        const proj = relPath(event.project_path);
+        logger.info(`[Forge:编排] 开始 | 项目=${proj} | prompt="${userPrompt.slice(0, 60)}${userPrompt.length > 60 ? '…' : ''}"`);
+        let stageIdx = 0;
+        for (const stage of stages) {
+            stageIdx++;
             try {
-                fs.readSync(fd, buf, 0, readSize, stat.size - readSize);
-            }
-            finally {
-                fs.closeSync(fd);
-            }
-            const fingerprint = `${stat.size}:${stat.mtimeMs}`;
-            const tail = buf.toString('utf-8');
-            // 写入缓存（只更新 rawTail 和 fingerprint，不覆盖 decisionsResult）
-            const cache = this.injectionCache.get(projectPath);
-            if (!cache || cache.decisionsKey !== fingerprint) {
-                this.injectionCache.set(projectPath, {
-                    ...(cache ?? { decisionsKey: '', decisionsResult: '', decisionsRawTail: '', profileInjected: false, planContextInjected: false, skillSuggestionsInjected: false }),
-                    decisionsKey: fingerprint,
-                    decisionsRawTail: tail,
-                });
-            }
-            return { tail, fingerprint };
-        }
-        catch {
-            return null;
-        }
-    }
-    /**
-     * 读取项目决策历史，优先使用树索引推理检索，失败时降级到关键词切片。
-     * 方案 A：同一 session 内 decisions.md 内容不变则直接复用缓存，不重复注入。
-     */
-    async readDecisionsContext(requirement, projectPath) {
-        // 只在涉及架构/设计/重构时注入，避免噪音
-        const needsContext = /架构|设计|重构|优化|改造|迁移|升级|architecture|design|refactor/i.test(requirement);
-        if (!needsContext)
-            return undefined;
-        try {
-            const decisionsPath = path.join(projectPath, '.claude-forge', 'decisions.md');
-            if (!fs.existsSync(decisionsPath))
-                return undefined;
-            // 用 stat 指纹（size:mtimeMs）判断缓存有效性
-            const stat = fs.statSync(decisionsPath);
-            const fingerprint = `${stat.size}:${stat.mtimeMs}`;
-            const cache = this.injectionCache.get(projectPath);
-            if (cache?.decisionsKey === fingerprint) {
-                logger.info('[Forge:决策] 内容未变，复用缓存');
-                return cache.decisionsResult || undefined;
-            }
-            // 尝试树索引推理检索
-            const treeResult = await this.readDecisionsViaTreeIndex(requirement, decisionsPath);
-            if (treeResult) {
-                const result = ForgeFormatter.formatModuleNotification('decisions', `项目决策历史（推理检索）：\n${treeResult}`);
-                this.injectionCache.set(projectPath, {
-                    ...(cache ?? { decisionsKey: '', decisionsResult: '', decisionsRawTail: '', profileInjected: false, planContextInjected: false, skillSuggestionsInjected: false }),
-                    decisionsKey: fingerprint,
-                    decisionsResult: result,
-                    decisionsRawTail: '',
-                });
-                return result;
-            }
-            // 降级：关键词切片
-            logger.info('[Forge:决策] 树索引不可用，降级到关键词切片');
-            return this.readDecisionsContextFallback(requirement, projectPath, fingerprint);
-        }
-        catch {
-            return undefined;
-        }
-    }
-    /**
-     * 树索引推理检索（新方法）
-     */
-    async readDecisionsViaTreeIndex(requirement, decisionsPath) {
-        try {
-            // 检查树索引是否存在且最新
-            if (TreeIndexEngine.isStale(decisionsPath)) {
-                logger.info('[TreeIndex] 索引过期或不存在，跳过推理检索');
-                return null;
-            }
-            const index = TreeIndexEngine.loadFromFile(decisionsPath);
-            if (!index || index.structure.length === 0)
-                return null;
-            const api = this.ctx.intentEngine?.getProvider();
-            if (!api)
-                return null;
-            const engine = new TreeIndexEngine(api);
-            const result = await engine.search(index, requirement);
-            if (result && result.length > 50) {
-                logger.info(`[TreeIndex] 推理检索成功，返回 ${result.length} 字符`);
-                return result;
-            }
-            return null;
-        }
-        catch (err) {
-            logger.warn(`[TreeIndex] 推理检索失败：${err}`);
-            return null;
-        }
-    }
-    /**
-     * 降级方案：关键词切片（原有逻辑）
-     */
-    readDecisionsContextFallback(requirement, projectPath, fingerprint) {
-        const cache = this.injectionCache.get(projectPath);
-        const fileData = this.readDecisionsFile(projectPath);
-        if (!fileData)
-            return undefined;
-        const { tail } = fileData;
-        if (!tail.trim())
-            return undefined;
-        // 按关键词过滤相关决策块
-        const keywords = requirement
-            .split(/[\s，,、。.！!？?]+/)
-            .map(w => w.trim())
-            .filter(w => w.length >= 2);
-        const blocks = tail.split(/(?=^## )/m).filter(b => b.trim());
-        let relevant;
-        if (keywords.length > 0) {
-            relevant = blocks.filter(block => keywords.some(kw => block.toLowerCase().includes(kw.toLowerCase())));
-            if (relevant.length === 0)
-                relevant = blocks.slice(-2);
-        }
-        else {
-            relevant = blocks.slice(-2);
-        }
-        let snippet = relevant.join('\n').trim();
-        if (snippet.length > 600)
-            snippet = '...\n' + snippet.slice(-600);
-        const result = ForgeFormatter.formatModuleNotification('decisions', `项目决策历史（关键词匹配）：\n\`\`\`\n${snippet}\n\`\`\``);
-        this.injectionCache.set(projectPath, {
-            ...(cache ?? { decisionsKey: '', decisionsResult: '', decisionsRawTail: '', profileInjected: false, planContextInjected: false, skillSuggestionsInjected: false }),
-            decisionsKey: fingerprint,
-            decisionsResult: result,
-            decisionsRawTail: tail,
-        });
-        logger.info(`[Forge:决策] 关键词匹配注入 ${relevant.length} 个块（${snippet.length} 字符）`);
-        return result;
-    }
-    /**
-     * 处理用户对 Pipeline 选择的回复（A/B/C）
-     */
-    async startPipelineFromChoice(choice, event) {
-        const option = PIPELINE_OPTIONS[choice];
-        if (choice === 'manual') {
-            const msg = ForgeFormatter.formatModuleNotification('pipeline', '已切换到手动控制模式，请逐步告诉我你的需求');
-            logger.info('用户选择了手动模式');
-            return { allow: true, additionalContext: ForgeFormatter.wrapInQuote(msg) };
-        }
-        const requirement = event.tool_input?.user_prompt || '用户需求';
-        const pipeline = await this.ctx.pipelineEngine.startPipeline(requirement, event.project_path, event.session_id);
-        if (this.ctx.qualityGate)
-            this.ctx.qualityGate.setRequirement(requirement);
-        logger.info(`已启动编排（${option.description}）：id=${pipeline.id} | 任务数=${pipeline.tasks.length}`);
-        const msg = ForgeFormatter.formatModuleNotification('pipeline', `已启动${option.description}，共 ${pipeline.tasks.length} 个任务\n阶段：${option.phases.join(' → ')}`);
-        return { allow: true, additionalContext: ForgeFormatter.wrapInQuote(msg) };
-    }
-    /**
-     * 根据用户需求关键词推断当前最匹配的 Convention 角色。
-     * 纯关键词匹配，不调用 AI，用于日志展示。
-     */
-    inferCurrentRole(requirement, conventions) {
-        const input = requirement.toLowerCase();
-        // 角色关键词映射（按优先级排序，先匹配先返回）
-        const roleKeywords = [
-            // 需求/产品阶段
-            { keywords: ['需求', '用户故事', '产品', '规格', '验收', 'spec', 'requirement'], roleKeys: ['product_manager'] },
-            // 架构/设计阶段
-            { keywords: ['架构', '设计', '方案', '技术选型', 'api', '数据模型', 'schema'], roleKeys: ['architect'] },
-            // 测试/安全网阶段
-            { keywords: ['测试', '覆盖', '安全网', 'test', '特征测试', '边界'], roleKeys: ['safety_net_engineer', 'verification_engineer'] },
-            // 审查阶段
-            { keywords: ['审查', 'review', '代码审查', '检查', '质量'], roleKeys: ['tech_lead', 'verification_engineer'] },
-            // 理解/分析阶段
-            { keywords: ['理解', '分析', '阅读', '调查', '排查', '诊断', 'debug'], roleKeys: ['code_archaeologist'] },
-            // 编码/实现阶段（最宽泛，放最后）
-            { keywords: ['实现', '编码', '开发', '修复', '重构', '优化', '改', '加', '写', 'fix', 'implement', 'refactor'], roleKeys: ['developer', 'surgeon'] },
-        ];
-        // 收集所有 Convention 的角色
-        const allRoles = new Map();
-        for (const conv of conventions) {
-            for (const [key, role] of Object.entries(conv.roles ?? {})) {
-                allRoles.set(key, role);
-            }
-        }
-        if (allRoles.size === 0)
-            return null;
-        // 按关键词匹配
-        for (const { keywords, roleKeys } of roleKeywords) {
-            if (keywords.some(kw => input.includes(kw))) {
-                for (const rk of roleKeys) {
-                    const role = allRoles.get(rk);
-                    if (role)
-                        return role;
+                const result = await stage.execute(ctx);
+                if (result.shouldTerminate) {
+                    logger.info(`[Forge:编排] ✓ [${stageIdx}/${stages.length}] ${stage.name} → 终止${result.response ? '（有响应）' : '（无响应）'}`);
+                    return result.response ?? undefined;
                 }
-            }
-        }
-        // 默认返回开发工程师（最常见的角色）
-        return allRoles.get('developer') ?? allRoles.get('surgeon') ?? null;
-    }
-    /**
-     * P4：负向重启回溯修正
-     * 检测到 dissatisfied 信号时，将上一个 session（24h 内）的满意度评分下调（×0.5，最低 0.1）
-     */
-    async applyNegativeRestartPenalty(projectPath, currentSessionId) {
-        try {
-            const last = this.ctx.storage.getLastCompletedTaskSession(projectPath);
-            if (!last)
-                return;
-            if (last.session_id === currentSessionId)
-                return;
-            // 只回溯 24h 内的上一 session
-            if (last.ended_at) {
-                const age = Date.now() - new Date(last.ended_at).getTime();
-                if (age > 24 * 60 * 60 * 1000)
-                    return;
-            }
-            const prevScore = last.satisfaction_score ?? 0.5;
-            const newScore = Math.max(0.1, prevScore * 0.5);
-            // 更新 task_sessions.satisfaction_score
-            this.ctx.storage.updateTaskSessionSatisfaction(last.id, newScore);
-            // 写入 satisfaction_signals 记录此次回溯修正
-            this.ctx.storage.insertSatisfactionSignal({
-                id: `ss_restart_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
-                session_id: last.session_id,
-                project_path: projectPath,
-                task_session_id: last.id,
-                signal_type: 'negative_restart_penalty',
-                signal_value: newScore - prevScore, // 负数，表示下调幅度
-                weight: 1.0,
-                raw_data: { prev_score: prevScore, new_score: newScore, triggered_by_session: currentSessionId },
-            });
-            logger.info(`[Forge:满意度] 检测到负向重启，回溯修正上一 session 评分：${prevScore.toFixed(3)} → ${newScore.toFixed(3)}`);
-        }
-        catch (err) {
-            logger.warn(`[Forge:满意度] 负向重启回溯修正失败：${err}`);
-        }
-    }
-    /** 构建用户上下文（供 IntentEngine 有状态分析） */
-    buildUserContext(projectPath) {
-        const profile = this.ctx.profileManager.get();
-        const recentSatisfaction = this.ctx.storage.getSatisfactionHistory(projectPath, 10);
-        const avgSatisfaction = recentSatisfaction.length > 0
-            ? recentSatisfaction.reduce((sum, row) => sum + row.score, 0) / recentSatisfaction.length
-            : 0.5;
-        const complexityCount = { simple: 0, moderate: 0, complex: 0 };
-        for (const row of recentSatisfaction) {
-            if (row.complexity === 'simple' || row.complexity === 'moderate' || row.complexity === 'complex') {
-                complexityCount[row.complexity]++;
-            }
-        }
-        const preferredComplexity = (Object.entries(complexityCount).sort((a, b) => b[1] - a[1])[0]?.[0] ?? 'moderate');
-        const experienceLevelMap = {
-            junior: 'beginner',
-            mid: 'intermediate',
-            senior: 'intermediate',
-            expert: 'expert',
-        };
-        return {
-            work_style: profile.work_style ?? 'balanced',
-            experience_level: experienceLevelMap[profile.experience_level ?? 'mid'],
-            skip_rate: profile.skip_rate ?? 0,
-            override_rate: profile.override_rate ?? 0,
-            avg_satisfaction: avgSatisfaction,
-            preferred_complexity: preferredComplexity,
-        };
+                if (result.skipRemaining) {
+                    logger.info(`[Forge:编排] ✓ [${stageIdx}/${stages.length}] ${stage.name} → 跳过剩余`);
+                    break;
+                }
+                logger.debug(`[Forge:编排] · [${stageIdx}/${stages.length}] ${stage.name} → 继续`);
+            }
+            catch (err) {
+                logger.error(`[Forge:编排] ✗ [${stageIdx}/${stages.length}] ${stage.name} 执行失败：${err}`);
+            }
+        }
+        logger.info(`[Forge:编排] 完成 | 项目=${proj} | 所有 Stage 通过，无响应`);
+    }
+    createStages() {
+        return [
+            new FailureSignalStage(),
+            new ActiveInterventionStage(),
+            new InitPromptStage(),
+            new SkillSuggestionsStage(),
+            new ConversationalConfigStage(this.ctx),
+            new EngineCheckStage(),
+            new PipelineReplyStage(),
+            new EscInterruptStage(),
+            new PipelineActiveStage(),
+            new CooldownStage(),
+            new IntentAnalysisStage(),
+            new StrategyAdviceStage(),
+            new TemplateRouteStage(),
+            new PlanResumeStage(),
+            new PlanEnforcementStage(),
+            new InterventionLevelStage(),
+            new SimpleTaskStage(),
+            new ComplexTaskStage(),
+            new ModerateTaskStage(),
+        ];
     }
 }
 //# sourceMappingURL=user-prompt-handler.js.map