autosnippet 3.0.0 → 3.0.2

package/lib/service/chat/ChatAgent.js

@@ -26,12 +26,11 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import Logger from '../../infrastructure/logging/Logger.js';
-import { TaskPipeline } from './TaskPipeline.js';
-import { Memory } from './Memory.js';
+import { ContextWindow, limitToolResult, PhaseRouter } from './ContextWindow.js';
 import { ConversationStore } from './ConversationStore.js';
-import { ContextWindow, PhaseRouter, limitToolResult } from './ContextWindow.js';
+import { Memory } from './Memory.js';
 import { ReasoningLayer } from './ReasoningLayer.js';
-import { WorkingMemory } from './WorkingMemory.js';
+import { TaskPipeline } from './TaskPipeline.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PROJECT_ROOT = path.resolve(__dirname, '../../..');
@@ -41,7 +40,7 @@ const MAX_ITERATIONS = 6;
 /** 系统调用 (如 bootstrap) 允许更多迭代,因为每维度需要多次 submit_knowledge */
 const MAX_ITERATIONS_SYSTEM = 30;
 /** 原生函数调用模式下，已提交 ≥ MIN_SUBMITS_FOR_EARLY_EXIT 个候选后，连续 N 轮无新提交则提前退出 */
-const MIN_SUBMITS_FOR_EARLY_EXIT = 1;
+const _MIN_SUBMITS_FOR_EARLY_EXIT = 1;
 const IDLE_ROUNDS_TO_EXIT = 2;
 /** 单个维度最多提交候选数量 — 超过后跳过提交返回提醒 */
 const MAX_SUBMITS_PER_DIMENSION = 6;
@@ -77,10 +76,16 @@ export class ChatAgent {
   #conversations = null;
   /** @type {string|null} 当前 execute 调用的 source — 'user' | 'system' */
   #currentSource = null;
+  /** @type {string|null} 当前 execute 调用的 UI 语言偏好 — 'zh' | 'en' | null */
+  #currentLang = null;
+  /** @type {string|null} 默认 UI 语言偏好（通过 setLang 设置，bootstrap 等非对话场景使用） */
+  #defaultLang = null;
   /** @type {Array|null} 内存文件缓存（bootstrap 场景注入，search_project_code/read_project_file 优先使用） */
   #fileCache = null;
   /** @type {Set<string>} 跨维度已提交候选标题（bootstrap 全局去重） */
   #globalSubmittedTitles = new Set();
+  /** @type {Set<string>} 跨维度已提交代码模式指纹（bootstrap 全局去重） */
+  #globalSubmittedPatterns = new Set();
   /** @type {{ input: number, output: number }} 当前 execute() 累计 token 用量 */
   #currentTokenUsage = { input: 0, output: 0 };
   /** @type {import('./ProjectSemanticMemory.js').ProjectSemanticMemory|null} Tier 3 语义记忆 */
@@ -115,13 +120,23 @@ export class ChatAgent {
       const projectRoot = container?.singletons?._projectRoot || process.cwd();
       this.#memory = new Memory(projectRoot);
       this.#conversations = new ConversationStore(projectRoot);
-    } catch { /* Memory/ConversationStore init failed, degrade silently */ }
+    } catch {
+      /* Memory/ConversationStore init failed, degrade silently */
+    }
 
     // v4.1: 尝试初始化 ProjectSemanticMemory (Tier 3)
     this.#initSemanticMemory(container);
 
     // 注册内置 DAG 管线
     this.#registerBuiltinPipelines();
+
+    // 从系统环境变量检测默认语言
+    const sysLang = (process.env.LANG || '').split('.')[0];
+    if (sysLang.startsWith('en')) {
+      this.#defaultLang = 'en';
+    } else if (sysLang.startsWith('zh')) {
+      this.#defaultLang = 'zh';
+    }
   }
 
   // ─── 公共 API ─────────────────────────────────────────
@@ -148,6 +163,24 @@ export class ChatAgent {
    */
   resetGlobalSubmittedTitles() {
     this.#globalSubmittedTitles.clear();
+    this.#globalSubmittedPatterns.clear();
+  }
+
+  /**
+   * 获取当前默认 UI 语言偏好
+   * @returns {'zh'|'en'|null}
+   */
+  getLang() {
+    return this.#defaultLang;
+  }
+
+  /**
+   * 设置默认 UI 语言偏好（影响 Agent 回复语言）
+   * 由前端通过 bootstrap/chat 等 API 设置，后续所有 AI 调用自动继承。
+   * @param {'zh'|'en'|null} lang
+   */
+  setLang(lang) {
+    this.#defaultLang = lang || null;
   }
 
   /**
@@ -163,25 +196,38 @@ export class ChatAgent {
    * @param {string} [opts.projectLanguage] — 项目主语言 (e.g. 'swift', 'objectivec')，注入到 submit tool ctx
    * @returns {Promise<{reply: string, toolCalls: Array, hasContext: boolean, conversationId?: string}>}
    */
-  async execute(prompt, { history = [], conversationId, source = 'user', budget: budgetOverrides, dimensionId, dimensionMeta,
-    // v3.0: Agent 分离选项
-    systemPromptOverride,       // 覆盖默认 system prompt (Analyst/Producer 各自使用)
-    allowedTools,               // 覆盖默认工具白名单 (string[])
-    disablePhaseRouter = false, // 禁用 PhaseRouter (Analyst 不需要阶段控制)
-    temperature: temperatureOverride, // 覆盖默认温度
-    projectLanguage,            // 项目主语言，注入到 submit tool 的 ctx._projectLanguage
-    // v4.0: Agent Memory 集成
-    workingMemory,              // WorkingMemory 实例 (由 orchestrator 注入)
-    episodicMemory,             // EpisodicMemory 实例 (跨维度情景记忆)
-    toolResultCache,            // ToolResultCache 实例 (跨维度工具结果缓存)
-    // v5.1: SSE 流式进度回调
-    onProgress,                 // (event: {type, ...}) => void — 实时推送思考/工具/回答事件
-  } = {}) {
+  async execute(
+    prompt,
+    {
+      history = [],
+      conversationId,
+      source = 'user',
+      budget: budgetOverrides,
+      dimensionId,
+      dimensionMeta,
+      // v3.0: Agent 分离选项
+      systemPromptOverride, // 覆盖默认 system prompt (Analyst/Producer 各自使用)
+      allowedTools, // 覆盖默认工具白名单 (string[])
+      disablePhaseRouter = false, // 禁用 PhaseRouter (Analyst 不需要阶段控制)
+      temperature: temperatureOverride, // 覆盖默认温度
+      projectLanguage, // 项目主语言，注入到 submit tool 的 ctx._projectLanguage
+      lang, // UI 语言偏好 ('zh'|'en')，控制回复语言
+      // v4.0: Agent Memory 集成
+      workingMemory, // WorkingMemory 实例 (由 orchestrator 注入)
+      episodicMemory, // EpisodicMemory 实例 (跨维度情景记忆)
+      toolResultCache, // ToolResultCache 实例 (跨维度工具结果缓存)
+      // v5.1: SSE 流式进度回调
+      onProgress, // (event: {type, ...}) => void — 实时推送思考/工具/回答事件
+    } = {}
+  ) {
     this.#currentSource = source;
+    this.#currentLang = lang || this.#defaultLang || null;
     this.#currentTokenUsage = { input: 0, output: 0 };
     const execStartTime = Date.now();
-    const promptPreview = prompt.length > 80 ? prompt.substring(0, 80) + '…' : prompt;
-    this.#logger.info(`[ChatAgent] ▶ execute — source=${source}${dimensionMeta?.id ? ', dim=' + dimensionMeta.id + '(' + dimensionMeta.outputType + ')' : (dimensionId ? ', dim=' + dimensionId : '')}, prompt="${promptPreview}", historyLen=${history.length}${conversationId ? ', convId=' + conversationId.substring(0, 8) : ''}`);
+    const promptPreview = prompt.length > 80 ? `${prompt.substring(0, 80)}…` : prompt;
+    this.#logger.info(
+      `[ChatAgent] ▶ execute — source=${source}${dimensionMeta?.id ? `, dim=${dimensionMeta.id}(${dimensionMeta.outputType})` : dimensionId ? `, dim=${dimensionId}` : ''}, prompt="${promptPreview}", historyLen=${history.length}${conversationId ? `, convId=${conversationId.substring(0, 8)}` : ''}`
+    );
 
     // 合并预算配置: 默认值 + 外部覆盖
     const budget = budgetOverrides
@@ -192,7 +238,9 @@ export class ChatAgent {
     let effectiveHistory = history;
     if (conversationId && this.#conversations) {
       effectiveHistory = this.#conversations.load(conversationId);
-      this.#logger.info(`[ChatAgent] loaded ${effectiveHistory.length} messages from conversation store`);
+      this.#logger.info(
+        `[ChatAgent] loaded ${effectiveHistory.length} messages from conversation store`
+      );
       this.#conversations.append(conversationId, { role: 'user', content: prompt });
     }
 
@@ -206,10 +254,20 @@ export class ChatAgent {
     this.#logger.info(`[ChatAgent] ✨ using NATIVE tool calling mode (${this.#aiProvider.name})`);
     let result;
     result = await this.#executeWithNativeTools(prompt, {
-      effectiveHistory, conversationId, source, execStartTime, budget, dimensionMeta,
-      systemPromptOverride, allowedTools, disablePhaseRouter, temperatureOverride,
+      effectiveHistory,
+      conversationId,
+      source,
+      execStartTime,
+      budget,
+      dimensionMeta,
+      systemPromptOverride,
+      allowedTools,
+      disablePhaseRouter,
+      temperatureOverride,
       projectLanguage,
-      workingMemory, episodicMemory, toolResultCache,
+      workingMemory,
+      episodicMemory,
+      toolResultCache,
       onProgress,
     });
 
@@ -229,8 +287,11 @@ export class ChatAgent {
     // 持久化 assistant 回复
     if (conversationId && this.#conversations) {
       this.#conversations.append(conversationId, { role: 'assistant', content: result.reply });
-      this.#autoSummarize(conversationId).catch(err => {
-        this.#logger.debug('[ChatAgent] autoSummarize failed', { conversationId, error: err.message });
+      this.#autoSummarize(conversationId).catch((err) => {
+        this.#logger.debug('[ChatAgent] autoSummarize failed', {
+          conversationId,
+          error: err.message,
+        });
       });
     }
 
@@ -260,9 +321,13 @@ export class ChatAgent {
         try {
           const realtime = this.#container?.get?.('realtimeService');
           realtime?.broadcastTokenUsageUpdated?.();
-        } catch { /* optional */ }
+        } catch {
+          /* optional */
+        }
       }
-    } catch { /* token logging should never break execution */ }
+    } catch {
+      /* token logging should never break execution */
+    }
 
     return { ...result, conversationId };
   }
@@ -281,15 +346,29 @@ export class ChatAgent {
    * @param {object} opts
    * @returns {Promise<{reply: string, toolCalls: Array, hasContext: boolean}>}
    */
-  async #executeWithNativeTools(prompt, { effectiveHistory, conversationId, source, execStartTime, budget = DEFAULT_BUDGET, dimensionMeta,
-    // v3.0: Agent 分离新增选项
-    systemPromptOverride, allowedTools, disablePhaseRouter = false, temperatureOverride,
-    projectLanguage,
-    // v4.0: Agent Memory 集成
-    workingMemory, episodicMemory, toolResultCache,
-    // v5.1: SSE 流式进度回调
-    onProgress,
-  }) {
+  async #executeWithNativeTools(
+    prompt,
+    {
+      effectiveHistory,
+      conversationId,
+      source,
+      execStartTime,
+      budget = DEFAULT_BUDGET,
+      dimensionMeta,
+      // v3.0: Agent 分离新增选项
+      systemPromptOverride,
+      allowedTools,
+      disablePhaseRouter = false,
+      temperatureOverride,
+      projectLanguage,
+      // v4.0: Agent Memory 集成
+      workingMemory,
+      episodicMemory,
+      toolResultCache,
+      // v5.1: SSE 流式进度回调
+      onProgress,
+    }
+  ) {
     const isSystem = source === 'system';
     const isSkillOnly = dimensionMeta?.outputType === 'skill';
     const temperature = temperatureOverride ?? (isSystem ? 0.3 : 0.7);
@@ -297,9 +376,7 @@ export class ChatAgent {
     // ── Layer 1: ContextWindow ──
     // messages[0] = prompt（不可压缩），历史消息在前面
     // token 预算按模型动态适配：大窗口模型(Gemini/Claude)给更多预算，小窗口(Ollama)限制预算
-    const tokenBudget = ContextWindow.resolveTokenBudget(
-      this.#aiProvider?.model, { isSystem },
-    );
+    const tokenBudget = ContextWindow.resolveTokenBudget(this.#aiProvider?.model, { isSystem });
     const ctx = new ContextWindow(tokenBudget);
     for (const h of effectiveHistory) {
       if (h.role === 'assistant') {
@@ -314,19 +391,33 @@ export class ChatAgent {
     // ── P5: Pre-check — 首条 prompt 过大时预警 ──
     const initialUsage = ctx.getTokenUsageRatio();
     if (initialUsage > 0.7) {
-      this.#logger.warn(`[ChatAgent] ⚠ initial prompt already at ${(initialUsage * 100).toFixed(0)}% of token budget (${ctx.estimateTokens()}/${ctx.tokenBudget})`);
+      this.#logger.warn(
+        `[ChatAgent] ⚠ initial prompt already at ${(initialUsage * 100).toFixed(0)}% of token budget (${ctx.estimateTokens()}/${ctx.tokenBudget})`
+      );
       if (initialUsage > 0.9 && isSystem) {
         // 仅 1 条消息时 compactIfNeeded 无法压缩（需 >4 条），
         // 依赖 P0/P1 信号限制来控制 prompt 大小
-        this.#logger.warn(`[ChatAgent] ⚠ prompt exceeds 90% budget — P0/P1 signal limiting should have prevented this. Check PROMPT_LIMITS config.`);
+        this.#logger.warn(
+          `[ChatAgent] ⚠ prompt exceeds 90% budget — P0/P1 signal limiting should have prevented this. Check PROMPT_LIMITS config.`
+        );
       }
     }
 
     // ── Layer 2: PhaseRouter (仅 system 源且未禁用时使用) ──
-    const phaseRouter = (isSystem && !disablePhaseRouter) ? new PhaseRouter(budget, isSkillOnly) : null;
+    const phaseRouter =
+      isSystem && !disablePhaseRouter ? new PhaseRouter(budget, isSkillOnly) : null;
 
     // ── 系统提示词 (支持外部覆盖) ──
     let baseSystemPrompt = systemPromptOverride || this.#buildNativeToolSystemPrompt(budget);
+
+    // ── 统一注入语言指令（对所有来源生效: user 对话 / system bootstrap / analyst / producer）──
+    const effectiveLang = this.#currentLang;
+    if (effectiveLang === 'en') {
+      baseSystemPrompt += '\n\n## Language\nYou MUST respond in English. All output text, analysis, titles and descriptions must be in English.';
+    } else if (effectiveLang === 'zh') {
+      baseSystemPrompt += '\n\n## 语言\n你必须使用中文回复。所有输出文本、分析、标题和描述都必须是中文。';
+    }
+
     // 统一注入轮次预算，确保 AI 始终知道具体数字和节奏
     if (isSystem && !baseSystemPrompt.includes('轮次预算')) {
       const exploreEnd = Math.floor(budget.maxIterations * 0.6);
@@ -335,47 +426,60 @@ export class ChatAgent {
     }
 
     // Bootstrap 场景限制可用工具集 (支持外部覆盖)
-    const effectiveAllowedTools = allowedTools || (isSystem ? [
-      'search_project_code', 'read_project_file',
-      'submit_knowledge', 'submit_with_check',
-      'list_project_structure', 'get_file_summary', 'semantic_search_code',
-      // AST 结构化分析工具
-      'get_project_overview', 'get_class_hierarchy', 'get_class_info',
-      'get_protocol_info', 'get_method_overrides', 'get_category_map',
-      'get_previous_analysis',
-      // Agent Memory 工具 (v4.0)
-      'note_finding', 'get_previous_evidence',
-    ] : null);
+    const effectiveAllowedTools =
+      allowedTools ||
+      (isSystem
+        ? [
+            'search_project_code',
+            'read_project_file',
+            'submit_knowledge',
+            'submit_with_check',
+            'list_project_structure',
+            'get_file_summary',
+            'semantic_search_code',
+            // AST 结构化分析工具
+            'get_project_overview',
+            'get_class_hierarchy',
+            'get_class_info',
+            'get_protocol_info',
+            'get_method_overrides',
+            'get_category_map',
+            'get_previous_analysis',
+            // Agent Memory 工具 (v4.0)
+            'note_finding',
+            'get_previous_evidence',
+          ]
+        : null);
     const toolSchemas = this.#toolRegistry.getToolSchemas(effectiveAllowedTools);
 
     const toolCalls = [];
     const maxIter = isSystem ? budget.maxIterations : MAX_ITERATIONS;
     let consecutiveAiErrors = 0;
     let consecutiveEmptyResponses = 0;
-    let iterationCount = 0;  // v3: 独立迭代计数器
+    let iterationCount = 0; // v3: 独立迭代计数器
     const submittedTitles = new Set(this.#globalSubmittedTitles);
     const sharedState = {}; // P2.2: 跨工具调用共享状态（搜索计数器等）
 
     // ── 进度感知收敛 (Analyst 专用: disablePhaseRouter=true) ──
     // 追踪搜索/读取新信息的效率，当探索饱和时提前引导 AI 收敛
     const explorationMetrics = {
-      uniqueFiles: new Set(),        // 已读取的唯一文件
-      uniquePatterns: new Set(),     // 已搜索的唯一 pattern
-      uniqueQueries: new Set(),      // 已查询的唯一类名/目录（AST + list_project_structure）
-      totalToolCalls: 0,             // 总工具调用数
-      newInfoRounds: 0,              // 最近 N 轮中获取到新信息的轮次
-      staleRounds: 0,                // 连续未获取新信息的轮次
-      convergenceNudged: false,      // 是否已注入收敛 nudge
+      uniqueFiles: new Set(), // 已读取的唯一文件
+      uniquePatterns: new Set(), // 已搜索的唯一 pattern
+      uniqueQueries: new Set(), // 已查询的唯一类名/目录（AST + list_project_structure）
+      totalToolCalls: 0, // 总工具调用数
+      newInfoRounds: 0, // 最近 N 轮中获取到新信息的轮次
+      staleRounds: 0, // 连续未获取新信息的轮次
+      convergenceNudged: false, // 是否已注入收敛 nudge
     };
-    const MIN_EXPLORE_ITERS = 16;    // 最少探索轮次（冷启动质量保障）
-    const STALE_THRESHOLD = 3;       // 连续无新信息轮次触发收敛
+    const MIN_EXPLORE_ITERS = 16; // 最少探索轮次（冷启动质量保障）
+    const STALE_THRESHOLD = 3; // 连续无新信息轮次触发收敛
 
     // ── Layer 4: ReasoningLayer — 推理链采集 + 结构化观察 + 反思 + 规划 ──
     const reasoning = new ReasoningLayer({
       enabled: true,
-      reflectionEnabled: isSystem,      // 仅 system 模式启用反思
+      reflectionEnabled: isSystem, // 仅 system 模式启用反思
       reflectionInterval: isSystem ? 5 : 0,
-      planningEnabled: isSystem,        // 仅 system 模式启用规划
+      planningEnabled: isSystem, // 仅 system 模式启用规划
       replanInterval: isSystem ? 8 : 0,
       deviationThreshold: 0.6,
     });
@@ -386,49 +490,71 @@ export class ChatAgent {
       if (phaseRouter) {
         phaseRouter.tick();
         if (phaseRouter.shouldExit()) {
-          this.#logger.info(`[ChatAgent] PhaseRouter exit: phase=${phaseRouter.phase}, iter=${phaseRouter.totalIterations}, submits=${phaseRouter.totalSubmits}`);
+          this.#logger.info(
+            `[ChatAgent] PhaseRouter exit: phase=${phaseRouter.phase}, iter=${phaseRouter.totalIterations}, submits=${phaseRouter.totalSubmits}`
+          );
           break;
         }
         // PhaseRouter 因 maxIterations 强制转入 SUMMARIZE → 注入收尾 nudge
         if (phaseRouter.consumeForcedSummarize()) {
-          const submitCount = toolCalls.filter(tc => tc.tool === 'submit_knowledge' || tc.tool === 'submit_with_check').length;
+          const submitCount = toolCalls.filter(
+            (tc) => tc.tool === 'submit_knowledge' || tc.tool === 'submit_with_check'
+          ).length;
           ctx.appendUserNudge(
             `⚠️ 轮次即将耗尽 (${phaseRouter.totalIterations}/${budget.maxIterations})，**必须立即结束**。请在回复中直接输出 dimensionDigest JSON 总结（用 \`\`\`json 包裹），不要再调用任何工具。\n` +
-            `\`\`\`json\n{"dimensionDigest":{"summary":"分析总结","candidateCount":${submitCount},"keyFindings":["发现"],"crossRefs":{},"gaps":["缺口"],"remainingTasks":[{"signal":"未处理信号","reason":"轮次耗尽","priority":"high","searchHints":["搜索词"]}]}}\n\`\`\`\n> remainingTasks: 列出未来得及处理的信号。已覆盖则留空 \`[]\`。`
+              `\`\`\`json\n{"dimensionDigest":{"summary":"分析总结","candidateCount":${submitCount},"keyFindings":["发现"],"crossRefs":{},"gaps":["缺口"],"remainingTasks":[{"signal":"未处理信号","reason":"轮次耗尽","priority":"high","searchHints":["搜索词"]}]}}\n\`\`\`\n> remainingTasks: 列出未来得及处理的信号。已覆盖则留空 \`[]\`。`
+          );
+          this.#logger.info(
+            '[ChatAgent] 📝 injected forced SUMMARIZE nudge (maxIterations reached)'
           );
-          this.#logger.info('[ChatAgent] 📝 injected forced SUMMARIZE nudge (maxIterations reached)');
         }
-      } else if (isSystem && !phaseRouter && !ctx.__gracefulExitInjected && !explorationMetrics.convergenceNudged
-                 && iterationCount >= MIN_EXPLORE_ITERS && explorationMetrics.staleRounds >= STALE_THRESHOLD) {
+      } else if (
+        isSystem &&
+        !phaseRouter &&
+        !ctx.__gracefulExitInjected &&
+        !explorationMetrics.convergenceNudged &&
+        iterationCount >= MIN_EXPLORE_ITERS &&
+        explorationMetrics.staleRounds >= STALE_THRESHOLD
+      ) {
         // ── 进度感知收敛：探索已饱和，提前引导 AI 总结 ──
         this.#logger.info(
           `[ChatAgent] 📊 Exploration saturated at iter ${iterationCount}/${maxIter} — ` +
-          `files=${explorationMetrics.uniqueFiles.size}, patterns=${explorationMetrics.uniquePatterns.size}, ` +
-          `queries=${explorationMetrics.uniqueQueries.size}, staleRounds=${explorationMetrics.staleRounds} — nudging convergence`
+            `files=${explorationMetrics.uniqueFiles.size}, patterns=${explorationMetrics.uniquePatterns.size}, ` +
+            `queries=${explorationMetrics.uniqueQueries.size}, staleRounds=${explorationMetrics.staleRounds} — nudging convergence`
         );
         ctx.appendUserNudge(
           `你已经充分探索了项目代码（${explorationMetrics.uniqueFiles.size} 个文件，${explorationMetrics.uniquePatterns.size} 次不同搜索，${explorationMetrics.uniqueQueries.size} 次结构化查询）。` +
-          `最近 ${explorationMetrics.staleRounds} 轮没有发现新信息，建议开始撰写分析总结。\n` +
-          `如果你确信还有重要方面未覆盖，可以继续探索（剩余 ${maxIter - iterationCount} 轮）；否则请直接输出你的分析发现。`
+            `最近 ${explorationMetrics.staleRounds} 轮没有发现新信息，建议开始撰写分析总结。\n` +
+            `如果你确信还有重要方面未覆盖，可以继续探索（剩余 ${maxIter - iterationCount} 轮）；否则请直接输出你的分析发现。`
         );
         explorationMetrics.convergenceNudged = true;
         // 不 break，不设 toolChoice=none — 这是软 nudge，AI 仍可继续探索
-      } else if (isSystem && !phaseRouter && !ctx.__budgetWarningInjected
-                 && iterationCount >= Math.floor(maxIter * 0.75)) {
+      } else if (
+        isSystem &&
+        !phaseRouter &&
+        !ctx.__budgetWarningInjected &&
+        iterationCount >= Math.floor(maxIter * 0.75)
+      ) {
         // ── 预算感知提醒：75% 预算消耗时轻量提示 ──
         ctx.appendUserNudge(
-          `📌 进度提醒：你已使用 ${iterationCount}/${maxIter} 轮次（${Math.round(iterationCount / maxIter * 100)}%）。` +
-          `请确保核心方面已覆盖，开始准备总结。剩余 ${maxIter - iterationCount} 轮，优先填补最重要的分析空白。`
+          `📌 进度提醒：你已使用 ${iterationCount}/${maxIter} 轮次（${Math.round((iterationCount / maxIter) * 100)}%）。` +
+            `请确保核心方面已覆盖，开始准备总结。剩余 ${maxIter - iterationCount} 轮，优先填补最重要的分析空白。`
         );
         ctx.__budgetWarningInjected = true;
-        this.#logger.info(`[ChatAgent] 📌 Budget warning at ${iterationCount}/${maxIter} (${Math.round(iterationCount / maxIter * 100)}%)`);
+        this.#logger.info(
+          `[ChatAgent] 📌 Budget warning at ${iterationCount}/${maxIter} (${Math.round((iterationCount / maxIter) * 100)}%)`
+        );
       } else if (isSystem && iterationCount >= maxIter && !ctx.__gracefulExitInjected) {
         // 达到上限 → 注入收尾消息让 AI 快速总结（而非硬中断）
-        this.#logger.info(`[ChatAgent] Iteration cap reached (${iterationCount}/${maxIter}) — injecting graceful exit nudge`);
-        const submitCount = toolCalls.filter(tc => tc.tool === 'submit_knowledge' || tc.tool === 'submit_with_check').length;
+        this.#logger.info(
+          `[ChatAgent] Iteration cap reached (${iterationCount}/${maxIter}) — injecting graceful exit nudge`
+        );
+        const submitCount = toolCalls.filter(
+          (tc) => tc.tool === 'submit_knowledge' || tc.tool === 'submit_with_check'
+        ).length;
         ctx.appendUserNudge(
           `⚠️ 你已使用 ${iterationCount}/${maxIter} 轮次，**必须立即结束**。请在回复中直接输出 dimensionDigest JSON 总结（用 \`\`\`json 包裹），不要再调用任何工具。\n` +
-          `\`\`\`json\n{"dimensionDigest":{"summary":"分析总结","candidateCount":${submitCount},"keyFindings":["发现"],"crossRefs":{},"gaps":["缺口"],"remainingTasks":[{"signal":"未处理信号","reason":"轮次耗尽","priority":"high","searchHints":["搜索词"]}]}}\n\`\`\`\n> remainingTasks: 列出未来得及处理的信号。已覆盖则留空 \`[]\`。`
+            `\`\`\`json\n{"dimensionDigest":{"summary":"分析总结","candidateCount":${submitCount},"keyFindings":["发现"],"crossRefs":{},"gaps":["缺口"],"remainingTasks":[{"signal":"未处理信号","reason":"轮次耗尽","priority":"high","searchHints":["搜索词"]}]}}\n\`\`\`\n> remainingTasks: 列出未来得及处理的信号。已覆盖则留空 \`[]\`。`
         );
         ctx.__gracefulExitInjected = true;
         // 不 break，给 AI 2 轮 grace 来产出总结
@@ -459,7 +585,9 @@ export class ChatAgent {
 
       // ── ReasoningLayer Hook 1: beforeAICall — 开始新轮次 + 反思检查 ──
       const reflectionNudge = reasoning.beforeAICall(iterationCount, {
-        explorationMetrics, budget, phase: phaseRouter?.phase,
+        explorationMetrics,
+        budget,
+        phase: phaseRouter?.phase,
       });
       if (reflectionNudge) {
         ctx.appendUserNudge(reflectionNudge);
@@ -469,7 +597,9 @@ export class ChatAgent {
       // ── 压缩检查 (每次 AI 调用前) ──
       const compactResult = ctx.compactIfNeeded();
       if (compactResult.level > 0) {
-        this.#logger.info(`[ChatAgent] context compacted: L${compactResult.level}, removed ${compactResult.removed} items`);
+        this.#logger.info(
+          `[ChatAgent] context compacted: L${compactResult.level}, removed ${compactResult.removed} items`
+        );
       }
 
       // ── 构建 systemPrompt (含阶段提示) ──
@@ -499,7 +629,7 @@ export class ChatAgent {
       if (workingMemory && isSystem) {
         const wmContext = workingMemory.buildContext();
         if (wmContext) {
-          systemPrompt += '\n\n' + wmContext;
+          systemPrompt += `\n\n${wmContext}`;
         }
       }
 
@@ -508,10 +638,17 @@ export class ChatAgent {
       try {
         const messages = ctx.toMessages();
         const currentPhase = phaseRouter?.phase || 'user';
-        this.#logger.info(`[ChatAgent] 🔄 iteration ${currentIter}/${maxIter} — phase=${currentPhase}, ${messages.length} msgs, toolChoice=${currentChoice}, tokens~${ctx.estimateTokens()}`);
+        this.#logger.info(
+          `[ChatAgent] 🔄 iteration ${currentIter}/${maxIter} — phase=${currentPhase}, ${messages.length} msgs, toolChoice=${currentChoice}, tokens~${ctx.estimateTokens()}`
+        );
 
         // SSE: 推送步骤开始
-        onProgress?.({ type: 'step:start', step: currentIter, maxSteps: maxIter, phase: currentPhase });
+        onProgress?.({
+          type: 'step:start',
+          step: currentIter,
+          maxSteps: maxIter,
+          phase: currentPhase,
+        });
 
         aiResult = await this.#aiProvider.chatWithTools(prompt, {
           messages,
@@ -531,10 +668,14 @@ export class ChatAgent {
         }
 
         if (aiResult.functionCalls?.length > 0) {
-          this.#logger.info(`[ChatAgent] ✓ AI returned ${aiResult.functionCalls.length} function calls in ${aiDuration}ms: [${aiResult.functionCalls.map(fc => fc.name).join(', ')}]`);
+          this.#logger.info(
+            `[ChatAgent] ✓ AI returned ${aiResult.functionCalls.length} function calls in ${aiDuration}ms: [${aiResult.functionCalls.map((fc) => fc.name).join(', ')}]`
+          );
         } else {
           const textPreview = (aiResult.text || '').substring(0, 120).replace(/\n/g, '↵');
-          this.#logger.info(`[ChatAgent] ✓ AI returned text in ${aiDuration}ms (${(aiResult.text || '').length} chars) — "${textPreview}…"`);
+          this.#logger.info(
+            `[ChatAgent] ✓ AI returned text in ${aiDuration}ms (${(aiResult.text || '').length} chars) — "${textPreview}…"`
+          );
         }
         consecutiveAiErrors = 0;
 
@@ -542,7 +683,9 @@ export class ChatAgent {
         reasoning.afterAICall(aiResult);
       } catch (aiErr) {
         consecutiveAiErrors++;
-        this.#logger.warn(`[ChatAgent] AI call failed (attempt ${consecutiveAiErrors}): ${aiErr.message}`);
+        this.#logger.warn(
+          `[ChatAgent] AI call failed (attempt ${consecutiveAiErrors}): ${aiErr.message}`
+        );
 
         // 熔断器已打开时立即跳出 — 不要继续浪费重试、也避免失败计数加速累积
         if (aiErr.code === 'CIRCUIT_OPEN') {
@@ -562,7 +705,9 @@ export class ChatAgent {
 
         if (consecutiveAiErrors >= 2) {
           if (isSystem) {
-            this.#logger.warn(`[ChatAgent] 🛑 2 consecutive AI errors — resetting context, breaking to summary`);
+            this.#logger.warn(
+              `[ChatAgent] 🛑 2 consecutive AI errors — resetting context, breaking to summary`
+            );
             ctx.resetToPromptOnly();
             break;
           }
@@ -576,7 +721,7 @@ export class ChatAgent {
             reasoningQuality: reasoning.getQualityMetrics(),
           };
         }
-        await new Promise(r => setTimeout(r, 2000));
+        await new Promise((r) => setTimeout(r, 2000));
         continue;
       }
 
@@ -585,13 +730,23 @@ export class ChatAgent {
         // ── Graceful exit 保护: Gemini 有时会无视 toolChoice='none' 继续返回工具调用
         //    强制忽略工具调用，将附带文本视为最终回复
         if (ctx.__gracefulExitInjected) {
-          this.#logger.warn(`[ChatAgent] ⚠ AI returned ${aiResult.functionCalls.length} tool calls despite toolChoice=none (graceful exit) — ignoring tools, treating as text`);
+          this.#logger.warn(
+            `[ChatAgent] ⚠ AI returned ${aiResult.functionCalls.length} tool calls despite toolChoice=none (graceful exit) — ignoring tools, treating as text`
+          );
           if (aiResult.text) {
             const reply = this.#cleanFinalAnswer(aiResult.text);
             const totalDuration = Date.now() - execStartTime;
             reasoning.afterRound();
-            this.#logger.info(`[ChatAgent] ✅ final answer (graceful exit, forced) — ${reply.length} chars, ${toolCalls.length} tool calls, ${totalDuration}ms`);
-            return { reply, toolCalls, hasContext: toolCalls.length > 0, reasoningTrace: reasoning.trace, reasoningQuality: reasoning.getQualityMetrics() };
+            this.#logger.info(
+              `[ChatAgent] ✅ final answer (graceful exit, forced) — ${reply.length} chars, ${toolCalls.length} tool calls, ${totalDuration}ms`
+            );
+            return {
+              reply,
+              toolCalls,
+              hasContext: toolCalls.length > 0,
+              reasoningTrace: reasoning.trace,
+              reasoningQuality: reasoning.getQualityMetrics(),
+            };
           }
           // 无文本时继续循环，下一轮硬上限兜底
           continue;
@@ -601,7 +756,9 @@ export class ChatAgent {
         const MAX_TOOL_CALLS_PER_ITER = 8;
         let activeCalls = aiResult.functionCalls;
         if (activeCalls.length > MAX_TOOL_CALLS_PER_ITER) {
-          this.#logger.warn(`[ChatAgent] ⚠ ${activeCalls.length} tool calls, capping to ${MAX_TOOL_CALLS_PER_ITER}`);
+          this.#logger.warn(
+            `[ChatAgent] ⚠ ${activeCalls.length} tool calls, capping to ${MAX_TOOL_CALLS_PER_ITER}`
+          );
           activeCalls = activeCalls.slice(0, MAX_TOOL_CALLS_PER_ITER);
         }
 
@@ -609,14 +766,21 @@ export class ChatAgent {
         ctx.appendAssistantWithToolCalls(aiResult.text || null, activeCalls);
 
         let roundSubmitCount = 0;
-        let roundHasNewInfo = false;  // 本轮是否获取到新信息
+        let roundHasNewInfo = false; // 本轮是否获取到新信息
 
         for (const fc of activeCalls) {
           const toolStartTime = Date.now();
-          this.#logger.info(`[ChatAgent] 🔧 ${fc.name}(${JSON.stringify(fc.args).substring(0, 100)})`);
+          this.#logger.info(
+            `[ChatAgent] 🔧 ${fc.name}(${JSON.stringify(fc.args).substring(0, 100)})`
+          );
 
           // SSE: 推送工具调用开始
-          onProgress?.({ type: 'tool:start', id: `tc_${fc.name}_${Date.now()}`, tool: fc.name, args: fc.args });
+          onProgress?.({
+            type: 'tool:start',
+            id: `tc_${fc.name}_${Date.now()}`,
+            tool: fc.name,
+            args: fc.args,
+          });
 
           let toolResult;
           let cacheHit = false;
@@ -637,28 +801,48 @@ export class ChatAgent {
                 fc.name,
                 fc.args,
                 this.#getToolContext({
-                  _sessionToolCalls: toolCalls, _dimensionMeta: dimensionMeta,
-                  _submittedTitles: submittedTitles, _sharedState: sharedState,
+                  _sessionToolCalls: toolCalls,
+                  _dimensionMeta: dimensionMeta,
+                  _submittedTitles: submittedTitles,
+                  _submittedPatterns: this.#globalSubmittedPatterns,
+                  _sharedState: sharedState,
                   _projectLanguage: projectLanguage,
                   // v4.0: Agent Memory
                   _workingMemory: workingMemory || null,
                   _episodicMemory: episodicMemory || null,
                   _toolResultCache: toolResultCache || null,
                   _currentRound: iterationCount,
-                }),
+                })
               );
               const toolDuration = Date.now() - toolStartTime;
-              const resultSize = typeof toolResult === 'string' ? toolResult.length : JSON.stringify(toolResult).length;
-              this.#logger.info(`[ChatAgent] 🔧 done: ${fc.name} → ${resultSize} chars in ${toolDuration}ms`);
+              const resultSize =
+                typeof toolResult === 'string'
+                  ? toolResult.length
+                  : JSON.stringify(toolResult).length;
+              this.#logger.info(
+                `[ChatAgent] 🔧 done: ${fc.name} → ${resultSize} chars in ${toolDuration}ms`
+              );
 
               // SSE: 推送工具调用完成
-              onProgress?.({ type: 'tool:end', tool: fc.name, status: 'ok', resultSize, duration: toolDuration });
+              onProgress?.({
+                type: 'tool:end',
+                tool: fc.name,
+                status: 'ok',
+                resultSize,
+                duration: toolDuration,
+              });
             } catch (toolErr) {
               this.#logger.warn(`[ChatAgent] 🔧 FAILED: ${fc.name} — ${toolErr.message}`);
               toolResult = { error: `tool "${fc.name}" failed: ${toolErr.message}` };
 
               // SSE: 推送工具调用失败
-              onProgress?.({ type: 'tool:end', tool: fc.name, status: 'error', error: toolErr.message, duration: Date.now() - toolStartTime });
+              onProgress?.({
+                type: 'tool:end',
+                tool: fc.name,
+                status: 'error',
+                error: toolErr.message,
+                duration: Date.now() - toolStartTime,
+              });
             }
           }
 
@@ -710,7 +894,7 @@ export class ChatAgent {
                   }
                 }
                 for (const sub of Object.values(batchResults)) {
-                  for (const m of (sub.matches || [])) {
+                  for (const m of sub.matches || []) {
                     if (m.file && !explorationMetrics.uniqueFiles.has(m.file)) {
                       explorationMetrics.uniqueFiles.add(m.file);
                       foundNewInfo = true;
@@ -739,11 +923,16 @@ export class ChatAgent {
                 explorationMetrics.uniqueQueries.add(qKey);
                 foundNewInfo = true;
               }
-            } else if (fc.name === 'get_class_info' || fc.name === 'get_class_hierarchy'
-                     || fc.name === 'get_protocol_info' || fc.name === 'get_method_overrides'
-                     || fc.name === 'get_category_map') {
+            } else if (
+              fc.name === 'get_class_info' ||
+              fc.name === 'get_class_hierarchy' ||
+              fc.name === 'get_protocol_info' ||
+              fc.name === 'get_method_overrides' ||
+              fc.name === 'get_category_map'
+            ) {
               // AST 结构化查询：同一类名/协议名只算一次新信息
-              const queryTarget = fc.args?.className || fc.args?.protocolName || fc.args?.name || '';
+              const queryTarget =
+                fc.args?.className || fc.args?.protocolName || fc.args?.name || '';
               const qKey = `${fc.name}:${queryTarget}`;
               if (!explorationMetrics.uniqueQueries.has(qKey)) {
                 explorationMetrics.uniqueQueries.add(qKey);
@@ -780,19 +969,31 @@ export class ChatAgent {
           if (fc.name === 'submit_knowledge' || fc.name === 'submit_with_check') {
             const title = fc.args?.title || fc.args?.category || '';
             const isRejected = typeof toolResult === 'object' && toolResult?.status === 'rejected';
-            const isError = typeof toolResult === 'object' && (toolResult?.error || toolResult?.status === 'error');
+            const isError =
+              typeof toolResult === 'object' &&
+              (toolResult?.error || toolResult?.status === 'error');
 
             if (isRejected) {
               this.#logger.info(`[ChatAgent] 🚫 off-topic rejected: "${title}"`);
             } else if (isError) {
               // 候选创建失败（如 validation error）— 不加入 submittedTitles，允许 AI 重试
-              this.#logger.info(`[ChatAgent] ⚠ submit error: "${title}" — ${toolResult.error || 'unknown'}`);
+              this.#logger.info(
+                `[ChatAgent] ⚠ submit error: "${title}" — ${toolResult.error || 'unknown'}`
+              );
             } else if (submittedTitles.has(title)) {
               resultStr = `⚠ 重复提交: "${title}" 已存在。`;
               this.#logger.info(`[ChatAgent] 🔁 duplicate: "${title}"`);
             } else {
               submittedTitles.add(title);
               this.#globalSubmittedTitles.add(title);
+              // 记录代码模式指纹用于跨维度去重
+              const pattern = fc.args?.content?.pattern || '';
+              if (pattern.length >= 30) {
+                const fp = pattern.replace(/\/\/[^\n]*/g, '').replace(/\/\*[\s\S]*?\*\//g, '').replace(/[\s]+/g, '').toLowerCase().slice(0, 200);
+                if (fp.length >= 20) {
+                  this.#globalSubmittedPatterns.add(fp);
+                }
+              }
               roundSubmitCount++;
             }
           }
@@ -836,7 +1037,9 @@ export class ChatAgent {
           // skill-only 维度从 EXPLORE 直接进入 SUMMARIZE (跳过 PRODUCE)，
           // 需要明确告知 AI 输出 dimensionDigest JSON
           if (transition.transitioned && transition.newPhase === 'SUMMARIZE') {
-            const submitCount = toolCalls.filter(tc => tc.tool === 'submit_knowledge' || tc.tool === 'submit_with_check').length;
+            const submitCount = toolCalls.filter(
+              (tc) => tc.tool === 'submit_knowledge' || tc.tool === 'submit_with_check'
+            ).length;
             ctx.appendUserNudge(
               `你已完成分析探索。请在回复中直接输出 dimensionDigest JSON（用 \`\`\`json 包裹），包含以下字段：\n\`\`\`json\n{"dimensionDigest":{"summary":"分析总结(100-200字)","candidateCount":${submitCount},"keyFindings":["关键发现"],"crossRefs":{},"gaps":["未覆盖方面"],"remainingTasks":[{"signal":"未处理的信号/主题","reason":"未完成原因(如:提交上限已达)","priority":"high|medium|low","searchHints":["建议搜索词"]}]}}\n\`\`\`\n> 如果所有信号都已覆盖，remainingTasks 留空数组 \`[]\`。如果有未来得及处理的信号，请在此标记，系统会在下次运行时续传。`
             );
@@ -855,8 +1058,10 @@ export class ChatAgent {
       // 空响应重试（Gemini 偶发）
       if (!aiResult.text && isSystem && consecutiveEmptyResponses < 2) {
         consecutiveEmptyResponses++;
-        this.#logger.warn(`[ChatAgent] ⚠ empty response from system source — retrying (${consecutiveEmptyResponses}/2)`);
-        await new Promise(r => setTimeout(r, 1500));
+        this.#logger.warn(
+          `[ChatAgent] ⚠ empty response from system source — retrying (${consecutiveEmptyResponses}/2)`
+        );
+        await new Promise((r) => setTimeout(r, 1500));
         continue;
       }
       // 收到非空响应时重置空响应计数器
@@ -878,19 +1083,31 @@ export class ChatAgent {
           // 注入 nudge 让 AI 再输出一次 digest JSON
           if (transition.transitioned) {
             ctx.appendAssistantText(aiResult.text || '');
-            const submitCount = toolCalls.filter(tc => tc.tool === 'submit_knowledge' || tc.tool === 'submit_with_check').length;
+            const submitCount = toolCalls.filter(
+              (tc) => tc.tool === 'submit_knowledge' || tc.tool === 'submit_with_check'
+            ).length;
             ctx.appendUserNudge(
               `请在回复中直接输出 dimensionDigest JSON 总结（用 \`\`\`json 包裹）：\n\`\`\`json\n{"dimensionDigest":{"summary":"分析总结","candidateCount":${submitCount},"keyFindings":["发现"],"crossRefs":{},"gaps":["缺口"],"remainingTasks":[{"signal":"未处理的信号","reason":"原因","priority":"high","searchHints":["搜索词"]}]}}\n\`\`\`\n> remainingTasks: 记录未来得及处理的信号。已全部覆盖则留空 \`[]\`。`
             );
-            this.#logger.info('[ChatAgent] 📝 injected SUMMARIZE nudge (text-triggered transition)');
+            this.#logger.info(
+              '[ChatAgent] 📝 injected SUMMARIZE nudge (text-triggered transition)'
+            );
             continue;
           }
           // 已在 SUMMARIZE 阶段 — 这就是最终回答
           const reply = this.#cleanFinalAnswer(aiResult.text || '');
           const totalDuration = Date.now() - execStartTime;
           reasoning.afterRound();
-          this.#logger.info(`[ChatAgent] ✅ final answer — ${reply.length} chars, ${phaseRouter.totalIterations} iters, ${toolCalls.length} tool calls, ${totalDuration}ms`);
-          return { reply, toolCalls, hasContext: toolCalls.length > 0, reasoningTrace: reasoning.trace, reasoningQuality: reasoning.getQualityMetrics() };
+          this.#logger.info(
+            `[ChatAgent] ✅ final answer — ${reply.length} chars, ${phaseRouter.totalIterations} iters, ${toolCalls.length} tool calls, ${totalDuration}ms`
+          );
+          return {
+            reply,
+            toolCalls,
+            hasContext: toolCalls.length > 0,
+            reasoningTrace: reasoning.trace,
+            reasoningQuality: reasoning.getQualityMetrics(),
+          };
         }
 
         if (!transition.transitioned) {
@@ -902,7 +1119,9 @@ export class ChatAgent {
               ctx.appendUserNudge(
                 '你的分析很好。请继续调用 submit_knowledge 提交你发现的知识候选，每个值得记录的模式/实践都应该提交。'
               );
-              this.#logger.info('[ChatAgent] 📝 injected submit nudge (text in PRODUCE, not transitioning)');
+              this.#logger.info(
+                '[ChatAgent] 📝 injected submit nudge (text in PRODUCE, not transitioning)'
+              );
             }
             continue;
           }
@@ -910,8 +1129,16 @@ export class ChatAgent {
           const reply = this.#cleanFinalAnswer(aiResult.text || '');
           const totalDuration = Date.now() - execStartTime;
           reasoning.afterRound();
-          this.#logger.info(`[ChatAgent] ✅ final answer — ${reply.length} chars, ${phaseRouter.totalIterations} iters, ${toolCalls.length} tool calls, ${totalDuration}ms`);
-          return { reply, toolCalls, hasContext: toolCalls.length > 0, reasoningTrace: reasoning.trace, reasoningQuality: reasoning.getQualityMetrics() };
+          this.#logger.info(
+            `[ChatAgent] ✅ final answer — ${reply.length} chars, ${phaseRouter.totalIterations} iters, ${toolCalls.length} tool calls, ${totalDuration}ms`
+          );
+          return {
+            reply,
+            toolCalls,
+            hasContext: toolCalls.length > 0,
+            reasoningTrace: reasoning.trace,
+            reasoningQuality: reasoning.getQualityMetrics(),
+          };
         }
 
         // 其他阶段的文字回答 → 继续循环（PhaseRouter 已自动转换阶段）
@@ -924,22 +1151,44 @@ export class ChatAgent {
         const reply = this.#cleanFinalAnswer(aiResult.text || '');
         const totalDuration = Date.now() - execStartTime;
         reasoning.afterRound();
-        this.#logger.info(`[ChatAgent] ✅ final answer (${ctx.__gracefulExitInjected ? 'graceful exit' : 'user'}) — ${reply.length} chars, ${toolCalls.length} tool calls, ${totalDuration}ms`);
-        return { reply, toolCalls, hasContext: toolCalls.length > 0, reasoningTrace: reasoning.trace, reasoningQuality: reasoning.getQualityMetrics() };
+        this.#logger.info(
+          `[ChatAgent] ✅ final answer (${ctx.__gracefulExitInjected ? 'graceful exit' : 'user'}) — ${reply.length} chars, ${toolCalls.length} tool calls, ${totalDuration}ms`
+        );
+        return {
+          reply,
+          toolCalls,
+          hasContext: toolCalls.length > 0,
+          reasoningTrace: reasoning.trace,
+          reasoningQuality: reasoning.getQualityMetrics(),
+        };
       }
 
       // system 模式非 graceful exit 的文字回答（理论上不应到这里）
       const reply = this.#cleanFinalAnswer(aiResult.text || '');
       const totalDuration = Date.now() - execStartTime;
       reasoning.afterRound();
-      this.#logger.info(`[ChatAgent] ✅ final answer — ${reply.length} chars, ${toolCalls.length} tool calls, ${totalDuration}ms`);
-      return { reply, toolCalls, hasContext: toolCalls.length > 0, reasoningTrace: reasoning.trace, reasoningQuality: reasoning.getQualityMetrics() };
+      this.#logger.info(
+        `[ChatAgent] ✅ final answer — ${reply.length} chars, ${toolCalls.length} tool calls, ${totalDuration}ms`
+      );
+      return {
+        reply,
+        toolCalls,
+        hasContext: toolCalls.length > 0,
+        reasoningTrace: reasoning.trace,
+        reasoningQuality: reasoning.getQualityMetrics(),
+      };
     }
 
     // ── 循环退出: 产出 dimensionDigest 总结 ──
     reasoning.afterRound();
     const forcedResult = await this.#produceForcedSummary({
-      source, toolCalls, toolSchemas, ctx, phaseRouter, execStartTime,
+      source,
+      toolCalls,
+      toolSchemas,
+      ctx,
+      phaseRouter,
+      execStartTime,
+      prompt,
     });
     forcedResult.reasoningTrace = reasoning.trace;
     forcedResult.reasoningQuality = reasoning.getQualityMetrics();
@@ -950,32 +1199,55 @@ export class ChatAgent {
    * 强制退出后的摘要生成 — 独立方法，避免主循环代码膨胀
    * @private
    */
-  async #produceForcedSummary({ source, toolCalls, toolSchemas, ctx, phaseRouter, execStartTime }) {
+  async #produceForcedSummary({
+    source,
+    toolCalls,
+    toolSchemas,
+    ctx,
+    phaseRouter,
+    execStartTime,
+    prompt,
+  }) {
     const iterations = phaseRouter?.totalIterations || 0;
-    this.#logger.info(`[ChatAgent] ⚠ producing forced summary (${iterations} iters, ${toolCalls.length} calls)`);
+    const isSystem = source === 'system';
+    this.#logger.info(
+      `[ChatAgent] ⚠ producing forced summary (${iterations} iters, ${toolCalls.length} calls, source=${source})`
+    );
 
-    const candidateCount = toolCalls.filter(tc =>
-      tc.tool === 'submit_knowledge' || tc.tool === 'submit_with_check'
+    const candidateCount = toolCalls.filter(
+      (tc) => tc.tool === 'submit_knowledge' || tc.tool === 'submit_with_check'
     ).length;
 
     let finalReply;
 
-    // 如果熔断器已打开，跳过 AI 调用直接合成 digest（避免无用的失败 + 计数累积）
+    // 如果熔断器已打开，跳过 AI 调用直接合成摘要（避免无用的失败 + 计数累积）
     const isCircuitOpen = this.#aiProvider._circuitState === 'OPEN';
     if (isCircuitOpen) {
-      this.#logger.warn(`[ChatAgent] circuit breaker is OPEN — skipping AI summary, using synthetic digest`);
+      this.#logger.warn(
+        `[ChatAgent] circuit breaker is OPEN — skipping AI summary, using synthetic ${isSystem ? 'digest' : 'summary'}`
+      );
     }
 
+    // ── 收集工具调用摘要（user / system 共用） ──
+    const submitSummary = toolCalls
+      .filter((tc) => tc.tool === 'submit_knowledge' || tc.tool === 'submit_with_check')
+      .map((tc, i) => `${i + 1}. ${tc.params?.title || tc.params?.category || 'untitled'}`)
+      .join('\n');
+
+    // ── 收集工具调用上下文（user 源需要更丰富的上下文来生成自然语言总结） ──
+    const toolContextSummary = isSystem ? '' : this.#buildToolContextForUserSummary(toolCalls);
+
     try {
-      if (isCircuitOpen) throw new Error('circuit open — skip to synthetic digest');
+      if (isCircuitOpen) {
+        throw new Error('circuit open — skip to synthetic summary');
+      }
 
-      const submitSummary = toolCalls
-        .filter(tc => tc.tool === 'submit_knowledge' || tc.tool === 'submit_with_check')
-        .map((tc, i) => `${i + 1}. ${tc.params?.title || tc.params?.category || 'untitled'}`)
-        .join('\n');
+      let summaryPrompt;
+      let systemPrompt;
 
-      const summaryPrompt = source === 'system'
-        ? `你已完成 ${iterations} 轮工具调用（共 ${toolCalls.length} 次），提交了 ${candidateCount} 个候选。
+      if (isSystem) {
+        // ── system 源: 输出 dimensionDigest JSON（供 Bootstrap 管线消费） ──
+        summaryPrompt = `你已完成 ${iterations} 轮工具调用（共 ${toolCalls.length} 次），提交了 ${candidateCount} 个候选。
 ${submitSummary ? `已提交候选:\n${submitSummary}\n` : ''}
 **必须**输出 dimensionDigest JSON（用 \`\`\`json 包裹）：
 \`\`\`json
@@ -992,21 +1264,36 @@ ${submitSummary ? `已提交候选:\n${submitSummary}\n` : ''}
   }
 }
 \`\`\`
-> remainingTasks: 列出本次未来得及处理的信号/主题。已全部覆盖则留空 \`[]\`。`
-        : `Completed ${iterations} iterations with ${toolCalls.length} tool calls. Please summarize.`;
+> remainingTasks: 列出本次未来得及处理的信号/主题。已全部覆盖则留空 \`[]\`。`;
+        systemPrompt = '直接输出 dimensionDigest JSON 总结，不要调用工具。';
+      } else {
+        // ── user 源: 输出人类可读的 Markdown 结构化总结（前端 AI Chat 展示） ──
+        const userQuestion = prompt ? `用户的原始问题：「${prompt.slice(0, 500)}」\n\n` : '';
+        summaryPrompt = `${userQuestion}你刚才通过 ${toolCalls.length} 次工具调用分析了项目代码。以下是你调用过的工具和获取到的关键信息：
+
+${toolContextSummary}
+
+请基于以上收集到的信息，用**清晰易读的 Markdown** 格式撰写分析总结，直接回答用户的问题。
+
+要求：
+- 使用二级/三级标题组织内容
+- 要有具体的代码文件路径、类名、模式名称等细节
+- 关键发现用列表项罗列
+- 如果发现了架构模式或最佳实践，用简短代码块举例
+- 语言自然流畅，像一份技术分析报告`;
+        systemPrompt =
+          '你是项目分析助手。请用纯 Markdown 格式输出结构清晰的分析总结，只输出人类可读的自然语言文档，不要输出 JSON 格式的数据。';
+      }
 
       // 用空 messages 避免累积上下文导致 400
-      const summaryResult = await this.#aiProvider.chatWithTools(
-        summaryPrompt,
-        {
-          messages: [],
-          toolSchemas,
-          toolChoice: 'none',
-          systemPrompt: '直接输出 dimensionDigest JSON 总结，不要调用工具。',
-          temperature: 0.3,
-          maxTokens: 8192,
-        },
-      );
+      const summaryResult = await this.#aiProvider.chatWithTools(summaryPrompt, {
+        messages: [],
+        toolSchemas,
+        toolChoice: 'none',
+        systemPrompt,
+        temperature: isSystem ? 0.3 : 0.5,
+        maxTokens: 8192,
+      });
       // 累计 token 用量
       if (summaryResult.usage) {
         this.#currentTokenUsage.input += summaryResult.usage.inputTokens || 0;
@@ -1015,11 +1302,13 @@ ${submitSummary ? `已提交候选:\n${submitSummary}\n` : ''}
       finalReply = this.#cleanFinalAnswer(summaryResult.text || '');
     } catch (err) {
       this.#logger.warn(`[ChatAgent] forced summary AI call failed: ${err.message}`);
-      // 合成 digest 兜底
-      const titles = toolCalls
-        .filter(tc => tc.tool === 'submit_knowledge' || tc.tool === 'submit_with_check')
-        .map(tc => tc.params?.title || 'untitled');
-      finalReply = `\`\`\`json
+
+      if (isSystem) {
+        // ── system 源兜底: 合成 dimensionDigest JSON ──
+        const titles = toolCalls
+          .filter((tc) => tc.tool === 'submit_knowledge' || tc.tool === 'submit_with_check')
+          .map((tc) => tc.params?.title || 'untitled');
+        finalReply = `\`\`\`json
 {
   "dimensionDigest": {
     "summary": "通过 ${toolCalls.length} 次工具调用分析了项目代码，提交了 ${candidateCount} 个候选。",
@@ -1030,13 +1319,136 @@ ${submitSummary ? `已提交候选:\n${submitSummary}\n` : ''}
   }
 }
 \`\`\``;
+      } else {
+        // ── user 源兜底: 合成人类可读的 Markdown 摘要 ──
+        const toolNames = [...new Set(toolCalls.map((tc) => tc.tool))];
+        const filesRead = toolCalls
+          .filter((tc) => tc.tool === 'read_project_file')
+          .flatMap((tc) => {
+            if (tc.params?.filePaths) {
+              return tc.params.filePaths;
+            }
+            if (tc.params?.filePath) {
+              return [tc.params.filePath];
+            }
+            return [];
+          })
+          .slice(0, 10);
+        const searches = toolCalls
+          .filter((tc) => tc.tool === 'search_project_code' || tc.tool === 'semantic_search_code')
+          .map((tc) => tc.params?.patterns?.[0] || tc.params?.query || tc.params?.pattern)
+          .filter(Boolean)
+          .slice(0, 5);
+
+        finalReply = `## 分析总结\n\n通过 **${toolCalls.length} 次工具调用**探索了项目代码。\n\n`;
+        if (searches.length > 0) {
+          finalReply += `### 搜索的关键词\n${searches.map((s) => `- \`${s}\``).join('\n')}\n\n`;
+        }
+        if (filesRead.length > 0) {
+          finalReply += `### 读取的文件\n${filesRead.map((f) => `- \`${f}\``).join('\n')}\n\n`;
+        }
+        finalReply += `### 使用的工具\n${toolNames.map((t) => `- ${t}`).join('\n')}\n\n`;
+        finalReply += `> ⚠️ AI 服务异常，未能生成完整分析。请稍后重试或缩小分析范围。`;
+      }
     }
 
     const totalDuration = Date.now() - execStartTime;
-    this.#logger.info(`[ChatAgent] ✅ forced summary — ${finalReply.length} chars, ${totalDuration}ms total`);
+    this.#logger.info(
+      `[ChatAgent] ✅ forced summary — ${finalReply.length} chars, ${totalDuration}ms total`
+    );
     return { reply: finalReply, toolCalls, hasContext: toolCalls.length > 0 };
   }
 
+  /**
+   * 从工具调用记录中提取上下文摘要（供 user 源强制总结使用）
+   * @private
+   */
+  #buildToolContextForUserSummary(toolCalls) {
+    const sections = [];
+
+    // 目录结构探索
+    const structureCalls = toolCalls.filter((tc) => tc.tool === 'list_project_structure');
+    if (structureCalls.length > 0) {
+      const dirs = structureCalls.map((tc) => tc.params?.directory || '/').slice(0, 5);
+      sections.push(`**目录探索**: ${dirs.map((d) => `\`${d}\``).join(', ')}`);
+    }
+
+    // 项目概况
+    const overviewCalls = toolCalls.filter((tc) => tc.tool === 'get_project_overview');
+    if (overviewCalls.length > 0) {
+      sections.push('**项目概况**: 已获取');
+    }
+
+    // 代码搜索
+    const searchCalls = toolCalls.filter(
+      (tc) => tc.tool === 'search_project_code' || tc.tool === 'semantic_search_code'
+    );
+    if (searchCalls.length > 0) {
+      const queries = searchCalls
+        .map((tc) => tc.params?.patterns?.[0] || tc.params?.query || tc.params?.pattern)
+        .filter(Boolean)
+        .slice(0, 8);
+      sections.push(
+        `**代码搜索** (${searchCalls.length} 次): ${queries.map((q) => `\`${q}\``).join(', ')}`
+      );
+    }
+
+    // 文件读取
+    const readCalls = toolCalls.filter((tc) => tc.tool === 'read_project_file');
+    if (readCalls.length > 0) {
+      const files = readCalls
+        .flatMap((tc) => {
+          if (tc.params?.filePaths) {
+            return tc.params.filePaths;
+          }
+          if (tc.params?.filePath) {
+            return [tc.params.filePath];
+          }
+          return [];
+        })
+        .slice(0, 10);
+      sections.push(
+        `**文件读取** (${readCalls.length} 次): ${files.map((f) => `\`${f}\``).join(', ')}`
+      );
+    }
+
+    // AST 分析
+    const astCalls = toolCalls.filter((tc) =>
+      [
+        'get_class_hierarchy',
+        'get_class_info',
+        'get_protocol_info',
+        'get_method_overrides',
+        'get_category_map',
+      ].includes(tc.tool)
+    );
+    if (astCalls.length > 0) {
+      const entities = astCalls
+        .map(
+          (tc) =>
+            tc.params?.className ||
+            tc.params?.name ||
+            tc.params?.protocolName ||
+            tc.params?.rootClass
+        )
+        .filter(Boolean)
+        .slice(0, 5);
+      sections.push(
+        `**AST 结构分析** (${astCalls.length} 次): ${entities.map((e) => `\`${e}\``).join(', ')}`
+      );
+    }
+
+    // 知识库搜索
+    const kbCalls = toolCalls.filter((tc) =>
+      ['search_knowledge', 'search_recipes', 'knowledge_overview'].includes(tc.tool)
+    );
+    if (kbCalls.length > 0) {
+      sections.push(`**知识库查询**: ${kbCalls.length} 次`);
+    }
+
+    return sections.length > 0 ? sections.join('\n') : '（工具调用记录为空）';
+  }
+
   // ─── Text Parsing 已移除 (v5.0) ────────────────────────
   // 所有 Provider 统一走 chatWithTools() 原生函数调用路径。
   // 不支持 native tool calling 的 Provider 在基类 chatWithTools()
@@ -1064,7 +1476,9 @@ ${submitSummary ? `已提交候选:\n${submitSummary}\n` : ''}
    * @returns {string} conversationId
    */
   createConversation({ category = 'user', title = '' } = {}) {
-    if (!this.#conversations) return null;
+    if (!this.#conversations) {
+      return null;
+    }
     return this.#conversations.create({ category, title });
   }
 
@@ -1076,7 +1490,9 @@ ${submitSummary ? `已提交候选:\n${submitSummary}\n` : ''}
    * @returns {Array}
    */
   getConversations({ category, limit = 20 } = {}) {
-    if (!this.#conversations) return [];
+    if (!this.#conversations) {
+      return [];
+    }
     return this.#conversations.list({ category, limit });
   }
 
@@ -1100,12 +1516,18 @@ ${submitSummary ? `已提交候选:\n${submitSummary}\n` : ''}
     }
     // 降级到硬编码任务（复杂交互逻辑无法用 DAG 表达的场景）
     switch (taskName) {
-      case 'check_and_submit': return this.#taskCheckAndSubmit(params);
-      case 'discover_all_relations': return this.#taskDiscoverAllRelations(params);
-      case 'full_enrich': return this.#taskFullEnrich(params);
-      case 'quality_audit': return this.#taskQualityAudit(params);
-      case 'guard_full_scan': return this.#taskGuardFullScan(params);
-      default: throw new Error(`Unknown task: ${taskName}`);
+      case 'check_and_submit':
+        return this.#taskCheckAndSubmit(params);
+      case 'discover_all_relations':
+        return this.#taskDiscoverAllRelations(params);
+      case 'full_enrich':
+        return this.#taskFullEnrich(params);
+      case 'quality_audit':
+        return this.#taskQualityAudit(params);
+      case 'guard_full_scan':
+        return this.#taskGuardFullScan(params);
+      default:
+        throw new Error(`Unknown task: ${taskName}`);
     }
   }
 
@@ -1131,7 +1553,9 @@ ${submitSummary ? `已提交候选:\n${submitSummary}\n` : ''}
    */
   async runPipeline(pipelineId, inputs = {}) {
     const pipeline = this.#pipelines.get(pipelineId);
-    if (!pipeline) throw new Error(`Pipeline '${pipelineId}' not found`);
+    if (!pipeline) {
+      throw new Error(`Pipeline '${pipelineId}' not found`);
+    }
     const executor = (toolName, params) => this.executeTool(toolName, params);
     return pipeline.execute(executor, inputs);
   }
@@ -1140,7 +1564,7 @@ ${submitSummary ? `已提交候选:\n${submitSummary}\n` : ''}
    * 获取已注册的管线列表
    */
   getPipelines() {
-    return [...this.#pipelines.values()].map(p => p.describe());
+    return [...this.#pipelines.values()].map((p) => p.describe());
   }
 
   /**
@@ -1155,7 +1579,11 @@ ${submitSummary ? `已提交候选:\n${submitSummary}\n` : ''}
         { name: 'full_enrich', description: '批量 AI 语义补全候选字段' },
         { name: 'quality_audit', description: '批量质量审计全部 Recipe，标记低分项' },
         { name: 'guard_full_scan', description: '用全部 Guard 规则扫描指定代码，生成完整报告' },
-        { name: 'bootstrap_full_pipeline', description: '冷启动全流程 DAG: bootstrap(纯启发式) → enrich(AI结构补齐) + loadSkill(并行) → refine(AI内容润色)' },
+        {
+          name: 'bootstrap_full_pipeline',
+          description:
+            '冷启动全流程 DAG: bootstrap(纯启发式) → enrich(AI结构补齐) + loadSkill(并行) → refine(AI内容润色)',
+        },
       ],
       pipelines: this.getPipelines(),
     };
@@ -1177,7 +1605,7 @@ ${submitSummary ? `已提交候选:\n${submitSummary}\n` : ''}
     });
 
     // Step 2: 如果有高相似度，使用 AI 分析是否真正重复
-    const highSim = (duplicates.similar || []).filter(d => d.similarity >= 0.7);
+    const highSim = (duplicates.similar || []).filter((d) => d.similarity >= 0.7);
     let aiVerdict = null;
     if (highSim.length > 0 && this.#aiProvider) {
       const verdictPrompt = `以下新候选代码与已有 Recipe 高度相似，请判断是否真正重复。
@@ -1187,23 +1615,28 @@ ${submitSummary ? `已提交候选:\n${submitSummary}\n` : ''}
 - Code: ${(candidate.code || '').substring(0, 1000)}
 
 相似 Recipe:
-${highSim.map(s => `- ${s.title} (相似度: ${s.similarity})`).join('\n')}
+${highSim.map((s) => `- ${s.title} (相似度: ${s.similarity})`).join('\n')}
 
 请回答: DUPLICATE（真正重复）/ SIMILAR（相似但不同，建议保留并标注关系）/ UNIQUE（误判，可放心提交）
 只回答一个词。`;
       try {
         const raw = await this.#aiProvider.chat(verdictPrompt, { temperature: 0, maxTokens: 20 });
         aiVerdict = (raw || '').trim().toUpperCase().split(/\s/)[0];
-      } catch { /* ignore */ }
+      } catch {
+        /* ignore */
+      }
     }
 
     return {
       duplicates: duplicates.similar || [],
       highSimilarity: highSim,
       aiVerdict,
-      recommendation: highSim.length === 0
-        ? 'safe_to_submit'
-        : aiVerdict === 'DUPLICATE' ? 'block_duplicate' : 'review_suggested',
+      recommendation:
+        highSim.length === 0
+          ? 'safe_to_submit'
+          : aiVerdict === 'DUPLICATE'
+            ? 'block_duplicate'
+            : 'review_suggested',
     };
   }
 
@@ -1214,14 +1647,27 @@ ${highSim.map(s => `- ${s.title} (相似度: ${s.similarity})`).join('\n')}
   async #taskDiscoverAllRelations({ batchSize = 20 } = {}) {
     const ctx = this.#getToolContext();
     const knowledgeService = ctx.container.get('knowledgeService');
-    if (!knowledgeService) throw new Error('KnowledgeService 不可用');
+    if (!knowledgeService) {
+      throw new Error('KnowledgeService 不可用');
+    }
 
-    if (!ctx.aiProvider) throw new Error('AI Provider 未配置，请先设置 API Key');
+    if (!ctx.aiProvider) {
+      throw new Error('AI Provider 未配置，请先设置 API Key');
+    }
 
     // 获取所有活跃知识条目
-    const { items = [], data = [] } = await knowledgeService.list({ lifecycle: 'active' }, { page: 1, pageSize: 500 });
+    const { items = [], data = [] } = await knowledgeService.list(
+      { lifecycle: 'active' },
+      { page: 1, pageSize: 500 }
+    );
     const recipes = items.length > 0 ? items : data;
-    if (recipes.length < 2) return { discovered: 0, totalPairs: 0, message: `只有 ${recipes.length} 条 Recipe，至少需要 2 条` };
+    if (recipes.length < 2) {
+      return {
+        discovered: 0,
+        totalPairs: 0,
+        message: `只有 ${recipes.length} 条 Recipe，至少需要 2 条`,
+      };
+    }
 
     // 按 batch 分组分析
     const pairs = [];
@@ -1241,14 +1687,28 @@ ${highSim.map(s => `- ${s.title} (相似度: ${s.similarity})`).join('\n')}
       try {
         const result = await this.executeTool('discover_relations', {
           recipePairs: batch.map(([a, b]) => ({
-            a: { id: a.id, title: a.title, category: a.category, language: a.language, code: String(a.content || a.code || '').substring(0, 500) },
-            b: { id: b.id, title: b.title, category: b.category, language: b.language, code: String(b.content || b.code || '').substring(0, 500) },
+            a: {
+              id: a.id,
+              title: a.title,
+              category: a.category,
+              language: a.language,
+              code: String(a.content || a.code || '').substring(0, 500),
+            },
+            b: {
+              id: b.id,
+              title: b.title,
+              category: b.category,
+              language: b.language,
+              code: String(b.content || b.code || '').substring(0, 500),
+            },
           })),
         });
 
         if (result.error) {
           batchErrors++;
-          this.#logger.warn(`[DiscoverRelations] Batch ${Math.floor(b / batchSize) + 1} error: ${result.error}`);
+          this.#logger.warn(
+            `[DiscoverRelations] Batch ${Math.floor(b / batchSize) + 1} error: ${result.error}`
+          );
           continue;
         }
         if (result.relations) {
@@ -1257,7 +1717,9 @@ ${highSim.map(s => `- ${s.title} (相似度: ${s.similarity})`).join('\n')}
         }
       } catch (err) {
         batchErrors++;
-        this.#logger.warn(`[DiscoverRelations] Batch ${Math.floor(b / batchSize) + 1} threw: ${err.message}`);
+        this.#logger.warn(
+          `[DiscoverRelations] Batch ${Math.floor(b / batchSize) + 1} threw: ${err.message}`
+        );
       }
     }
 
@@ -1278,21 +1740,26 @@ ${highSim.map(s => `- ${s.title} (相似度: ${s.similarity})`).join('\n')}
     const knowledgeService = ctx.container.get('knowledgeService');
 
     const { items = [], data = [] } = await knowledgeService.list(
-      { lifecycle: status }, { page: 1, pageSize: maxCount }
+      { lifecycle: status },
+      { page: 1, pageSize: maxCount }
     );
     const candidates = items.length > 0 ? items : data;
-    if (candidates.length === 0) return { enriched: 0, message: 'No candidates to enrich' };
+    if (candidates.length === 0) {
+      return { enriched: 0, message: 'No candidates to enrich' };
+    }
 
     // 筛选缺失语义字段的候选
-    const needEnrich = candidates.filter(c => {
+    const needEnrich = candidates.filter((c) => {
       const m = c.metadata || {};
       return !m.rationale || !m.knowledgeType || !m.complexity;
     });
 
-    if (needEnrich.length === 0) return { enriched: 0, message: 'All candidates already enriched' };
+    if (needEnrich.length === 0) {
+      return { enriched: 0, message: 'All candidates already enriched' };
+    }
 
     const result = await this.executeTool('enrich_candidate', {
-      candidateIds: needEnrich.map(c => c.id).slice(0, 20),
+      candidateIds: needEnrich.map((c) => c.id).slice(0, 20),
     });
 
     return result;
@@ -1307,17 +1774,22 @@ ${highSim.map(s => `- ${s.title} (相似度: ${s.similarity})`).join('\n')}
     const knowledgeService = ctx.container.get('knowledgeService');
 
     const { items = [], data = [] } = await knowledgeService.list(
-      { lifecycle: 'active' }, { page: 1, pageSize: maxCount }
+      { lifecycle: 'active' },
+      { page: 1, pageSize: maxCount }
     );
     const recipes = items.length > 0 ? items : data;
-    if (recipes.length === 0) return { total: 0, lowQuality: [], message: 'No active recipes' };
+    if (recipes.length === 0) {
+      return { total: 0, lowQuality: [], message: 'No active recipes' };
+    }
 
     const lowQuality = [];
     const gradeDistribution = { A: 0, B: 0, C: 0, D: 0, F: 0 };
 
     for (const recipe of recipes) {
       const scoreResult = await this.executeTool('quality_score', { recipe });
-      if (scoreResult.grade) gradeDistribution[scoreResult.grade] = (gradeDistribution[scoreResult.grade] || 0) + 1;
+      if (scoreResult.grade) {
+        gradeDistribution[scoreResult.grade] = (gradeDistribution[scoreResult.grade] || 0) + 1;
+      }
       if (scoreResult.score < threshold) {
         lowQuality.push({
           id: recipe.id,
@@ -1345,11 +1817,15 @@ ${highSim.map(s => `- ${s.title} (相似度: ${s.similarity})`).join('\n')}
    * 对代码运行全部 Guard 规则 + 生成修复建议
    */
   async #taskGuardFullScan({ code, language, filePath } = {}) {
-    if (!code) return { error: 'code is required' };
+    if (!code) {
+      return { error: 'code is required' };
+    }
 
     // Step 1: 静态检查
     const checkResult = await this.executeTool('guard_check_code', {
-      code, language: language || 'unknown', scope: 'project',
+      code,
+      language: language || 'unknown',
+      scope: 'project',
     });
 
     // Step 2: 如果有违规且 AI 可用，生成修复建议
@@ -1358,7 +1834,10 @@ ${highSim.map(s => `- ${s.title} (相似度: ${s.similarity})`).join('\n')}
       try {
         const violationSummary = (checkResult.violations || [])
           .slice(0, 5)
-          .map(v => `- [${v.severity}] ${v.message || v.ruleName} (line ${v.line || v.matches?.[0]?.line || '?'})`)
+          .map(
+            (v) =>
+              `- [${v.severity}] ${v.message || v.ruleName} (line ${v.line || v.matches?.[0]?.line || '?'})`
+          )
           .join('\n');
 
         const prompt = `以下代码存在 Guard 规则违规。请为每个违规提供修复建议。
@@ -1373,10 +1852,15 @@ ${code.substring(0, 3000)}
 
 请用 JSON 数组格式返回建议: [{"violation": "...", "suggestion": "...", "fixExample": "..."}]`;
 
-        suggestions = await this.#aiProvider.chatWithStructuredOutput(prompt, {
-          openChar: '[', closeChar: ']', temperature: 0.3,
-        }) || [];
-      } catch { /* AI suggestions optional */ }
+        suggestions =
+          (await this.#aiProvider.chatWithStructuredOutput(prompt, {
+            openChar: '[',
+            closeChar: ']',
+            temperature: 0.3,
+          })) || [];
+      } catch {
+        /* AI suggestions optional */
+      }
     }
 
     return {
@@ -1403,18 +1887,20 @@ ${code.substring(0, 3000)}
     // ── bootstrap_full_pipeline (v6 简化版) ──────────────────
     // 只做启发式 Phase 1-5.5 (含 ChatAgent per-dimension production)
     // 不再需要 enrich/refine 后置步骤
-    this.registerPipeline(new TaskPipeline('bootstrap_full_pipeline', [
-      {
-        name: 'bootstrap',
-        tool: 'bootstrap_knowledge',
-        params: {
-          maxFiles: (ctx) => ctx._inputs.maxFiles || 500,
-          skipGuard: (ctx) => ctx._inputs.skipGuard || false,
-          contentMaxLines: (ctx) => ctx._inputs.contentMaxLines || 120,
-          loadSkills: true,
+    this.registerPipeline(
+      new TaskPipeline('bootstrap_full_pipeline', [
+        {
+          name: 'bootstrap',
+          tool: 'bootstrap_knowledge',
+          params: {
+            maxFiles: (ctx) => ctx._inputs.maxFiles || 500,
+            skipGuard: (ctx) => ctx._inputs.skipGuard || false,
+            contentMaxLines: (ctx) => ctx._inputs.contentMaxLines || 120,
+            loadSkills: true,
+          },
         },
-      },
-    ]));
+      ])
+    );
   }
 
   // ─── Native Tool Calling 内部方法 ──────────────────────
@@ -1434,9 +1920,11 @@ ${code.substring(0, 3000)}
       let soulSection = '';
       try {
         if (fs.existsSync(SOUL_PATH)) {
-          soulSection = '\n' + fs.readFileSync(SOUL_PATH, 'utf-8').trim() + '\n';
+          soulSection = `\n${fs.readFileSync(SOUL_PATH, 'utf-8').trim()}\n`;
         }
-      } catch { /* SOUL.md not available */ }
+      } catch {
+        /* SOUL.md not available */
+      }
 
       return `${soulSection}
 你是 AutoSnippet 项目的统一 AI 中心。项目内所有 AI 推理和分析都通过你执行。
@@ -1446,8 +1934,7 @@ ${this.#projectBriefingCache}${this.#memory?.toPromptSection({ source: 'user' })
 1. 当需要查询数据时，直接调用相应工具。
 2. 工具参数严格按照工具声明中的 schema 传递。
 3. 对于代码分析任务，先 search_project_code 搜索，再 read_project_file 读取。
-4. 回答时使用用户的语言（中文/英文）。
-5. 当工具返回错误时，尝试不同参数或方法。`;
+4. 当工具返回错误时，尝试不同参数或方法。`;
     }
 
     // Bootstrap 系统模式: LLM 以领域大脑的能力处理任务
@@ -1490,7 +1977,9 @@ submit_knowledge 的 code 字段必须是「项目特写」— 将技术的基
    * 清理最终回答（去除 Thought/preamble + MEMORY 标签）
    */
   #cleanFinalAnswer(response) {
-    if (!response) return '';
+    if (!response) {
+      return '';
+    }
     return response
       .replace(/^(Final Answer|最终回答|Answer)\s*[:：]\s*/i, '')
       .replace(/\[MEMORY:\w+\]\s*[\s\S]*?\s*\[\/MEMORY\]/g, '')
@@ -1537,9 +2026,10 @@ submit_knowledge 的 code 字段必须是「项目特写」— 将技术的基
    */
   #loadSkillsFromDir(dir, skillMap) {
     try {
-      const dirs = fs.readdirSync(dir, { withFileTypes: true })
-        .filter(d => d.isDirectory())
-        .map(d => d.name);
+      const dirs = fs
+        .readdirSync(dir, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name);
       for (const name of dirs) {
         const skillPath = path.join(dir, name, 'SKILL.md');
         let summary = '';
@@ -1553,15 +2043,19 @@ submit_knowledge 的 code 字段必须是「项目特写」— 将技术的基
             for (const line of lines) {
               const trimmed = line.trim();
               if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('---')) {
-                summary = trimmed.length > 80 ? trimmed.substring(0, 80) + '...' : trimmed;
+                summary = trimmed.length > 80 ? `${trimmed.substring(0, 80)}...` : trimmed;
                 break;
               }
             }
           }
-        } catch { /* SKILL.md not found */ }
+        } catch {
+          /* SKILL.md not found */
+        }
         skillMap.set(name, { name, summary });
       }
-    } catch { /* directory not found */ }
+    } catch {
+      /* directory not found */
+    }
   }
 
   /**
@@ -1571,13 +2065,16 @@ submit_knowledge 的 code 字段必须是「项目特写」— 将技术的基
   async #buildProjectBriefing() {
     try {
       const db = this.#container?.get('database');
-      if (!db) return '';
+      if (!db) {
+        return '';
+      }
       // knowledgeType → kind 映射:
       //   rule: code-standard, code-style, best-practice, boundary-constraint
       //   pattern: code-pattern, architecture, solution
       //   fact: code-relation, inheritance, call-chain, data-flow, module-dependency
       // V3: knowledge_entries 统一表（candidates 已合并，lifecycle 替代 status）
-      const stats = db.prepare(`
+      const stats = db
+        .prepare(`
         SELECT
           (SELECT COUNT(*) FROM knowledge_entries WHERE lifecycle = 'active') as recipeCount,
           (SELECT COUNT(*) FROM knowledge_entries WHERE lifecycle = 'active' AND knowledgeType IN ('code-standard','code-style','best-practice','boundary-constraint')) as ruleCount,
@@ -1586,7 +2083,8 @@ submit_knowledge 的 code 字段必须是「项目特写」— 将技术的基
           (SELECT COUNT(*) FROM knowledge_entries WHERE lifecycle = 'active' AND knowledgeType = 'boundary-constraint') as guardRuleCount,
           (SELECT COUNT(*) FROM knowledge_entries WHERE lifecycle = 'pending') as pendingCandidates,
           (SELECT COUNT(*) FROM knowledge_entries) as totalCandidates
-      `).get();
+      `)
+        .get();
       if (!stats || stats.recipeCount === 0) {
         return '\n## 项目状态\n⚠️ 知识库为空。建议先执行冷启动（bootstrap_knowledge）。\n';
       }
@@ -1608,11 +2106,17 @@ submit_knowledge 的 code 字段必须是「项目特写」— 将技术的基
     try {
       const db = container?.get?.('database');
       if (db) {
-        import('./ProjectSemanticMemory.js').then(({ ProjectSemanticMemory }) => {
-          this.#semanticMemory = new ProjectSemanticMemory(db, { logger: this.#logger });
-        }).catch(() => { /* Semantic Memory not available */ });
+        import('./ProjectSemanticMemory.js')
+          .then(({ ProjectSemanticMemory }) => {
+            this.#semanticMemory = new ProjectSemanticMemory(db, { logger: this.#logger });
+          })
+          .catch(() => {
+            /* Semantic Memory not available */
+          });
       }
-    } catch { /* container.get failed, degrade silently */ }
+    } catch {
+      /* container.get failed, degrade silently */
+    }
   }
 
   /**
@@ -1625,7 +2129,9 @@ submit_knowledge 的 code 字段必须是「项目特写」— 将技术的基
    * source 隔离: 标记 memory 来源，避免系统分析污染用户记忆
    */
   #extractMemory(prompt, reply) {
-    if (!this.#memory && !this.#semanticMemory) return;
+    if (!this.#memory && !this.#semanticMemory) {
+      return;
+    }
     const source = this.#currentSource || 'user';
 
     try {
@@ -1638,7 +2144,7 @@ submit_knowledge 的 code 字段必须是「项目特写」— 将技术的基
         /remember\s+(to|that)/i,
         /our\s+(convention|standard|rule)\s+is/i,
       ];
-      if (prefPatterns.some(p => p.test(prompt))) {
+      if (prefPatterns.some((p) => p.test(prompt))) {
         const entry = {
           type: 'preference',
           content: prompt.substring(0, 200),
@@ -1656,7 +2162,7 @@ submit_knowledge 的 code 字段必须是「项目特写」— 将技术的基
         /let'?s\s+(go\s+with|use|adopt)/i,
         /approved|confirmed|decided/i,
       ];
-      if (decisionPatterns.some(p => p.test(prompt))) {
+      if (decisionPatterns.some((p) => p.test(prompt))) {
         const entry = {
           type: 'decision',
           content: prompt.substring(0, 200),
@@ -1687,7 +2193,9 @@ submit_knowledge 的 code 字段必须是「项目特写」— 将技术的基
           }
         }
       }
-    } catch { /* memory write failure is non-critical */ }
+    } catch {
+      /* memory write failure is non-critical */
+    }
   }
 
   /**
@@ -1695,7 +2203,9 @@ submit_knowledge 的 code 字段必须是「项目特写」— 将技术的基
    * 当对话消息数超过 12 条时触发 AI 摘要压缩
    */
   async #autoSummarize(conversationId) {
-    if (!this.#conversations || !this.#aiProvider) return;
+    if (!this.#conversations || !this.#aiProvider) {
+      return;
+    }
     try {
       const messages = this.#conversations.load(conversationId, { tokenBudget: Infinity });
       if (messages.length >= 12) {
@@ -1735,17 +2245,23 @@ submit_knowledge 的 code 字段必须是「项目特写」— 将技术的基
    * 截断长文本
    */
   #truncate(text, maxLen = 4000) {
-    if (!text || text.length <= maxLen) return text;
-    return text.substring(0, maxLen) + `\n...(truncated, ${text.length - maxLen} chars omitted)`;
+    if (!text || text.length <= maxLen) {
+      return text;
+    }
+    return `${text.substring(0, maxLen)}\n...(truncated, ${text.length - maxLen} chars omitted)`;
   }
 
   /**
    * 精简工具结果（避免过长的 observation）
    */
   #summarizeResult(result) {
-    if (!result) return null;
+    if (!result) {
+      return null;
+    }
     const str = typeof result === 'string' ? result : JSON.stringify(result);
-    if (str.length <= 500) return result;
+    if (str.length <= 500) {
+      return result;
+    }
     // 返回截断版
     if (typeof result === 'object') {
       if (Array.isArray(result)) {
@@ -1757,7 +2273,7 @@ submit_knowledge 的 code 字段必须是「项目特写」— 将技术的基
       for (const k of keys) {
         const v = result[k];
         if (typeof v === 'string' && v.length > 200) {
-          summary[k] = v.substring(0, 200) + '...';
+          summary[k] = `${v.substring(0, 200)}...`;
         } else if (Array.isArray(v)) {
           summary[k] = { _count: v.length, first2: v.slice(0, 2) };
         } else {