@winspan/claude-forge 4.1.0 → 6.0.0

package/dist/pipeline/index.js

@@ -1,728 +0,0 @@
-import { GoalDecomposer } from '../goal/goal-decomposer.js';
-import { GoalPlanner } from '../goal/goal-planner.js';
-import { DynamicNodeExecutor } from './dynamic-node-executor.js';
-import { PHASE_LABELS } from './types.js';
-import { DEFAULT_RETRY, PIPELINE, TIME } from '../constants.js';
-import { logger } from '../utils/logger.js';
-import { ArtifactManager } from '../utils/artifact-manager.js';
-import { cacheRegistry } from '../utils/cache-registry.js';
-import { getPlanPhaseLabels, stringifyExecutionPlanMeta, } from './execution-plan.js';
-export { TemplateRegistry } from './template-registry.js';
-export { TemplateRouter } from './template-router.js';
-export class PipelineEngine {
-    decomposer;
-    planner;
-    dynamicNodeExecutor;
-    api;
-    storage;
-    /** 内存缓存：最多保留 50 个最近访问的项目 pipeline，防止无界增长 */
-    activePipelines;
-    /** 上次注入的指令指纹（pipelineId:phase:completed/total），相同则跳过重复注入 */
-    lastInstructionKey;
-    /** 0/0 状态已通知的 key（projectPath:phase），避免每次 PreToolUse 重复注入空阶段提示（1小时 TTL 自动清理） */
-    emptyPhaseNotified = cacheRegistry.register('pipeline:emptyNotified', {
-        max: 100,
-        ttl: TIME.HOUR
-    });
-    /** CLAUDE.md 写入器（可选，用于统一加锁写入） */
-    claudeMdWriter;
-    constructor(storage, api, conventionManager, claudeMdWriter, pendingPromptSink) {
-        this.decomposer = new GoalDecomposer(api, conventionManager);
-        this.planner = new GoalPlanner(this.decomposer);
-        this.dynamicNodeExecutor = new DynamicNodeExecutor(api, pendingPromptSink);
-        this.api = api;
-        this.storage = storage;
-        this.activePipelines = cacheRegistry.register('pipeline:active', { max: 50 });
-        this.lastInstructionKey = cacheRegistry.register('pipeline:instruction', { max: 50 });
-        this.claudeMdWriter = claudeMdWriter;
-    }
-    /** 检测到 ESC 中断、等待用户确认意图的项目路径集合（2小时 TTL，用户可能长时间不确认） */
-    interruptedProjects = cacheRegistry.register('pipeline:interrupted', {
-        max: 50,
-        ttl: TIME.TWO_HOURS
-    });
-    /** 硬阻断状态（key=projectPath）：用于 PreToolUse 拦截后续工具调用 */
-    blockedProjects = cacheRegistry.register('pipeline:blocked', {
-        max: 50,
-        ttl: TIME.TWO_HOURS
-    });
-    /**
-     * 启动新 Pipeline
-     *
-     * @param requirement - 用户需求描述
-     * @param projectPath - 项目根目录路径
-     * @param sessionId - 会话 ID
-     * @param analysis - 可选的意图分析结果，未提供时使用默认值
-     * @returns 创建的 Pipeline 对象
-     */
-    async startPipeline(requirement, projectPath, sessionId, analysis) {
-        logger.info(`[Pipeline] 启动中（模式：dynamic）："${requirement}"`);
-        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);
-    }
-    /**
-     * 生成统一执行计划（动态流水线唯一事实来源）
-     *
-     * @param requirement - 用户需求描述
-     * @param projectPath - 项目根目录路径
-     * @param sessionId - 会话 ID
-     * @param analysis - 意图分析结果
-     * @param template - 可选的流水线模板
-     * @param templateRoute - 可选的模板路由结果
-     * @returns 规范化的执行计划对象
-     */
-    async buildExecutionPlan(requirement, projectPath, sessionId, analysis, template, templateRoute) {
-        const goal = {
-            ...analysis,
-            requirement,
-            projectPath,
-            sessionId,
-            taskType: 'other',
-        };
-        return this.planner.buildPlan(goal, {
-            template,
-            templateRoute,
-        });
-    }
-    /**
-     * 从统一执行计划启动动态 Pipeline
-     *
-     * @param plan - 规范化的执行计划对象
-     * @returns 创建的 Pipeline 对象
-     */
-    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)}`;
-        const nodes = plan.stages.map((stage, index) => ({
-            id: `${pipelineId}_node_${index}`,
-            nodeTypeId: stage.nodeTypeId,
-            status: (index === 0 ? 'in_progress' : 'pending'),
-            dependencies: index > 0 ? [`${pipelineId}_node_${index - 1}`] : [],
-        }));
-        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: plan.requirement,
-            projectPath: plan.projectPath,
-            sessionId: plan.sessionId,
-            templateId: plan.templateId,
-            complexity: plan.complexity,
-            reasoning: reasoningMeta,
-            status: 'in_progress',
-            executionPlan: plan,
-        });
-        if (nodes.length > 0) {
-            await this.storage.repositories.dynamicPipelines.createNodes(pipelineId, nodes);
-        }
-        if (nodes[0]) {
-            await this.storage.repositories.dynamicPipelines.updateCurrentNode(pipelineId, nodes[0].id);
-        }
-        const now = new Date().toISOString();
-        const pipeline = {
-            id: pipelineId,
-            requirement: plan.requirement,
-            projectPath: plan.projectPath,
-            sessionId: plan.sessionId,
-            phase: nodes[0]?.nodeTypeId ?? 'code',
-            tasks: nodes.map((node, index) => ({
-                id: node.id,
-                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: plan.tasks[index]?.description ?? `动态节点：${node.nodeTypeId}`,
-                dependencies: node.dependencies,
-                source: plan.source,
-            })),
-            techStack: plan.techStack,
-            complexity: plan.complexity,
-            taskType: plan.taskType,
-            plannedPhases: plan.stages.map(stage => stage.phase ?? stage.nodeTypeId),
-            phaseArtifacts: Object.fromEntries(plan.stages.map(stage => [stage.phase ?? stage.nodeTypeId, stage.derivedReports])),
-            reasoning: plan.reasoning,
-            templateId: plan.templateId,
-            executionPlan: plan,
-            createdAt: now,
-            updatedAt: now,
-        };
-        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 兼容对象（冷缓存恢复时使用）
-     */
-    dynamicPipelineToBridge(dynPipeline) {
-        const currentNode = dynPipeline.currentNodeId
-            ? dynPipeline.nodes.find(n => n.id === dynPipeline.currentNodeId)
-            : dynPipeline.nodes.find(n => n.status === 'in_progress');
-        const phase = currentNode?.nodeTypeId ??
-            dynPipeline.nodes[0]?.nodeTypeId ?? 'code';
-        const plannedPhases = dynPipeline.executionPlan?.stages.map(stage => stage.phase ?? stage.nodeTypeId)
-            ?? dynPipeline.nodes.map(n => n.nodeTypeId);
-        return {
-            id: dynPipeline.id,
-            requirement: dynPipeline.requirement,
-            projectPath: dynPipeline.projectPath,
-            sessionId: dynPipeline.sessionId,
-            phase,
-            tasks: dynPipeline.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: dynPipeline.complexity,
-            plannedPhases,
-            reasoning: dynPipeline.reasoning,
-            executionPlan: dynPipeline.executionPlan,
-            createdAt: dynPipeline.createdAt,
-            updatedAt: dynPipeline.updatedAt,
-        };
-    }
-    /**
-     * 从 PipelineTemplate 启动 Pipeline（Batch 4：模板驱动，跳过 AI 分解）
-     */
-    async startPipelineFromTemplate(requirement, projectPath, sessionId, template, analysis, templateRoute) {
-        const fallbackAnalysis = analysis ?? {
-            complexity: 'moderate',
-            requiresPipeline: true,
-            requirement,
-            reasoning: `模板 ${template.id} 启动时未提供显式意图分析，使用默认编排分析`,
-            estimatedFiles: 1,
-            suggestedPhases: template.phases.map(phase => phase.id),
-        };
-        const plan = await this.buildExecutionPlan(requirement, projectPath, sessionId, fallbackAnalysis, template, templateRoute);
-        return this.startPipelineFromPlan(plan);
-    }
-    writeExecutionPlanArtifact(plan, pipeline) {
-        try {
-            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}`);
-        }
-    }
-    /**
-     * 检查项目是否有活跃 Pipeline
-     */
-    /**
-     * 从 DynamicPipeline 转换为 Legacy Pipeline 格式（内部使用）
-     */
-    convertToLegacyPipeline(dynPipeline) {
-        const currentNode = dynPipeline.currentNodeId
-            ? dynPipeline.nodes.find(n => n.id === dynPipeline.currentNodeId)
-            : dynPipeline.nodes.find(n => n.status === 'in_progress');
-        const plannedPhases = dynPipeline.executionPlan?.stages.map(s => s.phase ?? s.nodeTypeId)
-            ?? dynPipeline.nodes.map(n => n.nodeTypeId);
-        return {
-            id: dynPipeline.id,
-            requirement: dynPipeline.requirement,
-            projectPath: dynPipeline.projectPath,
-            sessionId: dynPipeline.sessionId,
-            phase: (currentNode?.nodeTypeId ?? dynPipeline.nodes[0]?.nodeTypeId ?? 'code'),
-            plannedPhases,
-            tasks: dynPipeline.nodes.map(node => ({
-                id: node.id,
-                title: node.nodeTypeId,
-                description: node.configOverride?.extraInstructions || `动态节点：${node.nodeTypeId}`,
-                phase: node.nodeTypeId,
-                status: node.status,
-                dependencies: node.dependencies || [],
-                source: 'dynamic',
-                output: node.output || undefined,
-            })),
-            createdAt: dynPipeline.createdAt,
-            updatedAt: dynPipeline.updatedAt,
-        };
-    }
-    hasActivePipeline(projectPath) {
-        if (this.activePipelines.has(projectPath))
-            return true;
-        return this.storage.repositories.dynamicPipelines.getActiveByProjectPath(projectPath) !== null;
-    }
-    /**
-     * 获取 Pipeline 状态摘要（用于 resume 注入）
-     */
-    getStatusSummary(projectPath) {
-        let pipeline = this.activePipelines.get(projectPath);
-        if (!pipeline) {
-            const dynPipeline = this.storage.repositories.dynamicPipelines.getActiveByProjectPath(projectPath);
-            if (dynPipeline) {
-                pipeline = this.convertToLegacyPipeline(dynPipeline);
-            }
-        }
-        if (!pipeline || pipeline.phase === 'done')
-            return null;
-        const tasks = pipeline.tasks;
-        const done = tasks.filter(t => t.status === 'completed').length;
-        return `Pipeline 进行中：${pipeline.requirement}
-阶段：${PHASE_LABELS[pipeline.phase]} | 进度：${done}/${tasks.length}`;
-    }
-    /**
-     * 结构化进度快照（PostToolUse 后写入 events.jsonl）
-     * gateStatus: 质量门禁结果，undefined 表示本次未触发门禁
-     */
-    getProgressLogLine(projectPath, gateStatus, advanceReason) {
-        // 完全从 DB 读取，避免缓存中的 phase 过期
-        const dynPipeline = this.storage.repositories.dynamicPipelines.getActiveByProjectPath(projectPath);
-        if (!dynPipeline)
-            return null;
-        const pipeline = this.convertToLegacyPipeline(dynPipeline);
-        if (pipeline.phase === 'done')
-            return null;
-        const tasks = pipeline.tasks;
-        const doneAll = tasks.filter((t) => t.status === 'completed' || t.status === 'skipped').length;
-        const phaseTasks = tasks.filter(t => t.phase === pipeline.phase);
-        const phaseProg = {
-            total: phaseTasks.length,
-            completed: phaseTasks.filter(t => t.status === 'completed' || t.status === 'skipped').length,
-        };
-        // 空阶段（无任务）不显示进度，等待自愈推进
-        if (phaseProg.total === 0)
-            return null;
-        const pct = tasks.length > 0 ? Math.round((doneAll / tasks.length) * 100) : 0;
-        // 剩余阶段
-        const plannedPhases = pipeline.plannedPhases ?? ['analyze', 'design', 'code', 'test', 'review'];
-        const currentIdx = plannedPhases.indexOf(pipeline.phase);
-        const remaining = currentIdx >= 0 ? plannedPhases.slice(currentIdx + 1) : [];
-        const remainStr = remaining.length > 0
-            ? ` → 待：${remaining.map(p => PHASE_LABELS[p]).join('→')}`
-            : '';
-        // 当前阶段任务列表（含来源标记）
-        const currentTask = phaseTasks.find(t => t.status === 'in_progress');
-        const currentTaskLine = currentTask ? `\n  📍 当前任务: ${currentTask.title}` : '';
-        const taskLines = phaseTasks.length > 0
-            ? '\n' + phaseTasks.map(t => {
-                const icon = t.status === 'completed' ? '✅' : t.status === 'in_progress' ? '▶' : t.status === 'skipped' ? '⏭' : t.status === 'failed' ? '❌' : '○';
-                const sourceTag = t.source ? ` [${t.source}]` : '';
-                return `    ${icon} ${t.title}${sourceTag}`;
-            }).join('\n')
-            : '';
-        const shortId = pipeline.id.length > 8 ? pipeline.id.slice(0, 8) : pipeline.id;
-        const barFilled = phaseProg.total > 0 ? Math.round((phaseProg.completed / phaseProg.total) * 10) : 0;
-        const bar = '█'.repeat(barFilled) + '░'.repeat(10 - barFilled);
-        // 推进原因标记
-        let reasonTag = '';
-        if (advanceReason === 'activity_threshold') {
-            reasonTag = ' ⚠️ [活动阈值触发]';
-        }
-        else if (advanceReason === 'empty_phase') {
-            reasonTag = ' ⚡ [空阶段自愈]';
-        }
-        else if (advanceReason === 'timeout') {
-            reasonTag = ' ⏱️ [超时强制推进]';
-        }
-        // 任务进度行
-        const progressLine = `#${shortId} ${PHASE_LABELS[pipeline.phase]} ${phaseProg.completed}/${phaseProg.total} [${bar}] 全局${pct}%${remainStr}${reasonTag}${currentTaskLine}${taskLines}`;
-        // 质量门禁状态行（仅在有门禁结果时追加）
-        if (!gateStatus)
-            return progressLine;
-        let gateLine;
-        if (gateStatus.blocked) {
-            const attempts = gateStatus.fixAttempts ? ` (第${gateStatus.fixAttempts}次)` : '';
-            gateLine = `\n  🚦 阶段状态: ⚠️ 待修复${attempts}`;
-            if (gateStatus.issues?.length) {
-                gateLine += '\n' + gateStatus.issues.map(i => `    ❌ ${i}`).join('\n');
-            }
-            gateLine += '\n  ⏸️  阶段推进已暂停，修复后将自动继续';
-        }
-        else if (gateStatus.level === 'warn') {
-            gateLine = `\n  🚦 阶段状态: 🟡 通过（含建议）`;
-        }
-        else {
-            gateLine = `\n  🚦 阶段状态: ✅ 通过`;
-        }
-        return progressLine + gateLine;
-    }
-    /**
-     * 获取 DynamicNodeExecutor 引用
-     */
-    getDynamicNodeExecutor() {
-        return this.dynamicNodeExecutor;
-    }
-    /**
-     * 获取活跃 Pipeline 对象
-     */
-    getActivePipelineForProject(projectPath) {
-        const cached = this.activePipelines.get(projectPath);
-        if (cached)
-            return cached;
-        const dynamic = this.storage.repositories.dynamicPipelines.getActiveByProjectPath(projectPath);
-        return dynamic ? this.dynamicPipelineToBridge(dynamic) : null;
-    }
-    /**
-     * ESC 中断后恢复执行器内存状态
-     */
-    restorePhaseState(pipeline) {
-        if (pipeline.phase === 'done')
-            return;
-        this.dynamicNodeExecutor.resetFixAttempts(pipeline.id);
-    }
-    /**
-     * 检查指定项目是否处于 ESC 中断待确认状态
-     */
-    getInterruptedState(projectPath) {
-        return this.interruptedProjects.get(projectPath) ?? null;
-    }
-    /**
-     * 用户选择"继续"：重置 in_progress → pending，恢复内存状态，清除中断标记
-     */
-    resumeAfterInterrupt(projectPath) {
-        let pipeline = this.activePipelines.get(projectPath);
-        if (!pipeline) {
-            const dynPipeline = this.storage.repositories.dynamicPipelines.getActiveByProjectPath(projectPath);
-            if (dynPipeline)
-                pipeline = this.convertToLegacyPipeline(dynPipeline);
-        }
-        if (!pipeline)
-            return;
-        let reset = 0;
-        const dynPipeline = this.storage.repositories.dynamicPipelines.getById(pipeline.id);
-        if (dynPipeline) {
-            for (const node of dynPipeline.nodes) {
-                if (node.status === 'in_progress') {
-                    this.storage.repositories.dynamicPipelines.updateNodeStatus(node.id, 'pending');
-                    reset++;
-                }
-            }
-        }
-        if (reset > 0) {
-            logger.info(`[Pipeline] 用户选择继续：重置 ${reset} 个 in_progress 任务为 pending`);
-            const refreshed = this.storage.repositories.dynamicPipelines.getById(pipeline.id);
-            if (refreshed) {
-                pipeline = this.convertToLegacyPipeline(refreshed);
-                this.activePipelines.set(projectPath, pipeline);
-            }
-        }
-        this.restorePhaseState(pipeline);
-        this.interruptedProjects.delete(projectPath);
-        this.lastInstructionKey.delete(projectPath);
-    }
-    /**
-     * 用户选择"取消/重做"：关闭当前 Pipeline，清除中断标记
-     */
-    cancelAfterInterrupt(projectPath) {
-        const interrupted = this.interruptedProjects.get(projectPath);
-        if (interrupted) {
-            this.storage.repositories.dynamicPipelines.close(interrupted.pipelineId, 'completed');
-            this.dynamicNodeExecutor.cleanup(interrupted.pipelineId);
-            this.activePipelines.delete(projectPath);
-            this.lastInstructionKey.delete(projectPath);
-            this.interruptedProjects.delete(projectPath);
-            logger.info(`[Pipeline] 用户选择取消：Pipeline ${interrupted.pipelineId} 已关闭`);
-        }
-    }
-    /**
-     * 手动关闭指定项目（或指定 ID）的 Pipeline。
-     * 供 CLI 和 daemon 启动时调用。
-     */
-    closePipeline(projectPathOrId, byId = false) {
-        if (byId) {
-            this.dynamicNodeExecutor.cleanup(projectPathOrId);
-            this.storage.repositories.dynamicPipelines.close(projectPathOrId, 'completed');
-            // 清理内存缓存（遍历找到对应条目）
-            for (const [key, p] of this.activePipelines) {
-                if (p.id === projectPathOrId) {
-                    this.activePipelines.delete(key);
-                    this.lastInstructionKey.delete(key);
-                    this.clearBlocked(key);
-                    break;
-                }
-            }
-        }
-        else {
-            const dynPipeline = this.storage.repositories.dynamicPipelines.getActiveByProjectPath(projectPathOrId);
-            if (dynPipeline) {
-                this.dynamicNodeExecutor.cleanup(dynPipeline.id);
-                this.storage.repositories.dynamicPipelines.close(dynPipeline.id, 'completed');
-            }
-            this.activePipelines.delete(projectPathOrId);
-            this.lastInstructionKey.delete(projectPathOrId);
-            this.clearBlocked(projectPathOrId);
-        }
-        logger.info(`[Pipeline] 已手动关闭：${projectPathOrId}`);
-    }
-    /**
-     * 清理所有超过 ttlMs 未更新的过期 Pipeline（daemon 启动时调用）。
-     * 默认使用配置的过期时间。
-     */
-    cleanupExpired(ttlMs = PIPELINE.EXPIRE_MS) {
-        const allActive = this.storage.repositories.dynamicPipelines.listActive();
-        const now = Date.now();
-        const expired = [];
-        for (const pipeline of allActive) {
-            const age = now - new Date(pipeline.updatedAt).getTime();
-            if (age > ttlMs) {
-                this.storage.repositories.dynamicPipelines.close(pipeline.id, 'failed');
-                expired.push(pipeline.id);
-            }
-        }
-        if (expired.length > 0) {
-            for (const pipelineId of expired) {
-                this.dynamicNodeExecutor.cleanup(pipelineId);
-            }
-            logger.info(`[Pipeline] 已自动关闭 ${expired.length} 个过期 Pipeline（超过 ${ttlMs / 60000} 分钟未更新）`);
-            this.activePipelines.clear();
-            this.lastInstructionKey.clear();
-        }
-    }
-    /**
-     * 获取项目当前硬阻断状态（若阻断状态与活跃 Pipeline 不一致会自动清理）
-     */
-    getBlockedState(projectPath) {
-        const blocked = this.blockedProjects.get(projectPath);
-        if (!blocked)
-            return null;
-        const active = this.activePipelines.get(projectPath)
-            ?? (() => {
-                const dyn = this.storage.repositories.dynamicPipelines.getActiveByProjectPath(projectPath);
-                return dyn ? this.convertToLegacyPipeline(dyn) : null;
-            })();
-        if (!active || active.id !== blocked.pipelineId) {
-            this.blockedProjects.delete(projectPath);
-            return null;
-        }
-        return blocked;
-    }
-    /** 当前项目是否处于硬阻断状态 */
-    isBlocked(projectPath) {
-        return this.getBlockedState(projectPath) !== null;
-    }
-    /**
-     * 当前项目的动态 Pipeline 是否处于产物重试状态（retryCount >= 1）
-     * 用于 PreToolUse 强制门禁：重试期间只允许 Write/Edit/Bash
-     */
-    isInArtifactRetry(projectPath) {
-        const pipeline = this.activePipelines.get(projectPath)
-            ?? (() => {
-                const dyn = this.storage.repositories.dynamicPipelines.getActiveByProjectPath(projectPath);
-                return dyn ? this.convertToLegacyPipeline(dyn) : null;
-            })();
-        if (!pipeline || !pipeline.id.startsWith('dp_'))
-            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);
-    }
-    /**
-     * 检查节点完成并推进（动态流水线）
-     *
-     * 在每次工具调用后调用，检查当前节点是否满足完成条件，
-     * 如果满足则更新节点状态为 completed 并推进到下一个节点
-     */
-    async checkAndAdvance(projectPath, event, qualityGate) {
-        const pipeline = this.getActiveDynamicPipelineForProject(projectPath);
-        if (!pipeline) {
-            return { advanced: false };
-        }
-        return this.dynamicNodeExecutor.checkAndAdvance(pipeline, event, qualityGate);
-    }
-    /**
-     * 检查 Step 级工具白名单（Step 模式启用时生效）
-     */
-    checkStepGate(event) {
-        return this.evaluatePreToolGate(event);
-    }
-    /** 标记项目进入硬阻断状态 */
-    markBlocked(projectPath, pipelineId, reason) {
-        this.blockedProjects.set(projectPath, {
-            pipelineId,
-            reason,
-            blockedAt: Date.now(),
-        });
-    }
-    /** 清理项目硬阻断状态 */
-    clearBlocked(projectPath) {
-        this.blockedProjects.delete(projectPath);
-    }
-    /** 列出所有活跃 Pipeline（跨项目，供 CLI 展示） */
-    listActive() {
-        const dynPipelines = this.storage.repositories.dynamicPipelines.listActive();
-        return dynPipelines.map(dyn => {
-            const legacy = this.convertToLegacyPipeline(dyn);
-            return {
-                id: legacy.id,
-                requirement: legacy.requirement,
-                projectPath: legacy.projectPath,
-                phase: legacy.phase,
-                updatedAt: legacy.updatedAt,
-            };
-        });
-    }
-    /**
-     * 获取活跃 DynamicPipeline 对象（用于 PreToolUse 阶段判断）
-     */
-    getActiveDynamicPipelineForProject(projectPath) {
-        const pipeline = this.getActivePipelineForProject(projectPath);
-        if (!pipeline || !pipeline.id.startsWith('dp_'))
-            return null;
-        return this.storage.repositories.dynamicPipelines.getActiveByProjectPath(projectPath);
-    }
-    /**
-     * 获取活跃 Pipeline 对象（session-cleanup 接口兼容）
-     */
-    getActivePipeline(projectPath) {
-        return this.getActivePipelineForProject(projectPath);
-    }
-    /**
-     * 检查活跃 Pipeline 的所有节点是否已完成（从 DB 读取最新状态）
-     * 用于 Stage 09 检测 Pipeline 是否应该自动关闭
-     */
-    isAllNodesCompleted(projectPath) {
-        const dynPipeline = this.storage.repositories.dynamicPipelines.getActiveByProjectPath(projectPath);
-        if (!dynPipeline)
-            return false;
-        const nodes = dynPipeline.nodes;
-        return nodes.length > 0 && nodes.every(n => n.status === 'completed');
-    }
-    /**
-     * 获取当前阶段指令（Stage 09 增强上下文使用）
-     * 使用与 PreToolUse 相同的进度指纹缓存机制，避免相同进度下重复注入
-     */
-    async getCurrentPhaseDirective(projectPath) {
-        const pipeline = this.getActivePipelineForProject(projectPath);
-        if (!pipeline || pipeline.phase === 'done')
-            return null;
-        // 动态流水线：计算进度指纹
-        const tasks = pipeline.tasks;
-        const phaseTasks = tasks.filter(t => t.phase === pipeline.phase);
-        const progress = {
-            total: phaseTasks.length,
-            completed: phaseTasks.filter(t => t.status === 'completed' || t.status === 'skipped').length,
-        };
-        const instrKey = `${pipeline.id}:${pipeline.phase}:${progress.completed}/${progress.total}:user`;
-        if (progress.total === 0) {
-            const emptyKey = `${projectPath}:${pipeline.phase}:user`;
-            if (this.emptyPhaseNotified.get(emptyKey))
-                return null;
-            this.emptyPhaseNotified.set(emptyKey, true);
-        }
-        else {
-            this.emptyPhaseNotified.delete(`${projectPath}:${pipeline.phase}:user`);
-            if (this.lastInstructionKey.get(`${projectPath}:user`) === instrKey)
-                return null;
-            this.lastInstructionKey.set(`${projectPath}:user`, instrKey);
-        }
-        // 动态流水线路由到 DynamicNodeExecutor
-        if (pipeline.id.startsWith('dp_')) {
-            const dynPipeline = await this.storage.repositories.dynamicPipelines.getById(pipeline.id);
-            if (!dynPipeline)
-                return null;
-            return this.dynamicNodeExecutor.getInstruction(dynPipeline);
-        }
-        return null;
-    }
-    /**
-     * 获取任务进度摘要（Stage 09 增强上下文使用）
-     */
-    getTaskProgress(projectPath) {
-        let pipeline = this.activePipelines.get(projectPath);
-        if (!pipeline) {
-            const dyn = this.storage.repositories.dynamicPipelines.getActiveByProjectPath(projectPath);
-            if (dyn)
-                pipeline = this.convertToLegacyPipeline(dyn);
-        }
-        if (!pipeline || pipeline.phase === 'done')
-            return null;
-        const tasks = pipeline.tasks;
-        const phaseTasks = tasks.filter(t => t.phase === pipeline.phase);
-        const phaseProgress = {
-            total: phaseTasks.length,
-            completed: phaseTasks.filter(t => t.status === 'completed' || t.status === 'skipped').length,
-        };
-        const lines = [];
-        lines.push(`当前阶段：${PHASE_LABELS[pipeline.phase]} (${phaseProgress.completed}/${phaseProgress.total})`);
-        for (const task of phaseTasks) {
-            const status = task.status === 'completed' ? '✓' : task.status === 'in_progress' ? '→' : '○';
-            lines.push(`  ${status} ${task.title}`);
-        }
-        return lines.join('\n');
-    }
-    /**
-     * 获取当前阶段名称（用于失败信号上下文）
-     */
-    getCurrentPhase(projectPath) {
-        const pipeline = this.getActivePipelineForProject(projectPath);
-        if (!pipeline || pipeline.phase === 'done')
-            return undefined;
-        return pipeline.phase;
-    }
-    /**
-     * 获取 Pipeline 阶段快照（用于复盘分析）
-     */
-    getSessionSnapshot(pipelineId) {
-        return this.dynamicNodeExecutor.getSessionSnapshot(pipelineId);
-    }
-    /**
-     * 发射 Step 级别的事件（STEP_STARTED/COMPLETED/FAILED/VALIDATED/RETRYING/NEED_HUMAN）
-     */
-    async emitStepEvents(dynPipeline, event, result) {
-        const currentNode = dynPipeline.nodes.find(n => n.id === dynPipeline.currentNodeId);
-        if (!currentNode)
-            return;
-        // 检查是否启用 Step 模式
-        const stepOrchestrator = this.dynamicNodeExecutor.getStepOrchestrator();
-        if (!stepOrchestrator.isStepModeEnabled(currentNode)) {
-            return; // 未启用 Step 模式，跳过
-        }
-        // 获取当前 Step
-        const currentStep = stepOrchestrator.getCurrentStep(dynPipeline, currentNode);
-        if (!currentStep)
-            return;
-        const stepDef = stepOrchestrator.loadStepDefinition(currentNode.nodeTypeId, currentStep.stepDefinitionId);
-        if (!stepDef)
-            return;
-        // 根据 result 判断应该记录哪些日志
-        if (result.advanced) {
-            // Step 完成
-            logger.info(`[Pipeline:Step] ✅ Step 完成：${stepDef.name}`);
-        }
-        else if (result.blocking) {
-            // Step 需要人工介入
-            logger.warn(`[Pipeline:Step] ⚠️  Step 需要人工介入：${stepDef.name}`);
-        }
-        else if (result.systemMessage && result.systemMessage.includes('重试')) {
-            // Step 重试
-            const maxRetries = stepDef.max_retries ?? DEFAULT_RETRY.MAX_RETRIES;
-            logger.info(`[Pipeline:Step] 🔄 Step 重试：${stepDef.name}（${currentStep.attempts}/${maxRetries}）`);
-        }
-        // 如果 Step 刚开始执行，记录日志
-        if (currentStep.status === 'running' && currentStep.attempts === 0 && !currentStep.startedAt) {
-            logger.info(`[Pipeline:Step] 🚀 Step 开始：${stepDef.name}`);
-        }
-    }
-}
-//# sourceMappingURL=index.js.map