devassist-agent 1.0.3 → 1.0.5

package/bin/devassist.js

@@ -166,12 +166,13 @@ function printHelp() {
   printHeader('开发守护 CLI');
   console.log(`${c.bold('用法：')} devassist <命令> [选项]\n`);
   console.log(`${c.bold('命令：')}`);
-  console.log(`  ${c.green('start')}                 一键启动：自动初始化 + AI多引擎实时监控`);
+  console.log(`  ${c.green('start')}                 一键启动：自动初始化 + AI双引擎实时监控 + 自动修复`);
   console.log(`  ${c.green('init')}                  初始化项目——创建 .devassist/ 配置与基础代码`);
   console.log(`  ${c.green('check')}                 运行全部开发时检查（代码质量 + 约定 + 模式 + 架构）`);
   console.log(`  ${c.green('watch')}                 实时监控文件变更并运行检查`);
   console.log(`  ${c.green('diff')} ${c.gray('--staged|--base <分支>')}  仅检查变更文件（CI 模式）`);
   console.log(`  ${c.green('report')} ${c.gray('[--open]')}          生成 HTML 检查报告`);
+  console.log(`  ${c.gray('         --watch-history [n]')}   查看最近 n 条监控复盘报告（默认 20）`);
   console.log(`  ${c.green('deploy')} ${c.gray('--check')}           部署前验证（端口 + 路由 + MIME + 清单）`);
   console.log(`  ${c.green('debt')} ${c.gray('--scan')}              查看技术债务看板（按优先级排序）`);
   console.log(`  ${c.green('convention')} ${c.gray('add|list|remove')}  管理项目约定`);
@@ -189,18 +190,19 @@ function printHelp() {
   console.log(`  ${c.gray('--ai')}                启用 AI 深度分析（需配置）`);
   console.log(`  ${c.gray('--compare')}           多引擎对比分析（所有引擎并行）`);
   console.log(`  ${c.gray('--json')}              输出 JSON 格式（用于 CI 集成）`);
+  console.log(`  ${c.gray('--fix')}               自动修复安全项（watch 模式下生效）`);
   console.log(`  ${c.gray('--fail-on <级别>')}    在以下级别非零退出：block（默认）或 warn`);
   console.log(`  ${c.gray('--base-code')}         安装运行时基础设施（Layer 2）`);
   console.log(`  ${c.gray('--force')}             覆盖已有配置`);
   console.log(`  ${c.gray('-v, --version')}       显示版本`);
   console.log(`  ${c.gray('-h, --help')}          显示帮助\n`);
   console.log(`${c.bold('示例：')}`);
-  console.log(`  ${c.gray('$')} devassist start                # 一键启动（自动init+AI多引擎监控）`);
+  console.log(`  ${c.gray('$')} devassist start                # 一键启动（自动init+AI双引擎+自动修复）`);
   console.log(`  ${c.gray('$')} devassist start --check        # 一键检查（不启动监控）`);
   console.log(`  ${c.gray('$')} devassist init`);
   console.log(`  ${c.gray('$')} devassist check --ai`);
   console.log(`  ${c.gray('$')} devassist watch              # 开发时实时监控`);
-  console.log(`  ${c.gray('$')} devassist watch --ai --compare # 实时监控+AI多引擎对比`);
+  console.log(`  ${c.gray('$')} devassist watch --ai --compare --fix  # 全自动：检测+AI+修复`);
   console.log(`  ${c.gray('$')} devassist diff --staged       # 提交前检查暂存文件`);
   console.log(`  ${c.gray('$')} devassist report --open       # 生成并查看 HTML 报告`);
   console.log(`  ${c.gray('$')} devassist convention add --id naming-list --rule "使用 data.list 而非 data.items" --severity block`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "devassist-agent",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "AI Agent 开发质量守护工具 — 30+规则检测代码缺陷/安全漏洞/性能反模式，多引擎AI根因分析，零外部依赖",
   "main": "src/index.js",
   "bin": {

package/src/cli/commands/report.js

@@ -12,6 +12,7 @@
  *   devassist report              # Generate report
  *   devassist report --ai         # Include AI analysis
  *   devassist report --open       # Open in browser after generating
+ *   devassist report --watch-history [n]  # Show recent watch reports (default 20)
  */
 
 const fs = require('fs');
@@ -38,6 +39,11 @@ module.exports = async function report(projectRoot, args, ui) {
   const useAI = args.includes('--ai');
   const openBrowser = args.includes('--open');
 
+  // Watch history mode
+  if (args.includes('--watch-history')) {
+    return showWatchHistory(projectRoot, args, ui);
+  }
+
   printHeader('生成报告');
 
   // Collect files using shared utility
@@ -308,3 +314,101 @@ function findingHTML(f) {
 function escapeHTML(str) {
   return String(str).replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;');
 }
+
+/**
+ * Show watch history for retrospective.
+ * Usage: devassist report --watch-history [n]
+ */
+function showWatchHistory(projectRoot, args, ui) {
+  const { printHeader, c } = ui;
+  printHeader('监控复盘报告');
+
+  const historyDir = path.join(projectRoot, '.devassist', 'history', 'watch');
+  const logPath = path.join(historyDir, 'watch-log.jsonl');
+
+  if (!fs.existsSync(logPath)) {
+    console.log(`  ${c.yellow('暂无监控历史记录。')}`);
+    console.log(`  ${c.gray('运行 devassist start 后，文件变更的检查/分析/修复记录会自动保存到这里。')}\n`);
+    return;
+  }
+
+  // Parse limit from args
+  let limit = 20;
+  const idx = args.indexOf('--watch-history');
+  if (idx >= 0 && args[idx + 1] && /^\d+$/.test(args[idx + 1])) {
+    limit = parseInt(args[idx + 1]);
+  }
+
+  // Read JSONL log
+  const lines = fs.readFileSync(logPath, 'utf-8').trim().split('\n').filter(Boolean);
+  const entries = lines.map(l => { try { return JSON.parse(l); } catch (_) { return null; } }).filter(Boolean);
+
+  if (entries.length === 0) {
+    console.log(`  ${c.yellow('暂无监控历史记录。')}\n`);
+    return;
+  }
+
+  // Show recent entries (newest first)
+  const recent = entries.slice(-limit).reverse();
+  console.log(`  ${c.gray(`共 ${entries.length} 条记录，显示最近 ${recent.length} 条：`)}\n`);
+
+  // Summary stats
+  const totalEvents = entries.length;
+  const totalFindings = entries.reduce((s, e) => s + (e.total || 0), 0);
+  const totalBlocks = entries.reduce((s, e) => s + (e.blocks || 0), 0);
+  const totalFixed = entries.reduce((s, e) => s + (e.fixed || 0), 0);
+  const aiEvents = entries.filter(e => e.aiUsed).length;
+
+  console.log(`  ${c.bold('汇总统计：')}`);
+  console.log(`    监控事件：${totalEvents} 次`);
+  console.log(`    发现问题：${totalFindings} 个（其中 ${c.red(totalBlocks + ' 阻断')}）`);
+  console.log(`    自动修复：${c.green(totalFixed + ' 处')}`);
+  console.log(`    AI 分析：${aiEvents} 次\n`);
+
+  // Detail table
+  console.log(`  ${c.bold('最近事件：')}\n`);
+  console.log(`  ${c.gray('时间'.padEnd(20))} ${c.gray('文件'.padEnd(30))} ${c.gray('问题'.padEnd(8))} ${c.gray('修复'.padEnd(6))} ${c.gray('引擎')}`);
+  console.log(`  ${'─'.repeat(90)}`);
+
+  for (const e of recent) {
+    const time = new Date(e.timestamp).toLocaleString('zh-CN', { month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit' });
+    const file = (e.file || '').length > 28 ? '...' + (e.file || '').slice(-25) : (e.file || '');
+    const issues = e.total > 0 ? c.yellow(String(e.total)) : c.green('0');
+    const blocks = e.blocks > 0 ? c.red(`(${e.blocks}阻断)`) : '';
+    const fixed = e.fixed > 0 ? c.green(String(e.fixed)) : '-';
+    const engines = e.engines || '-';
+
+    console.log(`  ${time.padEnd(20)} ${file.padEnd(30)} ${issues} ${blocks}`.padEnd(58) + ` ${fixed.toString().padEnd(6)} ${engines}`);
+  }
+
+  // Latest report detail
+  const latestPath = path.join(projectRoot, '.devassist', 'reports', 'latest.json');
+  if (fs.existsSync(latestPath)) {
+    console.log(`\n  ${c.gray('最近一次完整报告：')} ${latestPath}`);
+    console.log(`  ${c.gray('历史报告目录：')} ${historyDir}`);
+  }
+
+  // Watch files with most issues
+  const fileStats = {};
+  for (const e of entries) {
+    if (!fileStats[e.file]) fileStats[e.file] = { count: 0, issues: 0, blocks: 0, fixed: 0 };
+    fileStats[e.file].count++;
+    fileStats[e.file].issues += e.total || 0;
+    fileStats[e.file].blocks += e.blocks || 0;
+    fileStats[e.file].fixed += e.fixed || 0;
+  }
+
+  const hotFiles = Object.entries(fileStats)
+    .sort((a, b) => b[1].issues - a[1].issues)
+    .filter(([, s]) => s.issues > 0)
+    .slice(0, 5);
+
+  if (hotFiles.length > 0) {
+    console.log(`\n  ${c.bold('问题热点文件 TOP 5：')}\n`);
+    for (const [file, s] of hotFiles) {
+      console.log(`    ${file} — ${s.issues} 个问题，${s.blocks} 阻断，${s.fixed} 已修复（${s.count} 次变更）`);
+    }
+  }
+
+  console.log('');
+}

package/src/cli/commands/start.js

@@ -7,8 +7,9 @@
  *   3. Start watch mode with --ai --compare
  *
  * Usage:
- *   devassist start              # Full auto: init + watch --ai --compare
+ *   devassist start              # Full auto: init + watch --ai --compare --fix
  *   devassist start --no-ai      # Init + watch (rules only, no AI)
+ *   devassist start --no-fix     # Init + watch --ai --compare (no auto-fix)
  *   devassist start --check      # Init + one-time check --ai --compare (no watch)
  */
 
@@ -20,6 +21,7 @@ module.exports = async function start(projectRoot, args, ui) {
   const { printHeader, printFinding, printStats, c } = ui;
 
   const noAI = args.includes('--no-ai');
+  const noFix = args.includes('--no-fix');
   const checkOnly = args.includes('--check');
 
   printHeader('一键启动');
@@ -51,6 +53,9 @@ module.exports = async function start(projectRoot, args, ui) {
   if (aiReady && !noAI) {
     const engineNames = readyEngines.map(e => e.name || e.provider).join(' + ');
     console.log(`  ${c.green('2/3')} AI 引擎已就绪 ✓ (${configSource}：${engineNames})`);
+    if (!noFix) {
+      console.log(`         ${c.gray('自动修复已启用（--fix）')}`);
+    }
   } else if (readyEngines.length === 1 && !noAI) {
     console.log(`  ${c.green('2/3')} AI 引擎已就绪 ✓ (${configSource}：${readyEngines[0].name}，仅单引擎)`);
     console.log(`         ${c.gray('提示：配置第二个引擎可启用对比模式')}`);
@@ -79,6 +84,9 @@ module.exports = async function start(projectRoot, args, ui) {
     if (!noAI) {
       watchArgs.push('--ai', '--compare');
     }
+    if (!noFix) {
+      watchArgs.push('--fix');
+    }
     await watchCmd(projectRoot, watchArgs, ui);
   }
 };

package/src/cli/commands/watch.js

@@ -1,18 +1,20 @@
 /**
- * devassist watch - Real-time file monitoring
+ * devassist watch - Real-time file monitoring with full automation
  *
  * Watches project files for changes and runs checks on modified files.
- * Provides instant feedback during AI-assisted development.
+ * With --ai flag, automatically runs AI analysis on findings.
+ * With --compare flag, runs multi-engine comparison.
+ * With --fix flag, automatically applies safe fixes.
  *
  * Usage:
- *   devassist watch              # Watch all source files
- *   devassist watch --ai         # Watch + AI analysis on findings
- *   devassist watch --dir src    # Watch specific directory
+ *   devassist watch                    # Watch all source files (rules only)
+ *   devassist watch --ai               # Watch + AI analysis on findings
+ *   devassist watch --ai --compare     # Watch + multi-engine comparison
+ *   devassist watch --ai --compare --fix  # Full auto: detect + AI + fix
  */
 
 const fs = require('fs');
 const path = require('path');
-const { execSync } = require('child_process');
 
 // Core
 const { engine, RuleEngine } = require('../../core/rule-engine');
@@ -25,14 +27,29 @@ const { ArchRiskAssessor } = require('../../modules/dev-time/arch-risk-assessor'
 // Shared utilities
 const { loadConfig } = require('../shared/config-loader');
 const { filterIgnored } = require('../shared/inline-ignore');
+const { enrichWithContext } = require('../shared/code-context');
+
+// AI
+const ai = require('../../ai/adapter');
+const qwen = require('../../ai/providers/qwen');
+const openai = require('../../ai/providers/openai');
+const claude = require('../../ai/providers/claude');
+const hunyuan = require('../../ai/providers/hunyuan');
+
+// Register AI providers
+ai.registerProvider('qwen', qwen);
+ai.registerProvider('openai', openai);
+ai.registerProvider('claude', claude);
+ai.registerProvider('hunyuan', hunyuan);
 
 const CODE_EXTENSIONS = /\.(js|ts|jsx|tsx|py|java)$/;
 const SKIP_DIRS = ['node_modules', '.git', '.devassist', 'dist', 'build', 'vendor', '.gradle', '__pycache__'];
 
 module.exports = async function watch(projectRoot, args, ui) {
-  const { printHeader, printFinding, c } = ui;
+  const { printHeader, printFinding, printStats, c } = ui;
   const useAI = args.includes('--ai');
   const useCompare = args.includes('--compare');
+  const autoFix = args.includes('--fix');
   const watchDir = args.includes('--dir') ? args[args.indexOf('--dir') + 1] : null;
 
   printHeader('监控模式');
@@ -40,6 +57,7 @@ module.exports = async function watch(projectRoot, args, ui) {
   console.log(`  ${c.gray('监控目录：')} ${watchDir || '整个项目'}`);
   console.log(`  ${c.gray('AI 分析：')} ${useAI ? '已启用' : '已禁用'}`);
   console.log(`  ${c.gray('多引擎对比：')} ${useCompare ? '已启用' : '已禁用'}`);
+  console.log(`  ${c.gray('自动修复：')} ${autoFix ? '已启用' : '已禁用'}`);
   console.log(`  ${c.gray('按 Ctrl+C 停止')}\n`);
 
   // Initialize convention store
@@ -62,9 +80,28 @@ module.exports = async function watch(projectRoot, args, ui) {
     }
   });
 
+  // Load AI config (global or project-level)
+  let aiConfig = null;
+  let readyEngines = [];
+  if (useAI) {
+    const { loadAIConfig } = require('./ai');
+    aiConfig = loadAIConfig(projectRoot);
+    if (aiConfig && aiConfig.engines) {
+      readyEngines = aiConfig.engines.filter(e => e.enabled && e.apiKey);
+    }
+    if (readyEngines.length === 0) {
+      console.log(`  ${c.yellow('警告：')} 未检测到可用的 AI 引擎，将仅使用规则引擎\n`);
+    } else if (useCompare && readyEngines.length < 2) {
+      console.log(`  ${c.yellow('提示：')} 对比模式需要 2+ 引擎，当前仅 ${readyEngines.length} 个，将使用单引擎\n`);
+    } else {
+      console.log(`  ${c.green('AI 引擎就绪：')} ${readyEngines.map(e => e.name || e.provider).join(' + ')}\n`);
+    }
+  }
+
   // Track watchers for cleanup
   const watchers = [];
   const debounceTimers = new Map();
+  const analyzingFiles = new Set(); // Lock: prevent overlapping AI analysis on same file
 
   // Watch a single file
   function watchFile(filePath) {
@@ -72,14 +109,17 @@ module.exports = async function watch(projectRoot, args, ui) {
       const watcher = fs.watch(filePath, { persistent: true }, (eventType) => {
         if (eventType !== 'change') return;
 
-        // Debounce: wait 300ms after last change before checking
+        // Debounce: wait 500ms after last change before checking (longer with AI)
+        const debounceMs = useAI ? 500 : 300;
         if (debounceTimers.has(filePath)) {
           clearTimeout(debounceTimers.get(filePath));
         }
         debounceTimers.set(filePath, setTimeout(() => {
           debounceTimers.delete(filePath);
-          checkFile(filePath);
-        }, 300));
+          checkFile(filePath).catch(err => {
+            console.log(`  ${c.red('检查出错：')} ${err.message}`);
+          });
+        }, debounceMs));
       });
       watcher.on('error', () => {});
       watchers.push(watcher);
@@ -102,61 +142,165 @@ module.exports = async function watch(projectRoot, args, ui) {
     }
   }
 
-  // Check a single file
-  function checkFile(filePath) {
-    const relPath = path.relative(projectRoot, filePath);
-    const timestamp = new Date().toLocaleTimeString();
+  // Check a single file — async for AI analysis
+  async function checkFile(filePath) {
+    // Skip if already analyzing this file (AI takes time)
+    if (analyzingFiles.has(filePath)) return;
+    analyzingFiles.add(filePath);
 
-    let content = '';
-    try { content = fs.readFileSync(filePath, 'utf-8'); } catch (_) { return; }
+    try {
+      const relPath = path.relative(projectRoot, filePath);
+      const timestamp = new Date().toLocaleTimeString();
 
-    // Quick skip for HTML without script tags
-    if (/\.html?$/.test(filePath) && !/<script[\s>]/i.test(content)) return;
+      let content = '';
+      try { content = fs.readFileSync(filePath, 'utf-8'); } catch (_) { return; }
 
-    const ctx = {
-      files: [{ path: relPath, content, fullPath: filePath }],
-      projectRoot,
-      config: loadConfig(projectRoot),
-    };
+      // Quick skip for HTML without script tags
+      if (/\.html?$/.test(filePath) && !/<script[\s>]/i.test(content)) return;
 
-    const { findings: ruleFindings } = engine.run(ctx);
-    const archFindings = archAssessor.analyzeFile(relPath, content);
-    let allFindings = [...ruleFindings, ...archFindings];
+      const ctx = {
+        files: [{ path: relPath, content, fullPath: filePath }],
+        projectRoot,
+        config: loadConfig(projectRoot),
+      };
 
-    // Apply inline ignores
-    allFindings = filterIgnored(allFindings, [{ path: relPath, content }]);
+      const { findings: ruleFindings } = engine.run(ctx);
+      const archFindings = archAssessor.analyzeFile(relPath, content);
+      let allFindings = [...ruleFindings, ...archFindings];
 
-    // Save findings for ai --analyze
-    saveWatchFindings(projectRoot, allFindings);
+      // Apply inline ignores
+      allFindings = filterIgnored(allFindings, [{ path: relPath, content }]);
 
-    // Print header
-    console.log(`\n  ${c.gray(`[${timestamp}]`)} ${c.bold(relPath)}`);
+      // Print header
+      console.log(`\n  ${c.gray(`[${timestamp}]`)} ${c.bold(relPath)}`);
 
-    if (allFindings.length === 0) {
-      console.log(`  ${c.green('OK')} — 未发现问题`);
-      return;
-    }
+      if (allFindings.length === 0) {
+        console.log(`  ${c.green('OK')} — 未发现问题`);
+        return;
+      }
 
-    // Print findings
-    const blocks = allFindings.filter(f => f.severity === 'block');
-    const warns = allFindings.filter(f => f.severity === 'warn');
-    const infos = allFindings.filter(f => f.severity === 'info');
-
-    for (const f of allFindings) {
-      const icon = f.severity === 'block' ? c.red('[阻断]') :
-                   f.severity === 'warn' ? c.yellow('[警告]') :
-                   c.gray('[提示]');
-      console.log(`  ${icon} ${f.message}`);
-      if (f.line) console.log(`         ${c.gray(`第 ${f.line} 行`)}`);
-      if (f.suggestion) console.log(`         ${c.gray(f.suggestion)}`);
-    }
+      // --- AI Analysis (if enabled and there are warn/block findings) ---
+      let finalFindings = allFindings;
+      const suspectFindings = allFindings.filter(f => f.severity === 'block' || f.severity === 'warn');
+
+      if (useAI && readyEngines.length > 0 && suspectFindings.length > 0) {
+        console.log(`  ${c.cyan('AI 分析中...')} (${suspectFindings.length} 个疑似问题)`);
+
+        // Enrich with code context
+        const fileContents = [{ path: relPath, content }];
+        finalFindings = enrichWithContext(allFindings, fileContents);
+
+        const aiContext = {
+          conventions: conventionStore.getRelevant({}),
+          projectInfo: { root: projectRoot },
+        };
+
+        try {
+          if (useCompare && readyEngines.length >= 2) {
+            finalFindings = await ai.multiAnalyze(readyEngines, finalFindings, aiContext);
+          } else {
+            finalFindings = await ai.analyze(readyEngines[0], finalFindings, aiContext);
+          }
+        } catch (err) {
+          console.log(`  ${c.yellow('AI 分析失败：')} ${err.message}`);
+          console.log(`  ${c.gray('已回退到规则引擎结果')}`);
+        }
+      }
 
-    // Summary
-    const parts = [];
-    if (blocks.length > 0) parts.push(c.red(`${blocks.length} 阻断`));
-    if (warns.length > 0) parts.push(c.yellow(`${warns.length} 警告`));
-    if (infos.length > 0) parts.push(c.gray(`${infos.length} 提示`));
-    console.log(`  ${c.gray('—')} ${parts.join(c.gray(' · '))}`);
+      // --- Print findings ---
+      const blocks = finalFindings.filter(f => f.severity === 'block');
+      const warns = finalFindings.filter(f => f.severity === 'warn');
+      const infos = finalFindings.filter(f => f.severity === 'info');
+
+      for (const f of finalFindings) {
+        const icon = f.severity === 'block' ? c.red('[阻断]') :
+                     f.severity === 'warn' ? c.yellow('[警告]') :
+                     c.gray('[提示]');
+        console.log(`  ${icon} ${f.message}`);
+        if (f.line) console.log(`         ${c.gray(`第 ${f.line} 行`)}`);
+        if (f.suggestion) console.log(`         ${c.gray(f.suggestion)}`);
+
+        // Print AI analysis if available
+        if (f.aiAnalysis) {
+          const a = f.aiAnalysis;
+          if (a.falsePositive) {
+            console.log(`         ${c.gray('AI 判定：误报 — ' + (a.falsePositiveReason || '不适用'))}`);
+          } else {
+            const rootCause = a.rootCause || a.root_cause || '';
+            const fixSuggestion = a.fixSuggestion || a.fix_suggestion || '';
+            const confidence = a.confidence || '';
+            if (rootCause) console.log(`         ${c.cyan('AI 根因：')} ${rootCause}`);
+            if (fixSuggestion) console.log(`         ${c.cyan('AI 建议：')} ${fixSuggestion}`);
+            if (confidence) console.log(`         ${c.gray(`置信度：${confidence}`)}`);
+          }
+        }
+
+        // Print multi-engine comparison
+        if (f.aiAnalyses && f.aiAnalyses.length >= 2) {
+          for (const ea of f.aiAnalyses) {
+            if (ea.analysis && !ea.failed) {
+              const engineName = ea.engineName || ea.provider;
+              const a = ea.analysis;
+              if (a.falsePositive) {
+                console.log(`         ${c.gray(`[${engineName}] 误报 — ${a.falsePositiveReason || ''}`)}`);
+              } else {
+                const rootCause = a.rootCause || a.root_cause || '';
+                if (rootCause) console.log(`         ${c.cyan(`[${engineName}]`)} ${rootCause}`);
+              }
+            } else if (ea.failed) {
+              console.log(`         ${c.gray(`[${ea.engineName || ea.provider}] 分析失败`)}`);
+            }
+          }
+          // Agreement indicator
+          if (f.aiAnalyses.filter(ea => ea.analysis && !ea.failed && !ea.analysis.falsePositive).length === 0
+              && f.aiAnalyses.filter(ea => ea.analysis && !ea.failed && ea.analysis.falsePositive).length >= 2) {
+            console.log(`         ${c.green('引擎一致：均判定为误报')}`);
+          }
+        }
+      }
+
+      // --- Summary ---
+      const parts = [];
+      if (blocks.length > 0) parts.push(c.red(`${blocks.length} 阻断`));
+      if (warns.length > 0) parts.push(c.yellow(`${warns.length} 警告`));
+      if (infos.length > 0) parts.push(c.gray(`${infos.length} 提示`));
+      console.log(`  ${c.gray('—')} ${parts.join(c.gray(' · '))}`);
+
+      // --- Auto Fix (if enabled) ---
+      let fixResult = null;
+      if (autoFix && suspectFindings.length > 0) {
+        fixResult = await autoFixFile(filePath, content, projectRoot, c);
+        if (fixResult.count > 0) {
+          console.log(`  ${c.green('自动修复')} ${fixResult.count} 处问题`);
+          for (const d of fixResult.details) {
+            const typeLabel = d.type === 'fetch-catch' ? 'fetch 添加 .catch()' : '添加 await';
+            console.log(`         ${c.gray(`第${d.line}行`)} ${typeLabel}`);
+          }
+        }
+      }
+
+      // --- Save comprehensive report for retrospective ---
+      saveWatchReport(projectRoot, {
+        timestamp: new Date().toISOString(),
+        file: relPath,
+        findings: finalFindings,
+        aiAnalysisUsed: useAI && readyEngines.length > 0 && suspectFindings.length > 0,
+        compareMode: useCompare && readyEngines.length >= 2,
+        engines: readyEngines.map(e => ({ provider: e.provider, model: e.model, name: e.name })),
+        fixes: fixResult ? fixResult.details : [],
+        fixBackupPath: fixResult ? fixResult.backupPath : null,
+        stats: {
+          total: finalFindings.length,
+          blocks: blocks.length,
+          warnings: warns.length,
+          infos: infos.length,
+          fixed: fixResult ? fixResult.count : 0,
+        },
+      });
+
+    } finally {
+      analyzingFiles.delete(filePath);
+    }
   }
 
   // Start watching
@@ -199,19 +343,129 @@ module.exports = async function watch(projectRoot, args, ui) {
   });
 };
 
-function saveWatchFindings(projectRoot, findings) {
+/**
+ * Auto-fix a single file in-place (safe fixes only).
+ * Returns the number of fixes applied.
+ */
+async function autoFixFile(filePath, content, projectRoot, c) {
+  const lines = content.split('\n');
+  let fixCount = 0;
+  const changes = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (/^\s*(\/\/|\/\*|\*)/.test(line)) continue;
+
+    // Fix 1: fetch() without .catch()
+    if (/\bfetch\s*\(/.test(line)) {
+      const context = lines.slice(i, Math.min(i + 5, lines.length)).join('\n');
+      if (/\.catch\s*\(/.test(context)) continue;
+      const hasAwait = /\bawait\b/.test(line);
+      const hasTryCatch = /try\s*\{/.test(lines.slice(Math.max(0, i - 5), i + 1).join('\n'));
+      if (hasAwait && hasTryCatch) continue;
+
+      const trimmed = line.trimEnd();
+      if (trimmed.endsWith(')') && !trimmed.endsWith('.catch()')) {
+        const fixedLine = trimmed.replace(/\)\s*$/, ").catch(err => console.error('fetch error:', err))");
+        changes.push({ line: i + 1, type: 'fetch-catch', before: line, after: fixedLine });
+        fixCount++;
+        continue;
+      }
+    }
+
+    // Fix 2: Add await to async calls (fetch, axios, etc.)
+    if (!/\bawait\b/.test(line)) {
+      const asyncMatch = line.match(/(?<![\w.])(fetch|axios\.(get|post|put|delete|patch)|\.save\(|\.findOne\(|\.findById\(|\.create\()\s*/);
+      if (asyncMatch) {
+        const trimmed = line.trim();
+        if (/^\s*(const|let|var|if|while|return|throw)/.test(trimmed)) continue;
+        if (/^\s*(async\s+)?function\s+/.test(line)) continue;
+        if (/\.then\s*\(|\.catch\s*\(|\.finally\s*\(/.test(line)) continue;
+
+        const fixedLine = line.replace(
+          new RegExp('(?<![\\w.])(' + asyncMatch[1] + '\\w+)\\s*\\('),
+          'await $1('
+        );
+        if (fixedLine !== line) {
+          changes.push({ line: i + 1, type: 'add-await', before: line, after: fixedLine });
+          fixCount++;
+          continue;
+        }
+      }
+    }
+  }
+
+  if (fixCount === 0) return { count: 0, details: [] };
+
+  // Apply changes
+  for (const ch of changes) {
+    lines[ch.line - 1] = ch.after;
+  }
+  const newContent = lines.join('\n');
+
+  // Backup original
+  const backupDir = path.join(projectRoot, '.devassist', 'backups', `watch-fix-${Date.now()}`);
+  if (!fs.existsSync(backupDir)) fs.mkdirSync(backupDir, { recursive: true });
+  const backupPath = path.join(backupDir, path.basename(filePath));
+  fs.writeFileSync(backupPath, content, 'utf-8');
+
+  // Write fixed content
+  fs.writeFileSync(filePath, newContent, 'utf-8');
+
+  return { count: fixCount, details: changes, backupPath };
+}
+
+/**
+ * Save comprehensive watch report for retrospective.
+ * - latest.json: always overwritten with the latest event
+ * - history/watch-<timestamp>.json: per-event detail, kept for 90 days
+ * - history/watch-log.jsonl: append-only summary log for quick querying
+ */
+function saveWatchReport(projectRoot, report) {
   const reportDir = path.join(projectRoot, '.devassist', 'reports');
   if (!fs.existsSync(reportDir)) fs.mkdirSync(reportDir, { recursive: true });
-  const reportPath = path.join(reportDir, 'latest.json');
-  fs.writeFileSync(reportPath, JSON.stringify({
-    generatedAt: new Date().toISOString(),
-    source: 'watch',
-    findings,
-    stats: {
-      total: findings.length,
-      blocks: findings.filter(f => f.severity === 'block').length,
-      warnings: findings.filter(f => f.severity === 'warn').length,
-      infos: findings.filter(f => f.severity === 'info').length,
-    },
-  }, null, 2), 'utf-8');
+
+  // 1. Save latest.json (full detail, always latest)
+  const latestPath = path.join(reportDir, 'latest.json');
+  fs.writeFileSync(latestPath, JSON.stringify(report, null, 2), 'utf-8');
+
+  // 2. Save timestamped history
+  const historyDir = path.join(projectRoot, '.devassist', 'history', 'watch');
+  if (!fs.existsSync(historyDir)) fs.mkdirSync(historyDir, { recursive: true });
+
+  const ts = new Date();
+  const tsStr = ts.toISOString().replace(/[:.]/g, '-');
+  const historyPath = path.join(historyDir, `watch-${tsStr}.json`);
+  fs.writeFileSync(historyPath, JSON.stringify(report, null, 2), 'utf-8');
+
+  // 3. Append summary to JSONL log
+  const logPath = path.join(historyDir, 'watch-log.jsonl');
+  const summary = {
+    timestamp: report.timestamp,
+    file: report.file,
+    total: report.stats.total,
+    blocks: report.stats.blocks,
+    warnings: report.stats.warnings,
+    infos: report.stats.infos,
+    fixed: report.stats.fixed,
+    aiUsed: report.aiAnalysisUsed,
+    compare: report.compareMode,
+    engines: report.engines.map(e => e.provider).join('+'),
+  };
+  fs.appendFileSync(logPath, JSON.stringify(summary) + '\n', 'utf-8');
+
+  // 4. Auto-cleanup: remove history files older than 90 days
+  try {
+    const files = fs.readdirSync(historyDir);
+    const now = Date.now();
+    const maxAge = 90 * 24 * 60 * 60 * 1000; // 90 days in ms
+    for (const f of files) {
+      if (!f.startsWith('watch-') || !f.endsWith('.json')) continue;
+      const filePath = path.join(historyDir, f);
+      const stat = fs.statSync(filePath);
+      if (now - stat.mtime.getTime() > maxAge) {
+        fs.unlinkSync(filePath);
+      }
+    }
+  } catch (_) {}
 }