@winspan/claude-forge 2.7.0 → 3.0.0

package/dist/pipeline/index.js

@@ -1,16 +1,16 @@
 import { PipelineStore } from './store.js';
 import { PipelineAnalyzer } from './analyzer.js';
-import { PhaseManager } from './phase-manager.js';
 import { DynamicNodeExecutor } from './dynamic-node-executor.js';
-import { PhaseArtifactGenerator } from './artifact-generator.js';
 import { PipelineReportGenerator } from './report-generator.js';
 import { PHASE_LABELS } from './types.js';
 import { PIPELINE, TIME } from '../constants.js';
 import { logger } from '../utils/logger.js';
 import { ArtifactManager } from '../utils/artifact-manager.js';
-import { memoryManager } from '../utils/memory-manager.js';
+import { cacheRegistry } from '../core/cache-registry.js';
 import { MutexLock } from '../utils/mutex-lock.js';
 import { buildForgeResumeEnvelope, stripForgeResumeBlocks } from '../utils/forge-resume-block.js';
+import { getPlanPhaseLabels, stringifyExecutionPlanMeta, } from './execution-plan.js';
+import { ExecutionPlanBuilder } from './execution-plan-builder.js';
 import fsPromises from 'fs/promises';
 import path from 'path';
 export { TemplateRegistry } from './template-registry.js';
@@ -18,7 +18,7 @@ export { TemplateRouter } from './template-router.js';
 export class PipelineEngine {
     store;
     analyzer;
-    phaseManager;
+    planBuilder;
     dynamicNodeExecutor;
     api;
     storage;
@@ -27,7 +27,7 @@ export class PipelineEngine {
     /** 上次注入的指令指纹（pipelineId:phase:completed/total），相同则跳过重复注入 */
     lastInstructionKey;
     /** 0/0 状态已通知的 key（projectPath:phase），避免每次 PreToolUse 重复注入空阶段提示（1小时 TTL 自动清理） */
-    emptyPhaseNotified = memoryManager.register('pipeline:emptyNotified', {
+    emptyPhaseNotified = cacheRegistry.register('pipeline:emptyNotified', {
         max: 100,
         ttl: TIME.HOUR
     });
@@ -35,24 +35,24 @@ export class PipelineEngine {
     pipelineLock = new MutexLock('Pipeline');
     /** CLAUDE.md 写入器（可选，用于统一加锁写入） */
     claudeMdWriter;
-    constructor(storage, api, conventionManager, claudeMdWriter) {
+    constructor(storage, api, conventionManager, claudeMdWriter, pendingPromptSink) {
         this.store = new PipelineStore(storage);
         this.analyzer = new PipelineAnalyzer(api, conventionManager);
-        this.phaseManager = new PhaseManager(this.store);
-        this.dynamicNodeExecutor = new DynamicNodeExecutor(api);
+        this.planBuilder = new ExecutionPlanBuilder(this.analyzer);
+        this.dynamicNodeExecutor = new DynamicNodeExecutor(api, pendingPromptSink);
         this.api = api;
         this.storage = storage;
-        this.activePipelines = memoryManager.register('pipeline:active', { max: 50 });
-        this.lastInstructionKey = memoryManager.register('pipeline:instruction', { max: 50 });
+        this.activePipelines = cacheRegistry.register('pipeline:active', { max: 50 });
+        this.lastInstructionKey = cacheRegistry.register('pipeline:instruction', { max: 50 });
         this.claudeMdWriter = claudeMdWriter;
     }
     /** 检测到 ESC 中断、等待用户确认意图的项目路径集合（2小时 TTL，用户可能长时间不确认） */
-    interruptedProjects = memoryManager.register('pipeline:interrupted', {
+    interruptedProjects = cacheRegistry.register('pipeline:interrupted', {
         max: 50,
         ttl: TIME.TWO_HOURS
     });
     /** 硬阻断状态（key=projectPath）：用于 PreToolUse 拦截后续工具调用 */
-    blockedProjects = memoryManager.register('pipeline:blocked', {
+    blockedProjects = cacheRegistry.register('pipeline:blocked', {
         max: 50,
         ttl: TIME.TWO_HOURS
     });
@@ -123,12 +123,11 @@ export class PipelineEngine {
         }
         if (!pipeline || pipeline.phase === 'done')
             return null;
-        // 刷新任务列表
-        pipeline.tasks = this.store.getTasks(pipeline.id);
         // 计算当前进度指纹，相同时跳过注入（避免每次 PreToolUse 重复输出相同进度）
         // 注意：动态流水线（dp_）禁用去重，保证持续注入节点执行指令，避免 Claude 丢失上下文后停写
         const isDynamicPipeline = pipeline.id.startsWith('dp_');
         if (!isDynamicPipeline) {
+            pipeline.tasks = this.store.getTasks(pipeline.id);
             // total=0 时使用 emptyPhaseNotified 去重：首次注入后标记，状态变化时清除
             const progress = this.store.getPhaseProgress(pipeline.id, pipeline.phase);
             const instrKey = `${pipeline.id}:${pipeline.phase}:${progress.completed}/${progress.total}`;
@@ -151,9 +150,13 @@ export class PipelineEngine {
             const dynPipeline = await this.storage.repositories.dynamicPipelines.getById(pipeline.id);
             if (!dynPipeline)
                 return null;
+            pipeline = this.dynamicPipelineToBridge(dynPipeline);
+            this.activePipelines.set(projectPath, pipeline);
             return this.dynamicNodeExecutor.getInstruction(dynPipeline);
         }
-        return this.phaseManager.getPhaseInstruction(pipeline);
+        // Legacy Pipeline 不再处理（所有新 Pipeline 均为 dp_ 前缀）
+        logger.warn(`[Pipeline] Legacy Pipeline ${pipeline.id} 不再支持，请重新创建`);
+        return null;
     }
     /**
      * PostToolUse 处理：跟踪进度，检查阶段推进
@@ -209,85 +212,9 @@ export class PipelineEngine {
             }
             return dynamicResult;
         }
-        // 刷新任务列表
-        pipeline.tasks = this.store.getTasks(pipeline.id);
-        const result = await this.phaseManager.checkAndAdvance(pipeline, event, qualityGate);
-        // 持久化阶段推进状态（重启后可恢复）
-        this.persistPhaseState(pipeline.id, pipeline.phase);
-        if (result.qualityBlocked) {
-            if (result.blocking) {
-                this.markBlocked(event.project_path, pipeline.id, result.systemMessage || '[Pipeline 已阻断] 质量门禁 must 规范违反，必须修复后重启 Pipeline');
-            }
-            return { message: null, qualityBlocked: true, qualityIssues: result.qualityIssues, systemMessage: result.systemMessage, qualityLevel: result.qualityLevel, fixAttempts: result.fixAttempts, blocking: result.blocking };
-        }
-        if (result.advanced && result.newPhase) {
-            const completedPhase = pipeline.phase; // 推进前的阶段
-            // 阶段产物生成：异步非阻塞，失败只记录质量问题，不阻断推进
-            const pipelineSnapshot = { ...pipeline };
-            const artifactQualityIssues = [];
-            try {
-                await new PhaseArtifactGenerator(pipeline.projectPath, this.api, this.storage, pipelineSnapshot)
-                    .generateForPhase(completedPhase, pipelineSnapshot, event.session_id);
-            }
-            catch (err) {
-                const issueMsg = `[阶段产物] ${PHASE_LABELS[completedPhase]} 产物生成失败：${err}`;
-                logger.warn(`[Forge:阶段产物] ${issueMsg}`);
-                artifactQualityIssues.push(issueMsg);
-                // 产物失败不阻断推进，继续执行
-            }
-            pipeline.phase = result.newPhase;
-            // 阶段推进后清除指纹缓存和空阶段标记，确保新阶段指令能正常注入
-            this.lastInstructionKey.delete(event.project_path);
-            this.emptyPhaseNotified.delete(`${event.project_path}:${completedPhase}`);
-            // 阶段推进时更新 CLAUDE.md 续接状态，确保跨会话后 Claude 能快速恢复上下文
-            this.persistPipelineStateToClaude(pipeline, event.project_path);
-            if (result.newPhase === 'done') {
-                this.activePipelines.delete(event.project_path);
-                this.clearBlocked(event.project_path);
-                // 统计数据
-                const totalTasks = pipeline.tasks.length;
-                const completedTasks = pipeline.tasks.filter(t => t.status === 'completed').length;
-                const failedTasks = pipeline.tasks.filter(t => t.status === 'failed').length;
-                const completedPhases = pipeline.plannedPhases?.filter(p => {
-                    const phaseTasks = pipeline.tasks.filter(t => t.phase === p);
-                    return phaseTasks.length > 0 && phaseTasks.every(t => t.status === 'completed');
-                }) || [];
-                // Pipeline 完成报告
-                let reportMessage = `[Forge Pipeline] ✅ 项目已完成所有阶段！
-📋 需求：${pipeline.requirement}
-📊 统计：
-  • 总任务数：${totalTasks}
-  • 已完成：${completedTasks}
-  • 失败：${failedTasks}
-  • 完成阶段：${completedPhases.map(p => PHASE_LABELS[p]).join('、')}`;
-                if (qualityGate) {
-                    try {
-                        const reportGenerator = new PipelineReportGenerator(qualityGate.getIssueTracker(), this.phaseManager);
-                        const markdown = reportGenerator.generate(pipeline);
-                        reportGenerator.persist(pipeline.projectPath, markdown);
-                        reportMessage = `${reportMessage}\n\n${markdown}`;
-                    }
-                    catch (err) {
-                        logger.warn(`[Pipeline] 完成报告生成失败：${err}`);
-                    }
-                }
-                return { message: reportMessage };
-            }
-            return {
-                message: `[Forge Pipeline] 阶段推进：${PHASE_LABELS[result.newPhase]}`,
-                gapMessage: result.gapMessage,
-                qualityLevel: result.qualityLevel,
-                advanceReason: result.advanceReason,
-                systemMessage: result.systemMessage,
-                qualityIssues: artifactQualityIssues.length > 0 ? artifactQualityIssues : undefined,
-            };
-        }
-        // 非阶段推进时，也定期更新 CLAUDE.md（每 20 次工具调用一次）
-        const eventCount = this.phaseManager.exportPhaseState(`${pipeline.id}:${pipeline.phase}`)?.eventCount ?? 0;
-        if (eventCount > 0 && eventCount % 20 === 0) {
-            this.persistPipelineStateToClaude(pipeline, event.project_path);
-        }
-        return { message: null, qualityLevel: result.qualityLevel };
+        // Legacy Pipeline 不再处理（所有新 Pipeline 均为 dp_ 前缀）
+        logger.warn(`[Pipeline] Legacy Pipeline ${pipeline.id} 不再支持，请重新创建`);
+        return { message: null };
     }
     /**
      * 动态流水线 PostToolUse 处理
@@ -366,7 +293,7 @@ export class PipelineEngine {
   • 已完成：${completedNodes}`;
                 if (qualityGate) {
                     try {
-                        const reportGenerator = new PipelineReportGenerator(qualityGate.getIssueTracker(), this.phaseManager);
+                        const reportGenerator = new PipelineReportGenerator(qualityGate.getIssueTracker(), this.dynamicNodeExecutor);
                         const markdown = reportGenerator.generate(pipeline);
                         reportGenerator.persist(pipeline.projectPath, markdown);
                         reportMessage = `${reportMessage}\n\n${markdown}`;
@@ -442,81 +369,107 @@ ${taskSummary}
     /**
      * 启动新 Pipeline
      */
-    async startPipeline(requirement, projectPath, sessionId) {
+    async startPipeline(requirement, projectPath, sessionId, analysis) {
         logger.info(`[Pipeline] 启动中（模式：dynamic）："${requirement}"`);
-        this.clearBlocked(projectPath); // 清理旧的阻断状态
-        return this.startDynamicPipeline(requirement, projectPath, sessionId);
+        this.clearBlocked(projectPath);
+        const fallbackAnalysis = analysis ?? {
+            complexity: 'moderate',
+            requiresPipeline: true,
+            requirement,
+            reasoning: 'PipelineEngine 启动时未提供显式意图分析，使用默认编排分析',
+            estimatedFiles: 1,
+            suggestedPhases: [],
+        };
+        const plan = await this.buildExecutionPlan(requirement, projectPath, sessionId, fallbackAnalysis);
+        return this.startPipelineFromPlan(plan);
+    }
+    /**
+     * 生成统一执行计划（动态流水线唯一事实来源）
+     */
+    async buildExecutionPlan(requirement, projectPath, sessionId, analysis, template, templateRoute) {
+        return this.planBuilder.build({
+            requirement,
+            projectPath,
+            sessionId,
+            analysis,
+            template,
+            templateRoute: templateRoute ?? null,
+        });
     }
     /**
-     * 启动动态节点 Pipeline（Dynamic 模式）
-     *
-     * 使用 DynamicPipelineRepository 创建流水线记录，
-     * 通过 analyzer.decompose 分析需求，生成顺序依赖的 DynamicNode 列表，
-     * 并以 Bridge Pattern 返回兼容 Pipeline 接口的对象。
+     * 从统一执行计划启动动态 Pipeline。
      */
-    async startDynamicPipeline(requirement, projectPath, sessionId) {
-        logger.info(`[Pipeline:Dynamic] 🚀 启动动态流水线："${requirement}" | 项目=${projectPath}`);
-        // 1. 使用 analyzer 分析需求，获取规划阶段和复杂度
-        const analysis = await this.analyzer.decompose(requirement, projectPath);
-        const { plannedPhases, complexity, taskType, techStack, reasoning, phaseArtifacts } = analysis;
-        // 2. 生成 Pipeline ID
+    async startPipelineFromPlan(plan) {
+        logger.info(`[Pipeline:Dynamic] 🚀 启动动态流水线："${plan.requirement}" | 项目=${plan.projectPath} | source=${plan.source}`);
+        this.clearBlocked(plan.projectPath);
+        return this.materializeDynamicPipeline(plan);
+    }
+    async materializeDynamicPipeline(plan) {
         const pipelineId = `dp_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
-        // 3. 将 plannedPhases 转换为 DynamicNode 列表（顺序依赖）
-        const nodes = plannedPhases.map((phaseId, index) => ({
+        const nodes = plan.stages.map((stage, index) => ({
             id: `${pipelineId}_node_${index}`,
-            nodeTypeId: phaseId,
+            nodeTypeId: stage.nodeTypeId,
             status: (index === 0 ? 'in_progress' : 'pending'),
             dependencies: index > 0 ? [`${pipelineId}_node_${index - 1}`] : [],
         }));
-        // 4. 创建 DynamicPipeline 记录
+        const reasoningMeta = stringifyExecutionPlanMeta({
+            currentNodeId: nodes[0]?.id,
+            originalReasoning: plan.reasoning,
+            executionPlan: plan,
+            templateId: plan.templateId,
+            templateName: plan.templateName,
+            source: plan.source,
+        });
         await this.storage.repositories.dynamicPipelines.create({
             id: pipelineId,
-            requirement,
-            projectPath,
-            sessionId,
-            complexity,
-            reasoning: JSON.stringify({ currentNodeId: nodes[0]?.id, originalReasoning: reasoning }),
+            requirement: plan.requirement,
+            projectPath: plan.projectPath,
+            sessionId: plan.sessionId,
+            templateId: plan.templateId,
+            complexity: plan.complexity,
+            reasoning: reasoningMeta,
             status: 'in_progress',
+            executionPlan: plan,
         });
-        // 5. 存储节点
         if (nodes.length > 0) {
             await this.storage.repositories.dynamicPipelines.createNodes(pipelineId, nodes);
         }
-        // 6. 设置 currentNodeId
         if (nodes[0]) {
             await this.storage.repositories.dynamicPipelines.updateCurrentNode(pipelineId, nodes[0].id);
         }
-        // 7. 构建 Pipeline 兼容对象（Bridge Pattern：DynamicPipeline → Pipeline）
         const now = new Date().toISOString();
-        const legacyPipeline = {
+        const pipeline = {
             id: pipelineId,
-            requirement,
-            projectPath,
-            sessionId,
+            requirement: plan.requirement,
+            projectPath: plan.projectPath,
+            sessionId: plan.sessionId,
             phase: nodes[0]?.nodeTypeId ?? 'code',
-            tasks: nodes.map(node => ({
+            tasks: nodes.map((node, index) => ({
                 id: node.id,
-                title: PHASE_LABELS[node.nodeTypeId] || node.nodeTypeId,
+                title: plan.stages[index]?.name ?? (PHASE_LABELS[node.nodeTypeId] || node.nodeTypeId),
                 phase: node.nodeTypeId,
                 status: node.status === 'in_progress' ? 'in_progress' : node.status === 'completed' ? 'completed' : 'pending',
-                description: `动态节点：${node.nodeTypeId}`,
+                description: plan.tasks[index]?.description ?? `动态节点：${node.nodeTypeId}`,
                 dependencies: node.dependencies,
+                source: plan.source,
             })),
-            techStack,
-            complexity,
-            taskType,
-            plannedPhases,
-            phaseArtifacts,
-            reasoning,
+            techStack: plan.techStack,
+            complexity: plan.complexity,
+            taskType: plan.taskType,
+            plannedPhases: plan.stages.map(stage => stage.phase),
+            phaseArtifacts: Object.fromEntries(plan.stages.map(stage => [stage.phase, stage.derivedReports])),
+            reasoning: plan.reasoning,
+            templateId: plan.templateId,
+            executionPlan: plan,
             createdAt: now,
             updatedAt: now,
         };
-        // 8. 缓存到内存，重置质量门禁计数
-        this.activePipelines.set(projectPath, legacyPipeline);
-        this.phaseManager.resetFixAttempts(pipelineId);
-        const nodeFlow = plannedPhases.map(p => PHASE_LABELS[p] || p).join(' → ');
-        logger.info(`[Pipeline:Dynamic] ✅ 动态流水线已创建\n📋 需求：${requirement}\n📊 统计：${nodes.length} 个节点 | 复杂度：${complexity}\n🗺️  节点规划：${nodeFlow}`);
-        return legacyPipeline;
+        this.activePipelines.set(plan.projectPath, pipeline);
+        this.dynamicNodeExecutor.resetFixAttempts(pipelineId);
+        this.writeExecutionPlanArtifact(plan, pipeline);
+        const nodeFlow = getPlanPhaseLabels(plan).join(' → ');
+        logger.info(`[Pipeline:Dynamic] ✅ 动态流水线已创建\n📋 需求：${plan.requirement}\n📊 统计：${nodes.length} 个节点 | 复杂度：${plan.complexity}\n🗺️  节点规划：${nodeFlow}`);
+        return pipeline;
     }
     /**
      * 将 DynamicPipeline 转换为 Pipeline 兼容对象（冷缓存恢复时使用）
@@ -527,7 +480,8 @@ ${taskSummary}
             : dynPipeline.nodes.find(n => n.status === 'in_progress');
         const phase = currentNode?.nodeTypeId ??
             dynPipeline.nodes[0]?.nodeTypeId ?? 'code';
-        const plannedPhases = dynPipeline.nodes.map(n => n.nodeTypeId);
+        const plannedPhases = dynPipeline.executionPlan?.stages.map(stage => stage.phase)
+            ?? dynPipeline.nodes.map(n => n.nodeTypeId);
         return {
             id: dynPipeline.id,
             requirement: dynPipeline.requirement,
@@ -545,6 +499,7 @@ ${taskSummary}
             complexity: dynPipeline.complexity,
             plannedPhases,
             reasoning: dynPipeline.reasoning,
+            executionPlan: dynPipeline.executionPlan,
             createdAt: dynPipeline.createdAt,
             updatedAt: dynPipeline.updatedAt,
         };
@@ -552,87 +507,29 @@ ${taskSummary}
     /**
      * 从 PipelineTemplate 启动 Pipeline（Batch 4：模板驱动，跳过 AI 分解）
      */
-    async startPipelineFromTemplate(requirement, projectPath, sessionId, template) {
-        logger.info(`[Pipeline:Template] 🚀 从模板启动："${requirement}" | 模板=${template.id}`);
-        // 从模板阶段构建任务列表
-        const validPhases = template.phases
-            .map(p => p.id)
-            .filter((id) => ['analyze', 'design', 'profile', 'code', 'test', 'review'].includes(id));
-        const plannedPhases = validPhases.length > 0 ? validPhases : ['code', 'test'];
-        const complexity = (template.trigger?.complexity?.[0] || 'moderate');
-        const taskType = template.taskType || 'other';
-        // 生成 Pipeline ID
-        const pipelineId = `dp_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
-        // 将模板 phases 转换为 DynamicNode 列表（顺序依赖）
-        const nodes = plannedPhases.map((phaseId, index) => ({
-            id: `${pipelineId}_node_${index}`,
-            nodeTypeId: phaseId,
-            status: (index === 0 ? 'in_progress' : 'pending'),
-            dependencies: index > 0 ? [`${pipelineId}_node_${index - 1}`] : [],
-        }));
-        // 创建 DynamicPipeline 记录
-        await this.storage.repositories.dynamicPipelines.create({
-            id: pipelineId,
-            requirement,
-            projectPath,
-            sessionId,
-            complexity,
-            reasoning: JSON.stringify({
-                currentNodeId: nodes[0]?.id,
-                templateId: template.id,
-                templateName: template.name,
-                source: template.source
-            }),
-            status: 'in_progress',
-        });
-        // 存储节点
-        if (nodes.length > 0) {
-            await this.storage.repositories.dynamicPipelines.createNodes(pipelineId, nodes);
-        }
-        // 设置 currentNodeId
-        if (nodes[0]) {
-            await this.storage.repositories.dynamicPipelines.updateCurrentNode(pipelineId, nodes[0].id);
-        }
-        // 构建 Pipeline 兼容对象
-        const now = new Date().toISOString();
-        const pipeline = {
-            id: pipelineId,
+    async startPipelineFromTemplate(requirement, projectPath, sessionId, template, analysis, templateRoute) {
+        const fallbackAnalysis = analysis ?? {
+            complexity: 'moderate',
+            requiresPipeline: true,
             requirement,
-            projectPath,
-            sessionId,
-            phase: nodes[0]?.nodeTypeId ?? 'code',
-            tasks: nodes.map(node => ({
-                id: node.id,
-                title: PHASE_LABELS[node.nodeTypeId] || node.nodeTypeId,
-                phase: node.nodeTypeId,
-                status: node.status === 'in_progress' ? 'in_progress' : node.status === 'completed' ? 'completed' : 'pending',
-                description: `模板节点：${node.nodeTypeId}`,
-                dependencies: node.dependencies,
-            })),
-            complexity,
-            taskType,
-            plannedPhases,
-            reasoning: `来源模板：${template.name}（${template.id}）`,
-            createdAt: now,
-            updatedAt: now,
+            reasoning: `模板 ${template.id} 启动时未提供显式意图分析，使用默认编排分析`,
+            estimatedFiles: 1,
+            suggestedPhases: template.phases.map(phase => phase.id),
         };
-        this.activePipelines.set(projectPath, pipeline);
-        // 新 Pipeline 启动时重置质量门禁修复计数（防止旧计数污染）
-        this.phaseManager.resetFixAttempts(pipeline.id);
-        // 写入执行计划文档
+        const plan = await this.buildExecutionPlan(requirement, projectPath, sessionId, fallbackAnalysis, template, templateRoute);
+        return this.startPipelineFromPlan(plan);
+    }
+    writeExecutionPlanArtifact(plan, pipeline) {
         try {
-            const artifactManager = new ArtifactManager(projectPath);
-            const phases = plannedPhases.map(p => PHASE_LABELS[p] || p).join(' → ');
-            const taskLines = pipeline.tasks.map(t => `- [${PHASE_LABELS[t.phase] || t.phase}] ${t.title}${t.description ? `：${t.description}` : ''}`).join('\n');
-            const planContent = `# 执行计划（模板驱动）\n\n**需求**：${requirement}\n\n**模板**：${template.name}（${template.id}）\n\n**阶段规划**：${phases}\n\n## 任务清单\n\n${taskLines}\n`;
-            artifactManager.writeArtifact('plan', '执行计划.md', planContent, requirement.slice(0, 50), '执行计划');
+            const artifactManager = new ArtifactManager(plan.projectPath);
+            const phases = getPlanPhaseLabels(plan).join(' → ');
+            const taskLines = pipeline.tasks.map(task => `- [${PHASE_LABELS[task.phase] || task.phase}] ${task.title}${task.description ? `：${task.description}` : ''}`).join('\n');
+            const planContent = `# 执行计划\n\n**需求**：${plan.requirement}\n\n**来源**：${plan.source}${plan.templateName ? `（${plan.templateName}）` : ''}\n\n**阶段规划**：${phases}\n\n## 任务清单\n\n${taskLines}\n`;
+            artifactManager.writeArtifact('plan', '执行计划.md', planContent, plan.requirement.slice(0, 50), '执行计划');
         }
         catch (err) {
-            logger.warn(`[Pipeline] 模板执行计划文档写入失败：${err}`);
+            logger.warn(`[Pipeline] 执行计划文档写入失败：${err}`);
         }
-        const phaseFlow = plannedPhases.map(p => PHASE_LABELS[p] || p).join(' → ');
-        logger.info(`[Pipeline:Template] ✅ 模板驱动启动完成\n📋 需求：${requirement}\n📊 统计：${pipeline.tasks.length} 个节点 | ${plannedPhases.length} 个阶段 | 模板：${template.name}\n🗺️  阶段规划：${phaseFlow}`);
-        return pipeline;
     }
     /**
      * 检查项目是否有活跃 Pipeline
@@ -641,7 +538,9 @@ ${taskSummary}
         if (this.activePipelines.has(projectPath))
             return true;
         const db = this.store.getActivePipeline(projectPath);
-        return db !== null;
+        if (db !== null)
+            return true;
+        return this.storage.repositories.dynamicPipelines.getActiveByProjectPath(projectPath) !== null;
     }
     /**
      * 获取 Pipeline 状态摘要（用于 resume 注入）
@@ -722,12 +621,6 @@ ${taskSummary}
         }
         return progressLine + gateLine;
     }
-    /**
-     * 获取 PhaseManager 引用（用于注入知识上下文）
-     */
-    getPhaseManager() {
-        return this.phaseManager;
-    }
     /**
      * 获取 DynamicNodeExecutor 引用
      */
@@ -738,38 +631,35 @@ ${taskSummary}
      * 获取活跃 Pipeline 对象
      */
     getActivePipelineForProject(projectPath) {
-        return this.activePipelines.get(projectPath) || this.store.getActivePipeline(projectPath);
+        const cached = this.activePipelines.get(projectPath);
+        if (cached)
+            return cached;
+        const legacy = this.store.getActivePipeline(projectPath);
+        if (legacy)
+            return legacy;
+        const dynamic = this.storage.repositories.dynamicPipelines.getActiveByProjectPath(projectPath);
+        return dynamic ? this.dynamicPipelineToBridge(dynamic) : null;
     }
     /**
-     * ESC 中断后从 DB 恢复时，重建 PhaseManager 的内存状态。
-     * - phaseToolsSeen：已完成任务的阶段标记为"已见过 write"（允许后续任务正常检测）
-     * - totalPhaseEventCounts：按已完成任务数估算（保守值，避免立刻触发兜底推进）
+     * ESC 中断后从 DB 恢复时，重建执行器的内存状态。
      */
     restorePhaseState(pipeline) {
         const phase = pipeline.phase;
         if (phase === 'done')
             return;
-        const key = `${pipeline.id}:${phase}`;
-        const completedCount = pipeline.tasks.filter(t => t.phase === phase && t.status === 'completed').length;
-        // 跨会话恢复时清理质量门禁修复计数，避免残留计数导致"第N次"误报
-        this.phaseManager.resetFixAttempts(pipeline.id);
-        // 优先从 daemon_state 恢复完整状态
-        if (this.loadPhaseState(pipeline.id, phase)) {
-            logger.debug(`[Pipeline] 从 daemon_state 恢复阶段状态：${phase}`);
+        // 动态 Pipeline 使用 DynamicNodeExecutor 的状态恢复
+        if (pipeline.id.startsWith('dp_')) {
+            this.dynamicNodeExecutor.resetFixAttempts(pipeline.id);
+            logger.debug(`[Pipeline] 动态 Pipeline 状态已恢复：${phase}`);
             return;
         }
-        // 回退：已有已完成任务 → 恢复 toolsSeen 为"已做过 explore + write"，避免卡死
-        if (completedCount > 0) {
-            this.phaseManager.restoreToolsSeen(key, new Set(['explore', 'write', 'bash']));
-        }
-        // 回退：事件计数按已完成任务数 × 5（保守估算，不触发兜底推进）
-        this.phaseManager.restoreEventCount(key, completedCount * 5);
-        logger.debug(`[Pipeline] 回退恢复阶段状态：${phase} | 已完成=${completedCount}`);
+        // Legacy Pipeline 不再支持状态恢复
+        logger.warn(`[Pipeline] Legacy Pipeline ${pipeline.id} 状态恢复已跳过`);
     }
     /** 将当前阶段推进状态持久化到 daemon_state */
     persistPhaseState(pipelineId, phase) {
         const key = `${pipelineId}:${phase}`;
-        const state = this.phaseManager.exportPhaseState(key);
+        const state = this.dynamicNodeExecutor.exportState(key);
         this.storage.setDaemonState(`pipeline:phase-state:${key}`, JSON.stringify(state));
     }
     /** 从 daemon_state 加载阶段推进状态，成功返回 true */
@@ -780,7 +670,7 @@ ${taskSummary}
             return false;
         try {
             const parsed = JSON.parse(raw);
-            this.phaseManager.restorePhaseState(key, parsed);
+            this.dynamicNodeExecutor.restoreState(key, parsed);
             return true;
         }
         catch (err) {
@@ -823,7 +713,7 @@ ${taskSummary}
                 this.dynamicNodeExecutor.cleanup(interrupted.pipelineId);
             }
             else {
-                this.phaseManager.cleanup(interrupted.pipelineId);
+                this.dynamicNodeExecutor.cleanup(interrupted.pipelineId);
             }
             this.activePipelines.delete(projectPath);
             this.lastInstructionKey.delete(projectPath);
@@ -842,7 +732,7 @@ ${taskSummary}
                 this.dynamicNodeExecutor.cleanup(projectPathOrId);
             }
             else {
-                this.phaseManager.cleanup(projectPathOrId);
+                this.dynamicNodeExecutor.cleanup(projectPathOrId);
             }
             this.store.closeById(projectPathOrId);
             // 清理内存缓存（遍历找到对应条目）
@@ -863,7 +753,7 @@ ${taskSummary}
                     this.dynamicNodeExecutor.cleanup(pipeline.id);
                 }
                 else {
-                    this.phaseManager.cleanup(pipeline.id);
+                    this.dynamicNodeExecutor.cleanup(pipeline.id);
                 }
                 this.store.closeById(pipeline.id);
             }
@@ -886,7 +776,7 @@ ${taskSummary}
                     this.dynamicNodeExecutor.cleanup(pipelineId);
                 }
                 else {
-                    this.phaseManager.cleanup(pipelineId);
+                    this.dynamicNodeExecutor.cleanup(pipelineId);
                 }
             }
             logger.info(`[Pipeline] 已自动关闭 ${closedIds.length} 个过期 Pipeline（超过 ${ttlMs / 60000} 分钟未更新）`);
@@ -923,32 +813,17 @@ ${taskSummary}
             return false;
         return this.dynamicNodeExecutor.hasArtifactRetry(pipeline.id);
     }
+    evaluatePreToolGate(event) {
+        const pipeline = this.getActiveDynamicPipelineForProject(event.project_path);
+        if (!pipeline)
+            return null;
+        return this.dynamicNodeExecutor.evaluatePreToolGate(pipeline, event);
+    }
     /**
      * 检查 Step 级工具白名单（Step 模式启用时生效）
      */
     checkStepGate(event) {
-        const pipeline = this.getActiveDynamicPipelineForProject(event.project_path);
-        if (!pipeline)
-            return null;
-        const currentNode = pipeline.nodes.find(n => n.id === pipeline.currentNodeId);
-        if (!currentNode)
-            return null;
-        // 检查是否启用 Step 模式
-        const stepOrchestrator = this.dynamicNodeExecutor.getStepOrchestrator();
-        if (!stepOrchestrator.isStepModeEnabled(currentNode)) {
-            return null; // 未启用 Step 模式，跳过检查
-        }
-        // 获取当前 Step
-        const currentStep = stepOrchestrator.getCurrentStep(pipeline, currentNode);
-        if (!currentStep)
-            return null;
-        // 加载 Step 定义
-        const stepDef = stepOrchestrator.loadStepDefinition(currentNode.nodeTypeId, currentStep.stepDefinitionId);
-        if (!stepDef)
-            return null;
-        // 使用 StepGateKeeper 检查工具
-        const stepGateKeeper = this.dynamicNodeExecutor.getStepGateKeeper();
-        return stepGateKeeper.checkTool(event, currentStep, stepDef);
+        return this.evaluatePreToolGate(event);
     }
     /** 标记项目进入硬阻断状态 */
     markBlocked(projectPath, pipelineId, reason) {
@@ -1006,11 +881,12 @@ ${taskSummary}
      * 使用与 PreToolUse 相同的进度指纹缓存机制，避免相同进度下重复注入
      */
     async getCurrentPhaseDirective(projectPath) {
-        const pipeline = this.activePipelines.get(projectPath) || this.store.getActivePipeline(projectPath);
+        const pipeline = this.getActivePipelineForProject(projectPath);
         if (!pipeline || pipeline.phase === 'done')
             return null;
-        // 刷新任务列表
-        pipeline.tasks = this.store.getTasks(pipeline.id);
+        if (!pipeline.id.startsWith('dp_')) {
+            pipeline.tasks = this.store.getTasks(pipeline.id);
+        }
         // 进度指纹去重：与 PreToolUse 共享 lastInstructionKey 缓存
         const progress = this.store.getPhaseProgress(pipeline.id, pipeline.phase);
         const instrKey = `${pipeline.id}:${pipeline.phase}:${progress.completed}/${progress.total}:user`;
@@ -1033,7 +909,9 @@ ${taskSummary}
                 return null;
             return this.dynamicNodeExecutor.getInstruction(dynPipeline);
         }
-        return this.phaseManager.getPhaseInstruction(pipeline);
+        // Legacy Pipeline 不再支持
+        logger.warn(`[Pipeline] Legacy Pipeline ${pipeline.id} 不再支持`);
+        return null;
     }
     /**
      * 获取任务进度摘要（Stage 09 增强上下文使用）
@@ -1056,20 +934,15 @@ ${taskSummary}
     /**
      * 获取产物门禁提示（供 stage-scheduler 注入到 AI 上下文）
      */
-    getArtifactGateReminder(projectPath) {
-        const pipeline = this.activePipelines.get(projectPath) || this.store.getActivePipeline(projectPath);
-        if (!pipeline || pipeline.phase === 'done')
-            return null;
-        return this.phaseManager.getArtifactGateReminder(pipeline.id, pipeline.phase);
+    getArtifactGateReminder(_projectPath) {
+        // Legacy 功能，动态 Pipeline 不使用产物门禁提示
+        return null;
     }
     /**
      * 清除产物门禁提示
      */
-    clearArtifactGateReminder(projectPath) {
-        const pipeline = this.activePipelines.get(projectPath) || this.store.getActivePipeline(projectPath);
-        if (!pipeline || pipeline.phase === 'done')
-            return;
-        this.phaseManager.clearArtifactGateReminder(pipeline.id, pipeline.phase);
+    clearArtifactGateReminder(_projectPath) {
+        // Legacy 功能，动态 Pipeline 不使用产物门禁提示
     }
     /**
      * 获取当前阶段名称（用于失败信号上下文）
@@ -1084,7 +957,7 @@ ${taskSummary}
      * 获取 Pipeline 阶段快照（用于复盘分析）
      */
     getSessionSnapshot(pipelineId) {
-        return this.phaseManager.getSessionSnapshot(pipelineId);
+        return this.dynamicNodeExecutor.getSessionSnapshot(pipelineId);
     }
     /**
      * 发射 Step 级别的事件（STEP_STARTED/COMPLETED/FAILED/VALIDATED/RETRYING/NEED_HUMAN）