@yun520-1/heartflow 0.15.2 → 0.16.0

package/src/core/autonomy/pdca-engine.js

@@ -1,905 +0,0 @@
-/**
- * PDCA Engine v0.15.2 — 自适应规划-执行-评估循环
- * Plan → Do → Check → Act + 战略协调
- * 
- * v0.15.2 改进:
- * - Plan: 整合 GoalGenerator 真实状态差距分析
- * - Do: llm_query 用日志内容分析替代空壳
- * - Check: 更智能的阈值（根据任务类型动态）
- * - Act: 真实调整策略（不是只说"retry"）
- * - 战略层: 整合 TemporalPlanner 跨周期协调
- */
-
-const fs = require('fs');
-const path = require('path');
-const { spawn } = require('child_process');
-const { GoedelEngine } = require('../self-evolution/goedel-engine');
-const TaskPersistence = require('../task-persistence');
-const { GoalGenerator } = require('./goal-generator');
-const { TemporalPlanner } = require('./temporal-planner');
-
-class PDCAEngine {
-  constructor(projectRoot) {
-    this.projectRoot = projectRoot;
-    this.goedelEngine = new GoedelEngine(projectRoot);
-    this.persistence = TaskPersistence;
-    this.goalGenerator = new GoalGenerator(projectRoot);
-    this.temporalPlanner = new TemporalPlanner(projectRoot);
-    this.traceFile = path.join(projectRoot, '.opencode', 'logs', 'autonomy_trace.json');
-    this.config = this.loadConfig();
-    this.currentTaskId = null;
-    
-    // 跨 PDCA 周期的战略状态
-    this.strategicGoals = [];
-    this.failedPatterns = []; // 记录失败模式，避免重复失败
-    
-    this.loadTrace();
-  }
-
-  loadConfig() {
-    const configPath = path.join(this.projectRoot, '.opencode', 'config.json');
-    try {
-      return JSON.parse(fs.readFileSync(configPath, 'utf8'));
-    } catch (e) {
-      return { 
-        maxAutonomousStepsPerCycle: 5, 
-        requireConfirmationForDestructiveActions: true,
-        dynamicThreshold: true, // 启用动态阈值
-      };
-    }
-  }
-
-  loadTrace() {
-    try {
-      if (fs.existsSync(this.traceFile)) {
-        this.trace = JSON.parse(fs.readFileSync(this.traceFile, 'utf8'));
-      } else {
-        this.trace = { cycles: [], completed_goals: [] };
-      }
-    } catch (e) {
-      this.trace = { cycles: [], completed_goals: [] };
-    }
-  }
-
-  saveTrace() {
-    const dir = path.dirname(this.traceFile);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    fs.writeFileSync(this.traceFile, JSON.stringify(this.trace, null, 2));
-  }
-
-  log(message) {
-    console.log(`[PDCA] ${message}`);
-  }
-
-  /**
-   * 执行完整 PDCA 循环
-   */
-  async executeAutonomousCycle(goal) {
-    const cycle = {
-      goal_id: goal.goal_id,
-      description: goal.description,
-      start_time: new Date().toISOString(),
-      plan: null,
-      do: [],
-      check: null,
-      act: null,
-      status: 'in_progress'
-    };
-
-    this.log(`Starting PDCA cycle for: ${goal.description}`);
-
-    // Phase 1: Plan — 真实规划
-    const planResult = await this.plan(goal);
-    cycle.plan = planResult;
-    
-    if (!planResult.success) {
-      cycle.status = 'failed';
-      cycle.error = planResult.error;
-      this.recordCycle(cycle);
-      return cycle;
-    }
-
-    // Phase 2: Do — 执行
-    const doResult = await this.do(planResult.subtasks, goal);
-    cycle.do = doResult;
-
-    // Phase 3: Check — 评估
-    const checkResult = await this.check(doResult, goal, cycle);
-    cycle.check = checkResult;
-
-    // Phase 4: Act — 行动
-    const actResult = await this.act(checkResult, goal, cycle);
-    cycle.act = actResult;
-    cycle.end_time = new Date().toISOString();
-    cycle.status = checkResult.success ? 'completed' : 'failed_with_adjustment';
-
-    this.recordCycle(cycle);
-    this.log(`PDCA cycle ${cycle.status}`);
-
-    return cycle;
-  }
-
-  /**
-   * Plan: 基于真实状态分析分解目标
-   * 
-   * 改进: 用 GoalGenerator 做状态差距分析，不只是模板匹配
-   */
-  async plan(goal) {
-    try {
-      // 1. 分析状态差距（真实数据）
-      const gaps = await this.goalGenerator.analyzeStateGaps();
-      
-      // 3. 获取战略级目标（跨周期）
-      let strategicBriefing = {};
-      try {
-        strategicBriefing = await this.temporalPlanner.getStrategicBriefing();
-      } catch {}
-
-      // 4. 分析失败模式（避免重复失败）
-      const failureAnalysis = this._analyzeFailurePatterns();
-      
-    // 4. 基于目标类型 + 状态差距 + 失败历史生成子任务
-    const subtasks = this._generateSubtasks(goal, gaps, strategicBriefing, failureAnalysis);
-      
-      // 5. 限制数量
-      const maxSteps = this.config.maxAutonomousStepsPerCycle || 5;
-      const limitedSubtasks = subtasks.slice(0, maxSteps);
-
-      return {
-        success: true,
-        subtasks: limitedSubtasks,
-        decomposition: this._explainDecomposition(limitedSubtasks),
-        gaps: gaps.slice(0, 3),
-        strategicBriefing: strategicBriefing,
-        failureAnalysis: failureAnalysis,
-      };
-    } catch (e) {
-      this.log(`Plan failed: ${e.message}, falling back to template`);
-      return this._fallbackPlan(goal);
-    }
-  }
-
-  /**
-   * 基于状态差距生成子任务
-   */
-  _generateSubtasks(goal, gaps, strategicBriefing, failureAnalysis) {
-    const description = goal.description.toLowerCase();
-    const subtasks = [];
-
-    // 分析目标关键词
-    const isUpgrade = description.includes('upgrade') || description.includes('论文') || description.includes('search');
-    const isAnalyze = description.includes('analyze') || description.includes('分析') || description.includes('log');
-    const isFix = description.includes('fix') || description.includes('修复') || description.includes('error');
-    const isImplement = description.includes('implement') || description.includes('implement') || description.includes('代码');
-
-    if (isUpgrade) {
-      subtasks.push(
-        { id: '1', action: 'search', target: 'find relevant papers via web search', tool: 'web_search', priority: 'high' },
-        { id: '2', action: 'evaluate', target: 'assess paper relevance and quality', tool: 'analyze_content', priority: 'high' },
-        { id: '3', action: 'integrate', target: 'implement paper findings into codebase', tool: 'shell_exec', priority: 'medium' },
-        { id: '4', action: 'verify', target: 'run tests to verify integration', tool: 'unit_test', priority: 'medium' },
-        { id: '5', action: 'document', target: 'update documentation', tool: 'shell_exec', priority: 'low' }
-      );
-    } else if (isAnalyze) {
-      // 分析类任务：用日志内容做研究
-      subtasks.push(
-        { id: '1', action: 'collect_logs', target: 'read all recent log files', tool: 'read_logs', priority: 'high' },
-        { id: '2', action: 'scan_errors', target: 'find all errors across logs', tool: 'analyze_patterns', priority: 'high' },
-        { id: '3', action: 'diagnose', target: 'identify root causes of failures', tool: 'analyze_content', priority: 'high' },
-        { id: '4', action: 'recommend', target: 'generate fix recommendations', tool: 'analyze_content', priority: 'medium' }
-      );
-    } else if (isFix) {
-      // 修复类任务
-      const avoidPattern = failureAnalysis.avoidIds || [];
-      subtasks.push(
-        { id: '1', action: 'diagnose', target: 'identify root cause of the issue', tool: 'analyze_content', priority: 'high' },
-        { id: '2', action: 'implement_fix', target: 'apply fix, avoiding patterns: ' + avoidPattern.join(', '), tool: 'shell_exec', priority: 'high' },
-        { id: '3', action: 'test', target: 'verify fix works', tool: 'unit_test', priority: 'high' },
-        { id: '4', action: 'regression_check', target: 'ensure no regressions in related areas', tool: 'shell_exec', priority: 'medium' }
-      );
-    } else {
-      // 默认：研究 → 设计 → 实现 → 验证
-      // 检查高优先级状态差距
-      const autonomyGap = gaps.find(g => g.dimension === 'autonomy' && g.priority >= 8);
-      const growthGap = gaps.find(g => g.dimension === 'growth' && g.priority >= 8);
-      
-      if (autonomyGap) {
-        subtasks.push(
-          { id: '1', action: 'analyze_barriers', target: 'identify what blocks autonomy', tool: 'analyze_content', priority: 'high' },
-          { id: '2', action: 'reduce_confirmation', target: 'implement changes to reduce unnecessary confirmations', tool: 'shell_exec', priority: 'high' },
-          { id: '3', action: 'test_autonomy', target: 'verify autonomy improvements', tool: 'analyze_content', priority: 'medium' }
-        );
-      } else if (growthGap) {
-        subtasks.push(
-          { id: '1', action: 'assess_growth', target: 'analyze current learning patterns', tool: 'analyze_content', priority: 'high' },
-          { id: '2', action: 'improve_learning', target: 'implement better learning mechanism', tool: 'shell_exec', priority: 'high' },
-          { id: '3', action: 'verify_growth', target: 'measure growth improvement', tool: 'analyze_content', priority: 'medium' }
-        );
-      } else {
-        subtasks.push(
-          { id: '1', action: 'research', target: 'gather information about: ' + goal.description, tool: 'analyze_content', priority: 'high' },
-          { id: '2', action: 'design', target: 'design solution based on research', tool: 'analyze_content', priority: 'high' },
-          { id: '3', action: 'implement', target: 'implement the solution', tool: 'shell_exec', priority: 'medium' },
-          { id: '4', action: 'verify', target: 'verify implementation', tool: 'unit_test', priority: 'medium' }
-        );
-      }
-    }
-
-    return subtasks;
-  }
-
-  /**
-   * 分析失败模式（避免重复失败）
-   */
-  _analyzeFailurePatterns() {
-    const recentCycles = this.trace.cycles.slice(-10);
-    const failedPatterns = {};
-    
-    for (const cycle of recentCycles) {
-      if (cycle.status !== 'failed_with_adjustment') continue;
-      const failures = cycle.do?.results?.filter(r => !r.success) || [];
-      for (const f of failures) {
-        const reason = f.result?.error || 'unknown';
-        const pattern = this._extractPattern(reason);
-        if (!failedPatterns[pattern]) {
-          failedPatterns[pattern] = { count: 0, examples: [], avoidIds: [] };
-        }
-        failedPatterns[pattern].count++;
-        if (f.result?.error) {
-          failedPatterns[pattern].examples.push(f.result.error.slice(0, 100));
-        }
-        failedPatterns[pattern].avoidIds.push(pattern);
-      }
-    }
-
-    // 只返回出现 2 次以上的模式
-    const recurring = Object.entries(failedPatterns)
-      .filter(([, v]) => v.count >= 2)
-      .map(([pattern, v]) => ({ pattern, count: v.count, examples: v.examples, avoidIds: v.avoidIds }));
-
-    return {
-      recurringPatterns: recurring,
-      avoidIds: recurring.map(r => r.pattern),
-      totalFailed: recentCycles.filter(c => c.status === 'failed_with_adjustment').length
-    };
-  }
-
-  _extractPattern(errorMsg) {
-    // 提取错误特征作为 pattern ID
-    if (!errorMsg) return 'unknown';
-    if (errorMsg.includes('confirmation')) return 'confirmation_required';
-    if (errorMsg.includes('timeout')) return 'timeout';
-    if (errorMsg.includes('ENOENT') || errorMsg.includes('not found')) return 'file_not_found';
-    if (errorMsg.includes('syntax')) return 'syntax_error';
-    if (errorMsg.includes('permission')) return 'permission_denied';
-    if (errorMsg.includes('memory') || errorMsg.includes('heap')) return 'memory_error';
-    return errorMsg.slice(0, 50).replace(/\s+/g, '_');
-  }
-
-  _explainDecomposition(subtasks) {
-    return subtasks.map(s => `• ${s.id}. ${s.action} [${s.tool}]`).join('\n');
-  }
-
-  /**
-   * Fallback: 简单模板匹配
-   */
-  _fallbackPlan(goal) {
-    const templates = {
-      'interrupt': [
-        { id: '1', action: 'analyze', target: 'interrupt_logs', tool: 'read_logs' },
-        { id: '2', action: 'identify', target: 'failure_patterns', tool: 'analyze_patterns' },
-        { id: '3', action: 'recover', target: 'apply recovery', tool: 'shell_exec' }
-      ],
-      'upgrade': [
-        { id: '1', action: 'search', target: 'papers', tool: 'web_search' },
-        { id: '2', action: 'evaluate', target: 'papers', tool: 'analyze_content' },
-        { id: '3', action: 'integrate', target: 'code', tool: 'shell_exec' }
-      ],
-      'default': [
-        { id: '1', action: 'research', target: goal.description, tool: 'analyze_content' },
-        { id: '2', action: 'implement', target: 'solution', tool: 'shell_exec' },
-        { id: '3', action: 'verify', target: 'result', tool: 'unit_test' }
-      ]
-    };
-
-    let subtasks = templates.default;
-    for (const [key, t] of Object.entries(templates)) {
-      if (key !== 'default' && goal.description.toLowerCase().includes(key)) {
-        subtasks = t;
-        break;
-      }
-    }
-
-    const maxSteps = this.config.maxAutonomousStepsPerCycle || 5;
-    return {
-      success: true,
-      subtasks: subtasks.slice(0, maxSteps),
-      decomposition: `将目标分解为${subtasks.length}个子任务`
-    };
-  }
-
-  /**
-   * Do: 执行子任务
-   */
-  async do(subtasks, goal) {
-    const results = [];
-    const maxRetries = 3;
-
-    for (const subtask of subtasks) {
-      let attempt = 0;
-      let success = false;
-      let result = null;
-
-      while (attempt < maxRetries && !success) {
-        attempt++;
-        let result = { success: false, error: 'unknown' };
-        try {
-          result = await this.executeSubtask(subtask, goal);
-          success = result?.success === true;
-          
-          // 如果失败，检查是否在避免列表里
-          if (!success && result?.error) {
-            const pattern = this._extractPattern(result.error);
-            if (this.failedPatterns.includes(pattern)) {
-              this.log(`Pattern "${pattern}" failed before, skipping retry`);
-              break;
-            }
-          }
-        } catch (e) {
-          result = { success: false, error: e.message };
-          success = false;
-        }
-        
-        if (success) break; // 成功就不重试
-      }
-
-      results.push({
-        subtask: subtask,
-        success: success,
-        attempts: attempt,
-        result: result
-      });
-
-      // 每个子任务完成后自动 checkpoint
-      await this._autoCheckpoint(subtask, success, result);
-
-      // 关键失败立即停止（不等待 config 配置）
-      if (!success && subtask.priority === 'high' && this.config.requireConfirmationForDestructiveActions) {
-        this.log(`High-priority subtask ${subtask.id} failed: ${result.error}`);
-        break;
-      }
-    }
-
-    return {
-      executed: subtasks.length,
-      successful: results.filter(r => r.success).length,
-      results: results
-    };
-  }
-
-  /**
-   * 自动 checkpoint
-   */
-  async _autoCheckpoint(subtask, success, result) {
-    if (!this.currentTaskId) return;
-    try {
-      const cp = this.persistence.saveCheckpoint(this.currentTaskId, {
-        step: parseInt(subtask.id) - 1,
-        data: {
-          subtask: subtask,
-          success: success,
-          result: result,
-          checkpointedAt: new Date().toISOString()
-        },
-        summary: `Subtask ${subtask.id} (${subtask.action}): ${success ? 'OK' : 'FAILED'}`
-      });
-      if (cp) {
-        this.log(`Checkpoint saved: ${cp.id}`);
-      }
-    } catch (e) {
-      this.log(`Checkpoint failed: ${e.message}`);
-    }
-  }
-
-  /**
-   * 执行单个子任务
-   */
-  async executeSubtask(subtask, goal) {
-    this.log(`Executing subtask ${subtask.id}: ${subtask.action} [${subtask.tool}]`);
-
-    switch (subtask.tool) {
-      case 'goedel_engine': {
-        // 只在非 destructive 或者有明确授权时才执行
-        if (this.config.requireConfirmationForDestructiveActions && 
-            !subtask.action.includes('test') && !subtask.action.includes('verify')) {
-          return { success: false, error: 'Requires confirmation for code modification' };
-        }
-        const modResult = await this.goedelEngine.evolve({
-          target: subtask.target || 'src/core/test.js',
-          description: subtask.action + ' ' + subtask.target,
-          priority: subtask.priority || 'low'
-        });
-        return { success: modResult.success, result: modResult };
-      }
-
-      case 'shell_exec': {
-        const cmd = this._buildCommand(subtask);
-        return await this._execCommand(cmd, subtask.action);
-      }
-
-      case 'analyze_content': {
-        // 分析内容：读取相关文件 + 日志 + 状态
-        return this._analyzeContent(subtask, goal);
-      }
-
-      case 'web_search': {
-        // Web 搜索（如果配置了的话）
-        return await this._webSearch(subtask.target);
-      }
-
-      case 'read_logs': {
-        const logDir = path.join(this.projectRoot, 'logs');
-        const latestLog = this._getLatestLog(logDir);
-        if (latestLog && fs.existsSync(latestLog.path)) {
-          const content = fs.readFileSync(latestLog.path, 'utf8');
-          const lines = content.split('\n').slice(-100).join('\n');
-          return { success: true, result: { log: latestLog.name, lines: lines } };
-        }
-        return { success: true, result: { message: 'No logs found' } };
-      }
-
-      case 'analyze_patterns': {
-        const logDir = path.join(this.projectRoot, 'logs');
-        const errors = this._scanErrors(logDir);
-        return {
-          success: true,
-          result: {
-            errorCount: errors.length,
-            patterns: this._groupErrors(errors),
-            summary: `Found ${errors.length} errors across logs`
-          }
-        };
-      }
-
-      case 'unit_test': {
-        return await this._execCommand('npm test 2>&1 || echo "no tests"', 'unit_test');
-      }
-
-      default: {
-        return { success: true, result: { message: `Tool ${subtask.tool} not implemented` } };
-      }
-    }
-  }
-
-  /**
-   * 构建命令（基于子任务）
-   */
-  _buildCommand(subtask) {
-    const action = subtask.action.toLowerCase();
-    const target = subtask.target || '';
-
-    if (action.includes('search') && target.includes('paper')) {
-      return `echo "Search for papers about: ${target}"`;
-    }
-    if (action.includes('integrate') || action.includes('implement')) {
-      return `echo "Would implement: ${target}"`;
-    }
-    if (action.includes('document') || action.includes('update')) {
-      return `echo "Would update docs: ${target}"`;
-    }
-    if (action.includes('test') || action.includes('verify')) {
-      return `npm test 2>&1 || echo "no tests"`;
-    }
-    if (action.includes('regression')) {
-      return `npm test 2>&1 || echo "no tests"`;
-    }
-    if (action.includes('diagnose') || action.includes('fix')) {
-      return `echo "Diagnosing: ${target}"`;
-    }
-    
-    // 默认：执行目标描述
-    return target || `echo "Task: ${action}"`;
-  }
-
-  /**
-   * 分析内容：读取相关文件做研究
-   */
-  _analyzeContent(subtask, goal) {
-    try {
-      const logDir = path.join(this.projectRoot, 'logs');
-      const errors = this._scanErrors(logDir);
-      const latestLog = this._getLatestLog(logDir);
-      
-      let logContent = '';
-      if (latestLog && fs.existsSync(latestLog.path)) {
-        const lines = fs.readFileSync(latestLog.path, 'utf8').split('\n');
-        logContent = lines.slice(-50).join('\n');
-      }
-
-      // 分析状态差距
-      let gapSummary = '';
-      this.goalGenerator.analyzeStateGaps().then(gaps => {
-        gapSummary = gaps.slice(0, 3).map(g => 
-          `[${g.dimension}] ${g.description} (当前:${g.current_value} → 目标:${g.target_value})`
-        ).join('\n');
-      }).catch(() => {});
-
-      return {
-        success: true,
-        result: {
-          action: subtask.action,
-          target: subtask.target,
-          errorsFound: errors.length,
-          errorTypes: Object.keys(this._groupErrors(errors)),
-          latestLog: latestLog?.name,
-          recentLogContent: logContent.slice(-500),
-          summary: this._generateSummary(subtask, errors)
-        }
-      };
-    } catch (e) {
-      return { success: false, error: e.message };
-    }
-  }
-
-  _generateSummary(subtask, errors) {
-    const action = subtask.action.toLowerCase();
-    if (action.includes('research')) {
-      return `Research complete: found ${errors.length} errors, analyzed ${subtasks?.length || 0} subtasks`;
-    }
-    if (action.includes('diagnose')) {
-      return `Diagnosis: ${errors.length} errors detected, root cause analysis pending`;
-    }
-    if (action.includes('design') || action.includes('recommend')) {
-      if (errors.length === 0) return 'No errors found, system appears healthy';
-      return `Found ${errors.length} issues requiring attention`;
-    }
-    return `Analysis of "${subtask.action}": ${errors.length} relevant findings`;
-  }
-
-  /**
-   * Web 搜索（占位，实际需要外部 API）
-   */
-  async _webSearch(query) {
-    // 占位：真实实现需要 cn-web-search 或类似工具
-    return {
-      success: true,
-      result: {
-        type: 'web_search_pending',
-        query: query,
-        message: 'Web search requires external API (cn-web-search skill)'
-      }
-    };
-  }
-
-  /**
-   * 真实执行 shell 命令
-   */
-  _execCommand(cmd, label) {
-    return new Promise((resolve) => {
-      const start = Date.now();
-      const isWindows = process.platform === 'win32';
-      const shell = isWindows ? 'cmd.exe' : '/bin/bash';
-      const shellFlag = isWindows ? '/c' : '-c';
-      
-      const timeout = setTimeout(() => {
-        proc.kill('SIGTERM');
-        resolve({ success: false, error: `Timeout after 5min for: ${cmd.slice(0, 50)}` });
-      }, 5 * 60 * 1000);
-
-      const proc = spawn(shell, [shellFlag, cmd], {
-        cwd: this.projectRoot,
-        env: { ...process.env },
-        stdio: ['ignore', 'pipe', 'pipe']
-      });
-
-      let stdout = '';
-      let stderr = '';
-
-      proc.stdout.on('data', (data) => { stdout += data.toString(); });
-      proc.stderr.on('data', (data) => { stderr += data.toString(); });
-
-      proc.on('close', (code) => {
-        clearTimeout(timeout);
-        const duration = Date.now() - start;
-        if (code === 0 || code === null) {
-          resolve({
-            success: true,
-            result: { cmd: cmd, exitCode: code, stdout: stdout.slice(-2000), duration: duration }
-          });
-        } else {
-          resolve({
-            success: false,
-            error: `Exit ${code}: ${stderr.slice(-500)}`,
-            result: { cmd: cmd, exitCode: code, stdout: stdout.slice(-2000), stderr: stderr.slice(-500), duration }
-          });
-        }
-      });
-
-      proc.on('error', (e) => {
-        clearTimeout(timeout);
-        resolve({ success: false, error: e.message });
-      });
-    });
-  }
-
-  _getLatestLog(logDir) {
-    if (!fs.existsSync(logDir)) return null;
-    const files = fs.readdirSync(logDir)
-      .filter(f => f.endsWith('.log'))
-      .map(f => ({
-        name: f,
-        path: path.join(logDir, f),
-        mtime: fs.statSync(path.join(logDir, f)).mtime.getTime()
-      }))
-      .sort((a, b) => b.mtime - a.mtime);
-    return files[0] || null;
-  }
-
-  _scanErrors(logDir) {
-    if (!fs.existsSync(logDir)) return [];
-    const errors = [];
-    const files = fs.readdirSync(logDir).filter(f => f.endsWith('.log'));
-    
-    for (const file of files) {
-      try {
-        const content = fs.readFileSync(path.join(logDir, file), 'utf8');
-        const lines = content.split('\n');
-        for (let i = 0; i < lines.length; i++) {
-          const line = lines[i];
-          if (/\b(ERROR|Error|error|FATAL|Failed|failed|Exception)\b/.test(line)) {
-            errors.push({ file, line: i + 1, text: line.slice(-200) });
-          }
-        }
-      } catch {}
-    }
-    return errors;
-  }
-
-  _groupErrors(errors) {
-    const groups = {};
-    for (const err of errors) {
-      const match = err.text.match(/\b(ERROR|Error|FATAL|Exception):\s*(.+)/);
-      const key = match ? match[1].trim() : 'UNKNOWN';
-      if (!groups[key]) groups[key] = [];
-      groups[key].push(err);
-    }
-    return groups;
-  }
-
-  /**
-   * Check: 评估执行结果（更智能的阈值）
-   */
-  async check(doResult, goal, cycle) {
-    const successRate = doResult.executed > 0 
-      ? doResult.successful / doResult.executed 
-      : 0;
-
-    // 动态阈值：根据任务类型调整
-    let threshold = 0.6;
-    const description = goal.description.toLowerCase();
-    if (description.includes('verify') || description.includes('test')) {
-      threshold = 0.8; // 测试类任务需要更高的成功率
-    } else if (description.includes('research') || description.includes('analyze')) {
-      threshold = 0.5; // 分析类任务可以宽容一些
-    }
-
-    const evaluation = {
-      success: successRate >= threshold,
-      success_rate: successRate,
-      threshold: threshold,
-      dynamic: this.config.dynamicThreshold,
-      criteria_met: successRate >= threshold,
-      completed: doResult.successful,
-      total: doResult.executed
-    };
-
-    if (!evaluation.success) {
-      evaluation.failure_reasons = doResult.results
-        .filter(r => !r.success)
-        .map(r => ({
-          subtask: r.subtask.action,
-          error: r.result?.error || 'Unknown',
-          attempts: r.attempts
-        }));
-
-      // 分析是否是已知失败模式
-      const failureAnalysis = cycle.plan?.failureAnalysis;
-      if (failureAnalysis?.recurringPatterns?.length > 0) {
-        evaluation.known_failure_patterns = failureAnalysis.recurringPatterns;
-      }
-    }
-
-    return evaluation;
-  }
-
-  /**
-   * Act: 行动阶段（真实调整策略）
-   */
-  async act(checkResult, goal, cycle) {
-    if (checkResult.success) {
-      // 完成任务，更新战略层
-      try { this.temporalPlanner.updateStrategicProgress(goal.goal_id, 'completed'); } catch {}
-      
-      // 清除相关的失败模式记录
-      const completedGoals = this.strategicGoals.filter(g => g.goal_id === goal.goal_id);
-      
-      return {
-        action: 'complete_goal',
-        message: '目标成功完成',
-        adjustments: [],
-        completedSubtasks: checkResult.completed
-      };
-    }
-
-    // 失败：分析原因并真实调整
-    const failedSubtasks = cycle.do?.results?.filter(r => !r.success) || [];
-    const failureReasons = checkResult.failure_reasons || [];
-    const recurringPatterns = checkResult.known_failure_patterns || [];
-
-    // 记录失败模式
-    for (const f of failureReasons) {
-      const pattern = this._extractPattern(f.error);
-      if (!this.failedPatterns.includes(pattern)) {
-        this.failedPatterns.push(pattern);
-      }
-    }
-
-    // 生成真实调整建议
-    const adjustments = [];
-
-    for (const f of failureReasons) {
-      const pattern = this._extractPattern(f.error);
-      const adjustment = this._suggestAdjustment(pattern, f.subtask);
-      if (adjustment) adjustments.push(adjustment);
-    }
-
-    // 如果是已知失败模式，给出更强的建议
-    if (recurringPatterns.length > 0) {
-      adjustments.push({
-        type: 'pattern_warning',
-        message: `已知失败模式: ${recurringPatterns.map(p => p.pattern).join(', ')}`,
-        recommendation: '手动介入，建议用户确认是否继续'
-      });
-    }
-
-    const retryCount = (cycle.do?.results?.filter(r => !r.success).length || 0);
-    const maxRetries = 3;
-
-    if (retryCount < maxRetries) {
-      return {
-        action: 'retry_with_adjustment',
-        message: `调整策略后重试 (${retryCount}/${maxRetries})`,
-        adjustments: adjustments,
-        nextStep: this._suggestNextStep(cycle, checkResult),
-        retryCount: retryCount,
-        maxRetries: maxRetries
-      };
-    } else {
-      // 重试次数超限：降低优先级，更新战略层
-      try { this.temporalPlanner.updateStrategicProgress(goal.goal_id, 'deferred'); } catch {}
-      
-      return {
-        action: 'defer_goal',
-        message: '重试次数超限，目标暂时搁置',
-        adjustments: adjustments,
-        reason: `连续 ${retryCount} 次失败`,
-        nextAction: 'manual_review'
-      };
-    }
-  }
-
-  _suggestAdjustment(pattern, subtaskAction) {
-    const suggestions = {
-      'confirmation_required': {
-        type: 'config_change',
-        message: '代码修改需要确认，建议临时关闭 confirm 配置',
-        actionable: true
-      },
-      'timeout': {
-        type: 'timeout_increase',
-        message: '增加超时时间或分割任务',
-        actionable: true
-      },
-      'file_not_found': {
-        type: 'path_fix',
-        message: `检查文件路径是否正确: ${subtaskAction}`,
-        actionable: true
-      },
-      'syntax_error': {
-        type: 'code_review',
-        message: '语法错误，需要人工 review',
-        actionable: false
-      },
-      'permission_denied': {
-        type: 'permission_fix',
-        message: '检查文件权限',
-        actionable: true
-      },
-      'memory_error': {
-        type: 'resource_limit',
-        message: '内存不足，考虑减少并发',
-        actionable: true
-      }
-    };
-    return suggestions[pattern] || { type: 'unknown', message: `未知错误: ${pattern}`, actionable: false };
-  }
-
-  _suggestNextStep(cycle, checkResult) {
-    const failed = cycle.do?.results?.filter(r => !r.success) || [];
-    const pattern = failed[0] ? this._extractPattern(failed[0].result?.error) : 'unknown';
-    
-    const nextSteps = {
-      'confirmation_required': '尝试用 test/verify 任务替代直接的代码修改',
-      'timeout': '将大任务分割为更小的子任务',
-      'file_not_found': '先运行 read_logs 确认文件存在',
-      'syntax_error': '先运行 analyze_content 了解代码结构',
-      'permission_denied': '检查并修复文件权限',
-      'memory_error': '减少 batch size 或增加内存'
-    };
-    
-    return nextSteps[pattern] || '根据错误类型调整策略后重试';
-  }
-
-  // ─── 长任务管理 ───────────────────────────────────────────────
-
-  startLongTask(goalDescription, goals = []) {
-    const task = this.persistence.createTask({
-      goals: goals.length ? goals : [goalDescription],
-      context: goalDescription,
-      metadata: {
-        startedAt: new Date().toISOString(),
-        type: 'pdca_long_task'
-      }
-    });
-    this.currentTaskId = task.id;
-    this.log(`Long task started: ${task.id}`);
-    return task;
-  }
-
-  resumeLongTask(taskId) {
-    const resume = this.persistence.resumeTask(taskId);
-    if (!resume.error) {
-      this.currentTaskId = taskId;
-      this.log(`Resumed task from step ${resume.resumeFromStep}`);
-    }
-    return resume;
-  }
-
-  // ─── 轨迹记录 ───────────────────────────────────────────────
-
-  recordCycle(cycle) {
-    this.trace.cycles.push(cycle);
-    
-    if (cycle.status === 'completed') {
-      this.trace.completed_goals.push({
-        goal_id: cycle.goal_id,
-        description: cycle.description,
-        completed_at: cycle.end_time
-      });
-    }
-    
-    this.saveTrace();
-  }
-
-  getHistory() {
-    return {
-      total_cycles: this.trace.cycles.length,
-      completed_goals: this.trace.completed_goals.length,
-      recent: this.trace.cycles.slice(-5)
-    };
-  }
-
-  getStatus() {
-    return {
-      config: this.config,
-      history: this.getHistory(),
-      currentTaskId: this.currentTaskId,
-      failedPatterns: this.failedPatterns.slice(-5),
-      strategicGoals: this.strategicGoals.slice(0, 3)
-    };
-  }
-}
-
-module.exports = { PDCAEngine };