@winspan/claude-forge 0.9.4 → 1.1.0

package/dist/pipeline/phase-manager.js

@@ -1,8 +1,9 @@
 import { PHASE_LABELS, nextPhase } from './types.js';
 import { logger } from '../utils/logger.js';
 import { memoryManager } from '../utils/memory-manager.js';
+import fs from 'fs';
+import path from 'path';
 export class PhaseManager {
-    taskCompletionDetector;
     store;
     knowledgeContext = memoryManager.register('phase:knowledge', { max: 100, ttl: 24 * 3600_000 });
     totalPhaseEventCounts = memoryManager.register('phase:eventCounts', { max: 100, ttl: 24 * 3600_000 });
@@ -13,10 +14,13 @@ export class PhaseManager {
     phaseWriteEditCounts = memoryManager.register('phase:writeEditCounts', { max: 100, ttl: 24 * 3600_000 });
     /** 追踪每个 pipeline:phase 最近 5 次工具调用 */
     recentTools = memoryManager.register('phase:recentTools', { max: 100, ttl: 24 * 3600_000 });
+    /** 质量门禁去重缓存：已通过的 pipeline:phase 不再重复检查（24h TTL） */
+    gatePassedCache = memoryManager.register('phase:gatePassed', { max: 100, ttl: 24 * 3600_000 });
+    /** 活动阈值触发标记：标记为 true 的 pipeline:phase 跳过质量门禁直接推进 */
+    activityThresholdTriggered = memoryManager.register('phase:thresholdTriggered', { max: 100, ttl: 24 * 3600_000 });
     static MAX_FIX_ATTEMPTS = 3;
     static EMPTY_PHASE_ADVANCE_THRESHOLD = 3;
-    constructor(store, taskCompletionDetector) {
-        this.taskCompletionDetector = taskCompletionDetector;
+    constructor(store) {
         this.store = store;
     }
     /**
@@ -114,6 +118,11 @@ export class PhaseManager {
             // 注入任务完成信号说明（让 Claude 主动确认完成，而非被动猜测）
             parts.push(`完成后执行：echo "FORGE_TASK_DONE: ${currentTask.id}"`);
         }
+        // 阶段指导：注入当前阶段的具体工作指导（让 Claude 知道该做什么）
+        const directive = this.getPhaseDirective(phase, currentTask, pipeline);
+        if (directive) {
+            parts.push(`\n${directive}`);
+        }
         // 待完成任务（仅显示前 3 个，超过则省略）
         const pendingTasks = phaseTasks.filter(t => t.status !== 'completed');
         if (pendingTasks.length > 1) {
@@ -124,217 +133,259 @@ export class PhaseManager {
         return parts.join(' ');
     }
     /**
-     * 根据 PostToolUse 事件判断是否推进阶段
+     * 根据 PostToolUse 事件判断是否推进阶段（重构版：职责分离 + 信号优先）
      */
     async checkAndAdvance(pipeline, event, qualityGate) {
+        const phase = pipeline.phase;
+        // 1. 工具追踪
+        this.trackToolUsage(pipeline, event);
+        // 2. 空阶段自愈
+        const emptyPhaseResult = this.handleEmptyPhase(pipeline);
+        if (emptyPhaseResult)
+            return emptyPhaseResult;
+        // 3. 任务完成检测
+        this.detectAndMarkCompletion(pipeline, event);
+        // 4. 活动阈值检测
+        const thresholdResult = this.handleActivityThreshold(pipeline);
+        // 5. 检查阶段是否全部完成
+        const progress = this.store.getPhaseProgress(pipeline.id, phase);
+        if (progress.total === 0 || progress.completed < progress.total) {
+            return { advanced: false };
+        }
+        // 6. 质量门禁（仅首次完成时触发，活动阈值触发时跳过）
+        if (qualityGate) {
+            const gateResult = await this.runQualityGateOnce(pipeline, event, qualityGate);
+            if (gateResult.blocked) {
+                return {
+                    advanced: false,
+                    qualityBlocked: true,
+                    qualityIssues: gateResult.issues,
+                    qualityLevel: gateResult.level,
+                    fixAttempts: gateResult.fixAttempts,
+                };
+            }
+        }
+        // 7. 阶段推进
+        return this.advancePhase(pipeline, thresholdResult?.message);
+    }
+    /**
+     * 1. 工具追踪：记录工具类别、调用次数、最近工具
+     */
+    trackToolUsage(pipeline, event) {
         const phase = pipeline.phase;
         const toolName = event.tool_name || '';
         const inputStr = event.tool_input ? JSON.stringify(event.tool_input) : '';
-        // 记录本阶段已见过的工具类型（用于多样性判定）
-        const toolsKey = `${pipeline.id}:${phase}`;
-        const toolsStr = this.phaseToolsSeen.get(toolsKey) ?? '';
+        const key = `${pipeline.id}:${phase}`;
+        // 工具类别追踪
+        const toolsStr = this.phaseToolsSeen.get(key) ?? '';
         const toolsSeenSet = toolsStr ? new Set(toolsStr.split(',')) : new Set();
         const toolCategory = this.categorizeToolCall(toolName, inputStr);
         if (toolCategory)
             toolsSeenSet.add(toolCategory);
-        this.phaseToolsSeen.set(toolsKey, [...toolsSeenSet].join(','));
-        const toolsSeen = toolsSeenSet;
-        // 标记当前任务完成的信号
+        this.phaseToolsSeen.set(key, [...toolsSeenSet].join(','));
+        // 调用次数追踪
+        const eventCount = this.totalPhaseEventCounts.get(key) || 0;
+        this.totalPhaseEventCounts.set(key, eventCount + 1);
+        // Write/Edit 次数追踪
+        if (toolName === 'Write' || toolName === 'Edit') {
+            const writeEditCount = this.phaseWriteEditCounts.get(key) || 0;
+            this.phaseWriteEditCounts.set(key, writeEditCount + 1);
+        }
+        // 最近 5 次工具追踪
+        const recent = this.recentTools.get(key) || [];
+        recent.push(toolName);
+        if (recent.length > 5)
+            recent.shift();
+        this.recentTools.set(key, recent);
+    }
+    /**
+     * 2. 空阶段自愈：当前阶段无任务时自动推进
+     */
+    handleEmptyPhase(pipeline) {
+        const phase = pipeline.phase;
+        const progress = this.store.getPhaseProgress(pipeline.id, phase);
+        const key = `${pipeline.id}:${phase}`;
+        const eventCount = this.totalPhaseEventCounts.get(key) || 0;
+        if (progress.total === 0 && eventCount >= PhaseManager.EMPTY_PHASE_ADVANCE_THRESHOLD) {
+            logger.warn(`[Pipeline] 阶段 ${PHASE_LABELS[phase]} 无任务（phase 标签可能无效），自动推进到下一阶段`);
+            const newPh = nextPhase(phase, pipeline.plannedPhases);
+            this.store.updatePhase(pipeline.id, newPh);
+            this.phaseToolsSeen.delete(key);
+            this.gatePassedCache.delete(key);
+            this.activityThresholdTriggered.delete(key);
+            return { advanced: true, newPhase: newPh };
+        }
+        return null;
+    }
+    /**
+     * 3. 任务完成检测：优先显式信号，回退到启发式
+     */
+    detectAndMarkCompletion(pipeline, event) {
+        const phase = pipeline.phase;
+        const toolName = event.tool_name || '';
+        const inputStr = event.tool_input ? JSON.stringify(event.tool_input) : '';
         const pendingTasks = pipeline.tasks.filter(t => t.phase === phase && (t.status === 'in_progress' || t.status === 'pending'));
         for (const currentTask of pendingTasks) {
-            const completed = this.detectTaskCompletion(phase, toolName, inputStr, event, toolsSeen);
+            const completed = this.detectTaskCompletion(phase, toolName, inputStr, event, currentTask, pipeline.id);
             if (completed) {
-                // 生成成果摘要：工具名 + 操作对象（文件路径或关键信息）
                 const artifact = this.summarizeArtifact(toolName, inputStr, event);
                 this.store.updateTaskStatus(currentTask.id, 'completed', artifact);
                 logger.info(`[Pipeline] 任务已完成：${currentTask.title} | 成果：${artifact}`);
                 break; // 每次事件只完成一个任务
             }
         }
-        // 兜底推进：同一阶段累积了足够多的工具调用，强制将剩余任务标记完成
-        // 前提条件：至少有一个任务已完成（避免还没开始就被强制跳过）
+    }
+    /**
+     * 4. 活动阈值检测：达到阈值后强制完成剩余任务
+     */
+    handleActivityThreshold(pipeline) {
+        const phase = pipeline.phase;
         const progress = this.store.getPhaseProgress(pipeline.id, phase);
-        const activityThreshold = this.getPhaseActivityThreshold(phase, pipeline.complexity);
-        const phaseEventCount = this.totalPhaseEventCounts.get(`${pipeline.id}:${phase}`) || 0;
-        this.totalPhaseEventCounts.set(`${pipeline.id}:${phase}`, phaseEventCount + 1);
-        // 追踪 Write/Edit 调用次数（供 getSessionSnapshot 使用）
-        if (toolName === 'Write' || toolName === 'Edit') {
-            const writeEditKey = `${pipeline.id}:${phase}`;
-            const writeEditCount = this.phaseWriteEditCounts.get(writeEditKey) || 0;
-            this.phaseWriteEditCounts.set(writeEditKey, writeEditCount + 1);
-        }
-        // 空阶段自愈：当前阶段无任务（可能因 AI 返回了无效 phase 标签），
-        // 累积足够工具调用后自动推进，避免 Pipeline 永久卡死
-        if (progress.total === 0 && phaseEventCount + 1 >= PhaseManager.EMPTY_PHASE_ADVANCE_THRESHOLD) {
-            logger.warn(`[Pipeline] 阶段 ${PHASE_LABELS[phase]} 无任务（phase 标签可能无效），自动推进到下一阶段`);
-            const newPh = nextPhase(phase, pipeline.plannedPhases);
-            this.store.updatePhase(pipeline.id, newPh);
-            this.phaseToolsSeen.delete(`${pipeline.id}:${phase}`);
-            return { advanced: true, newPhase: newPh };
-        }
-        // 追踪最近 5 次工具调用（供 TaskCompletionDetector 使用）
-        const recentKey = `${pipeline.id}:${phase}`;
-        const recent = this.recentTools.get(recentKey) || [];
-        recent.push(toolName);
-        if (recent.length > 5)
-            recent.shift();
-        this.recentTools.set(recentKey, recent);
-        // LLM 语义检测：在达到阈值前尝试智能判断是否完成（非阻塞，结果在下次事件中生效）
-        if (this.taskCompletionDetector && progress.completed < progress.total && phaseEventCount + 1 >= Math.floor(activityThreshold * 0.7)) {
-            // 异步触发，不阻塞当前事件处理
-            this.taskCompletionDetector.detect({
-                requirement: pipeline.requirement,
-                currentPhase: phase,
-                recentTools: recent,
-                toolCallCount: phaseEventCount + 1,
-                completedTaskCount: progress.completed,
-                totalTaskCount: progress.total,
-            }).then(detectionResult => {
-                if (detectionResult.isComplete && detectionResult.confidence !== 'low') {
-                    logger.info(`[Pipeline] LLM 检测到 ${PHASE_LABELS[phase]} 阶段已完成（${detectionResult.confidence}），标记剩余任务`);
-                    const remaining = pipeline.tasks.filter(t => t.phase === phase && t.status !== 'completed');
-                    for (const t of remaining) {
-                        this.store.updateTaskStatus(t.id, 'completed', `LLM 检测完成：${detectionResult.reason}`);
-                    }
-                }
-            }).catch(err => {
-                logger.warn(`[Pipeline] LLM 任务完成检测失败，降级到阈值逻辑：${err}`);
-            });
-        }
-        // 兜底推进：活动阈值强制完成（LLM 检测失败或未启用时的保底机制）
-        let forcedCompletionMessage;
-        if (progress.completed < progress.total && phaseEventCount + 1 >= activityThreshold) {
-            logger.info(`[Pipeline] 活动阈值（${activityThreshold}）已达到，强制完成 ${PHASE_LABELS[phase]} 阶段剩余任务`);
+        const key = `${pipeline.id}:${phase}`;
+        const eventCount = this.totalPhaseEventCounts.get(key) || 0;
+        const threshold = this.getPhaseActivityThreshold(phase, pipeline.complexity);
+        if (progress.completed < progress.total && eventCount >= threshold) {
+            logger.info(`[Pipeline] 活动阈值（${threshold}）已达到，强制完成 ${PHASE_LABELS[phase]} 阶段剩余任务`);
             const remaining = pipeline.tasks.filter(t => t.phase === phase && t.status !== 'completed');
             for (const t of remaining) {
-                this.store.updateTaskStatus(t.id, 'completed');
+                this.store.updateTaskStatus(t.id, 'completed', `活动阈值强制完成（${eventCount}次工具调用）`);
             }
-            // 生成用户可见的通知消息
+            // 标记活动阈值触发，跳过质量门禁
+            this.activityThresholdTriggered.set(key, true);
             const remainingTitles = remaining.map(t => `- ${t.title}`).join('\n');
-            forcedCompletionMessage = `[Forge 自动推进] ℹ️ ${PHASE_LABELS[phase]}阶段活动充分（${phaseEventCount + 1} 次工具调用），自动完成剩余任务：
+            return {
+                message: `[Forge 自动推进] ℹ️ ${PHASE_LABELS[phase]}阶段活动充分（${eventCount} 次工具调用），自动完成剩余任务：
 
 ${remainingTitles}
 
-继续下一阶段工作。`;
+继续下一阶段工作。`
+            };
         }
-        // 检查阶段是否全部完成
-        const updatedProgress = this.store.getPhaseProgress(pipeline.id, phase);
-        if (updatedProgress.total > 0 && updatedProgress.completed >= updatedProgress.total) {
-            // 质量门禁：阶段推进前检查（含自动修复循环）
-            let qualityLevel;
-            if (qualityGate) {
-                const fixKey = `${pipeline.id}:${phase}`;
-                const fixAttempts = this.phaseFixAttempts.get(fixKey) || 0;
-                // analyze/design 阶段产出为文本，使用 reviewPhaseCompletion
-                // code/test/review 阶段：优先用 reviewForPhase（有代码内容），否则降级到 reviewPhaseCompletion
-                const phaseTasks = pipeline.tasks.filter(t => t.phase === phase);
-                const phaseContext = phaseTasks
-                    .map(t => `- ${t.title}: ${t.output || '(进行中)'}`)
-                    .join('\n');
-                // 活动阈值强制完成时，任务 output 为空，质量门禁无法评审产出物。
-                // 此时跳过 reviewPhaseCompletion，视为通过（活动阈值本身已作为充分性判断）。
-                const hasRealOutput = phaseTasks.some(t => t.output && t.output.trim().length > 0);
-                const skipGate = !hasRealOutput && (phase === 'analyze' || phase === 'design');
-                if (skipGate) {
-                    logger.info(`[Pipeline] ${PHASE_LABELS[phase]}阶段任务均无产出物（活动阈值强制完成），跳过质量门禁，直接推进`);
-                    this.phaseFixAttempts.delete(fixKey);
-                }
-                let gateResult = skipGate ? null : (phase === 'analyze' || phase === 'design')
-                    ? await qualityGate.reviewPhaseCompletion(phase, pipeline.requirement, phaseContext)
-                    : await qualityGate.reviewForPhase(event, phase);
-                // reviewForPhase 返回 null 表示事件不适用（非 Write/Edit），降级到 reviewPhaseCompletion
-                if (gateResult === null && phase !== 'analyze' && phase !== 'design') {
-                    gateResult = await qualityGate.reviewPhaseCompletion(phase, pipeline.requirement, phaseContext);
-                }
-                if (gateResult && gateResult.level === 'fail') {
-                    const newAttempts = fixAttempts + 1;
-                    this.phaseFixAttempts.set(fixKey, newAttempts);
-                    const failIssues = gateResult.checks
-                        .filter(c => c.level === 'fail')
-                        .map(c => `[${c.category}] ${c.message}${c.suggestion ? `\n  修复建议：${c.suggestion}` : ''}`);
-                    if (newAttempts >= PhaseManager.MAX_FIX_ATTEMPTS) {
-                        // 达到最大重试次数，强制放行并记录警告——避免 Pipeline 永久卡死产生垃圾数据
-                        logger.warn(`[Pipeline] 质量门禁阶段 ${PHASE_LABELS[phase]} 已达最大修复次数（${PhaseManager.MAX_FIX_ATTEMPTS}），强制放行，记录警告`);
-                        this.phaseFixAttempts.delete(fixKey);
-                        // 不 return，继续执行后续阶段推进逻辑，让 Pipeline 正常前进
-                    }
-                    else {
-                        logger.warn(`[Pipeline] 质量门禁阻止推进 ${PHASE_LABELS[phase]}（第 ${newAttempts}/${PhaseManager.MAX_FIX_ATTEMPTS} 次）：${gateResult.summary}`);
-                        const completedTasks = pipeline.tasks
-                            .filter(t => t.phase === phase && t.status === 'completed')
-                            .map(t => `- ${t.title}`)
-                            .join('\n') || '（无）';
-                        // 按严重程度排序：security > spec > quality > test > performance
-                        const priorityOrder = ['security', 'spec', 'quality', 'test', 'performance'];
-                        const sortedIssues = [...failIssues].sort((a, b) => {
-                            const aIdx = priorityOrder.findIndex(p => a.includes(`[${p}]`));
-                            const bIdx = priorityOrder.findIndex(p => b.includes(`[${p}]`));
-                            return (aIdx === -1 ? 99 : aIdx) - (bIdx === -1 ? 99 : bIdx);
-                        });
-                        const systemMessage = `[Forge 质量门禁] ❌ ${PHASE_LABELS[phase]}阶段检查未通过（${newAttempts}/${PhaseManager.MAX_FIX_ATTEMPTS}）
-
-## 必须修复（按优先级）
-
-${sortedIssues.join('\n\n')}
-
-## 快速修复步骤
-1. 优先修复 [security] 问题（安全漏洞）
-2. 其次修复 [spec] 问题（需求不符）
-3. 最后处理 [quality]/[test] 问题
-4. 修复后继续工作，门禁将自动重新检查
-${newAttempts >= PhaseManager.MAX_FIX_ATTEMPTS - 1 ? '\n⚠️ 最后机会：下次仍不通过将强制放行。' : ''}`;
-                        return {
-                            advanced: false,
-                            qualityBlocked: true,
-                            qualityIssues: failIssues,
-                            systemMessage,
-                            qualityLevel: 'fail',
-                            fixAttempts: newAttempts,
-                        };
-                    }
-                }
-                else {
-                    // pass 或 warn：清理修复计数，允许阶段推进
-                    // warn 不阻断，仅记录日志
-                    qualityLevel = gateResult?.level ?? 'pass';
-                    if (fixAttempts > 0) {
-                        logger.info(`[Pipeline] 质量门禁 ${PHASE_LABELS[phase]} 通过（经过 ${fixAttempts} 次修复）`);
+        return null;
+    }
+    /**
+     * 5. 质量门禁（去重版）：已通过的阶段不再重复检查，活动阈值触发时跳过
+     */
+    async runQualityGateOnce(pipeline, event, qualityGate) {
+        const phase = pipeline.phase;
+        const cacheKey = `${pipeline.id}:${phase}`;
+        // 活动阈值触发时跳过质量门禁
+        if (this.activityThresholdTriggered.get(cacheKey)) {
+            logger.info(`[Pipeline] 活动阈值触发，跳过质量门禁，直接推进`);
+            return { blocked: false, level: 'pass' };
+        }
+        // 已通过，跳过
+        if (this.gatePassedCache.has(cacheKey)) {
+            return { blocked: false, level: 'pass' };
+        }
+        // 首次检查
+        const fixKey = `${pipeline.id}:${phase}`;
+        const fixAttempts = this.phaseFixAttempts.get(fixKey) || 0;
+        const phaseTasks = pipeline.tasks.filter(t => t.phase === phase);
+        const taskContext = phaseTasks
+            .map(t => `- ${t.title}: ${t.output || '(进行中)'}`)
+            .join('\n');
+        const recentFiles = this.getRecentlyModifiedFiles(pipeline.projectPath, 30);
+        const recentFilesNote = recentFiles.length > 0
+            ? `\n\n## 最近修改的文件（30分钟内）\n${recentFiles.map(f => `- ${f}`).join('\n')}`
+            : '';
+        const phaseContext = taskContext + recentFilesNote;
+        let gateResult = (phase === 'analyze' || phase === 'design')
+            ? await qualityGate.reviewPhaseCompletion(phase, pipeline.requirement, phaseContext)
+            : await qualityGate.reviewForPhase(event, phase);
+        if (gateResult === null && phase !== 'analyze' && phase !== 'design') {
+            gateResult = await qualityGate.reviewPhaseCompletion(phase, pipeline.requirement, phaseContext);
+        }
+        if (gateResult && gateResult.level === 'fail') {
+            const newAttempts = fixAttempts + 1;
+            this.phaseFixAttempts.set(fixKey, newAttempts);
+            const failIssues = gateResult.checks
+                .filter(c => c.level === 'fail')
+                .map(c => `[${c.category}] ${c.message}${c.suggestion ? `\n  修复建议：${c.suggestion}` : ''}`);
+            if (newAttempts >= PhaseManager.MAX_FIX_ATTEMPTS) {
+                logger.warn(`[Pipeline] 质量门禁阶段 ${PHASE_LABELS[phase]} 已达最大修复次数（${PhaseManager.MAX_FIX_ATTEMPTS}），强制放行`);
+                this.phaseFixAttempts.delete(fixKey);
+                this.gatePassedCache.set(cacheKey, true);
+                return { blocked: false, level: 'warn' };
+            }
+            return {
+                blocked: true,
+                issues: failIssues,
+                level: 'fail',
+                fixAttempts: newAttempts,
+            };
+        }
+        // 通过或警告，标记缓存
+        if (gateResult) {
+            this.gatePassedCache.set(cacheKey, true);
+            this.phaseFixAttempts.delete(fixKey);
+        }
+        return { blocked: false, level: gateResult?.level || 'pass' };
+    }
+    /**
+     * 6. 阶段推进
+     */
+    async advancePhase(pipeline, forcedMessage) {
+        const phase = pipeline.phase;
+        const newPh = nextPhase(phase, pipeline.plannedPhases);
+        // 跨阶段补充检测
+        let gapMessage;
+        const nextProgress = this.store.getPhaseProgress(pipeline.id, newPh);
+        if (nextProgress.total === 0 && newPh !== 'done') {
+            gapMessage = `[Forge 阶段间隙] ⚠️ ${PHASE_LABELS[newPh]}阶段暂无任务，可能需要手动创建任务或等待自动推进。`;
+            logger.warn(`[Pipeline] 阶段间隙：${PHASE_LABELS[newPh]} 无任务`);
+        }
+        this.store.updatePhase(pipeline.id, newPh);
+        const oldKey = `${pipeline.id}:${phase}`;
+        this.phaseToolsSeen.delete(oldKey);
+        this.gatePassedCache.delete(oldKey);
+        this.activityThresholdTriggered.delete(oldKey);
+        const phaseTasks = pipeline.tasks.filter(t => t.phase === phase);
+        const artifacts = phaseTasks
+            .map(t => `  - ${t.title}: ${t.output || '(无记录)'}`)
+            .join('\n');
+        logger.info(`[Pipeline] 阶段推进：${PHASE_LABELS[phase]} → ${PHASE_LABELS[newPh]}\n` +
+            `  完成 ${phaseTasks.length} 个任务，成果汇总：\n${artifacts}`);
+        return { advanced: true, newPhase: newPh, gapMessage: gapMessage ?? forcedMessage };
+    }
+    /**
+     * 获取项目目录中最近 N 分钟内修改的文件列表（相对路径）
+     * 用于增强质量门禁的 phaseContext，让 AI 有实际依据
+     */
+    getRecentlyModifiedFiles(projectPath, minutes) {
+        const cutoff = Date.now() - minutes * 60_000;
+        const result = [];
+        const ignoreDirs = new Set(['.git', 'node_modules', 'dist', '.claude-forge', '.claude']);
+        const walk = (dir, depth) => {
+            if (depth > 4)
+                return;
+            try {
+                const entries = fs.readdirSync(dir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (ignoreDirs.has(entry.name))
+                        continue;
+                    const fullPath = path.join(dir, entry.name);
+                    if (entry.isDirectory()) {
+                        walk(fullPath, depth + 1);
                     }
-                    if (gateResult?.level === 'warn') {
-                        logger.warn(`[Pipeline] 质量门禁 ${PHASE_LABELS[phase]} 有警告但允许推进：${gateResult.summary}`);
+                    else if (entry.isFile()) {
+                        try {
+                            const stat = fs.statSync(fullPath);
+                            if (stat.mtimeMs >= cutoff) {
+                                result.push(path.relative(projectPath, fullPath));
+                            }
+                        }
+                        catch { /* 忽略无法访问的文件 */ }
                     }
-                    this.phaseFixAttempts.delete(fixKey);
-                }
-            }
-            const newPh = nextPhase(phase, pipeline.plannedPhases);
-            // 跨阶段补充检测：在阶段切换前检测上一阶段遗留问题
-            let gapMessage;
-            if (qualityGate?.phaseGapDetector) {
-                const gapResult = qualityGate.phaseGapDetector.detect(pipeline, phase, newPh);
-                if (gapResult.action === 'ask_user' && gapResult.systemMessage) {
-                    // 暂停：需求歧义未解决，追问用户后才能推进
-                    logger.info(`[Pipeline] 跨阶段检测：${PHASE_LABELS[phase]}→${PHASE_LABELS[newPh]} 发现需求歧义，暂停推进`);
-                    return { advanced: false, qualityBlocked: true, systemMessage: gapResult.systemMessage };
-                }
-                if (gapResult.systemMessage) {
-                    // 非阻断：注入提示，Pipeline 继续推进
-                    gapMessage = gapResult.systemMessage;
-                    logger.info(`[Pipeline] 跨阶段检测：${PHASE_LABELS[phase]}→${PHASE_LABELS[newPh]} 注入补充提示（${gapResult.action}）`);
                 }
             }
-            this.store.updatePhase(pipeline.id, newPh);
-            // totalPhaseEventCounts 保留累积记录，供复盘分析使用
-            this.phaseToolsSeen.delete(`${pipeline.id}:${phase}`);
-            // 汇总本阶段所有任务的成果
-            const phaseTasks = pipeline.tasks.filter(t => t.phase === phase);
-            const artifacts = phaseTasks
-                .map(t => `  - ${t.title}: ${t.output || '(无记录)'}`)
-                .join('\n');
-            logger.info(`[Pipeline] 阶段推进：${PHASE_LABELS[phase]} → ${PHASE_LABELS[newPh]}\n` +
-                `  完成 ${phaseTasks.length} 个任务，成果汇总：\n${artifacts}`);
-            return { advanced: true, newPhase: newPh, gapMessage: gapMessage ?? forcedCompletionMessage, qualityLevel };
+            catch { /* 忽略无法读取的目录 */ }
+        };
+        try {
+            walk(projectPath, 0);
         }
-        return { advanced: false };
+        catch { /* 忽略整体失败 */ }
+        return result.slice(0, 20); // 最多返回 20 个文件，避免 prompt 过长
     }
     /** 每个阶段兜底推进所需的最少工具调用次数（按复杂度动态调整） */
     getPhaseActivityThreshold(phase, complexity) {
@@ -381,17 +432,26 @@ ${taskDesc}`;
         }
     }
     /**
-     * 检测任务是否完成（基于工具调用模式和多样性）
+     * 检测任务是否完成（重构版：信号优先 + 启发式回退）
      */
-    detectTaskCompletion(phase, toolName, inputStr, event, toolsSeen) {
+    detectTaskCompletion(phase, toolName, inputStr, event, currentTask, pipelineId) {
         // 优先检测显式完成信号（FORGE_TASK_DONE），100% 准确，无需模式匹配
         // 信号格式：echo "FORGE_TASK_DONE: <task_id>" 或文件注释 // FORGE: task_done <task_id>
         if (toolName === 'Bash' && inputStr.includes('FORGE_TASK_DONE:')) {
-            return true;
+            const match = inputStr.match(/FORGE_TASK_DONE:\s*(\S+)/);
+            if (match && match[1] === currentTask.id) {
+                logger.info(`[Pipeline] 检测到显式完成信号：${currentTask.id}`);
+                return true;
+            }
         }
         if ((toolName === 'Write' || toolName === 'Edit') && inputStr.includes('FORGE: task_done')) {
-            return true;
+            const match = inputStr.match(/FORGE:\s*task_done\s+(\S+)/);
+            if (match && match[1] === currentTask.id) {
+                logger.info(`[Pipeline] 检测到显式完成信号：${currentTask.id}`);
+                return true;
+            }
         }
+        // 回退到启发式检测（保留向后兼容）
         switch (phase) {
             case 'analyze':
                 // 分析阶段：有输出类工具（Write/Edit）即可，或明确的确认信号
@@ -399,7 +459,6 @@ ${taskDesc}`;
                     inputStr.includes('已分析') || inputStr.includes('analysis complete')) {
                     return true;
                 }
-                // 写入分析文档即算完成（不强制要求先探索，避免过度严格）
                 return toolName === 'Write' || toolName === 'Edit';
             case 'design':
                 // 设计阶段：必须有架构文档写入（Write 或 Edit），支持中英文文档名
@@ -422,17 +481,21 @@ ${taskDesc}`;
                     inputStr.includes('.vue') || inputStr.includes('.svelte'));
             case 'test': {
                 // 测试阶段：必须同时有测试文件写入 AND 测试执行（非 watch 模式）
+                const key = `${pipelineId}:${phase}`;
+                const toolsStr = this.phaseToolsSeen.get(key) ?? '';
+                const toolsSeenSet = toolsStr ? new Set(toolsStr.split(',')) : new Set();
                 const hasTestFile = (toolName === 'Write' || toolName === 'Edit') &&
                     (inputStr.includes('test') || inputStr.includes('spec'));
                 const hasTestRun = toolName === 'Bash' &&
                     (inputStr.includes('test') || inputStr.includes('vitest') || inputStr.includes('jest')) &&
                     !inputStr.includes('--watch');
-                // 持久化到 toolsSeenSet（L176 会自动写回 phaseToolsSeen），跨事件追踪
+                // 持久化标记（trackToolUsage 已更新 phaseToolsSeen）
                 if (hasTestFile)
-                    toolsSeen.add('test:file');
+                    toolsSeenSet.add('test:file');
                 if (hasTestRun)
-                    toolsSeen.add('test:run');
-                return toolsSeen.has('test:file') && toolsSeen.has('test:run');
+                    toolsSeenSet.add('test:run');
+                this.phaseToolsSeen.set(key, [...toolsSeenSet].join(','));
+                return toolsSeenSet.has('test:file') && toolsSeenSet.has('test:run');
             }
             case 'review':
                 // 审查阶段：有代码修改（Edit）即可（质量门禁已在 checkAndAdvance 中把关）