autosnippet 2.5.0 → 2.7.0

package/lib/service/chat/ChatAgent.js

@@ -28,12 +28,86 @@ import { fileURLToPath } from 'node:url';
 import Logger from '../../infrastructure/logging/Logger.js';
 import { TaskPipeline } from './TaskPipeline.js';
 import { Memory } from './Memory.js';
+import { ConversationStore } from './ConversationStore.js';
+import { ContextWindow, PhaseRouter, limitToolResult } from './ContextWindow.js';
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const PROJECT_ROOT = path.resolve(__dirname, '../../..');
 const SKILLS_DIR = path.resolve(PROJECT_ROOT, 'skills');
 const SOUL_PATH = path.resolve(PROJECT_ROOT, 'SOUL.md');
 const MAX_ITERATIONS = 6;
+/** 系统调用 (如 bootstrap) 允许更多迭代,因为每维度需要多次 submit_candidate */
+const MAX_ITERATIONS_SYSTEM = 30;
+/** 原生函数调用模式下，已提交 ≥ MIN_SUBMITS_FOR_EARLY_EXIT 个候选后，连续 N 轮无新提交则提前退出 */
+const MIN_SUBMITS_FOR_EARLY_EXIT = 1;
+const IDLE_ROUNDS_TO_EXIT = 2;
+/** 单个维度最多提交候选数量 — 超过后跳过提交返回提醒 */
+const MAX_SUBMITS_PER_DIMENSION = 6;
+/** 提交达到软上限后注入收尾提示的阈值 */
+const SOFT_SUBMIT_LIMIT = 4;
+/** 连续搜索/阅读轮次预算 — 超过后注入提交提示并切 auto */
+const SEARCH_BUDGET = 8;
+/** 搜索预算耗尽后，额外容忍的轮次 — 再未提交则强制退出 */
+const SEARCH_BUDGET_GRACE = 4;
+
+/** 默认预算配置 — 可通过 execute() 的 opts.budget 覆盖 */
+const DEFAULT_BUDGET = Object.freeze({
+  maxIterations: MAX_ITERATIONS_SYSTEM,
+  searchBudget: SEARCH_BUDGET,
+  searchBudgetGrace: SEARCH_BUDGET_GRACE,
+  maxSubmits: MAX_SUBMITS_PER_DIMENSION,
+  softSubmitLimit: SOFT_SUBMIT_LIMIT,
+  idleRoundsToExit: IDLE_ROUNDS_TO_EXIT,
+});
+
+/**
+ * 系统调用续跑提示 — 当 AI 输出纯文本计划而未执行工具调用时注入
+ * 告诉 AI 不要只写文字描述,而要实际调用工具
+ */
+const SYSTEM_CONTINUATION_PROMPT = `你的分析计划很好。但你需要 **实际执行工具调用** 来完成任务,而不是只写文字描述。
+
+请现在开始执行:
+1. 用 \`search_project_code\` 搜索项目代码获取真实示例
+2. 用 \`read_project_file\` 查看完整文件内容
+3. 对每个值得保留的信号,用 \`submit_candidate\` 提交候选
+
+⚡ 推荐使用 batch_actions 一次提交多条候选:
+\`\`\`batch_actions
+[
+  {"tool": "submit_candidate", "params": {"title": "[Bootstrap] xxx/子主题", "code": "# 标题 — 项目特写\\n\\n> 摘要...\\n\\n描述和代码交织...", "language": "objectivec", "category": "Service", "summary": "...", "tags": ["bootstrap"], "source": "bootstrap", "reasoning": {"whyStandard": "...", "sources": ["file1"], "confidence": 0.7}}},
+  {"tool": "submit_candidate", "params": {"title": "...", "code": "...", ...}}
+]
+\`\`\`
+
+请立即开始执行,不要再输出分析文字。`;
+
+/**
+ * 系统调用提交提示 — 当 AI 做了工具调用(search/read)、写了分析文本,但没调 submit_candidate 时注入
+ * 引导 AI 将已有分析转化为实际的 submit_candidate 调用
+ */
+const SYSTEM_SUBMIT_PROMPT = `你的分析很好，已经获取了足够的项目信息。但你还没有调用 \`submit_candidate\` 提交任何候选。
+
+**你的分析不能只停留在文字描述层面** — 必须通过工具调用将分析结果持久化。
+
+请根据你刚才的分析,立即使用 batch_actions 提交候选:
+
+\`\`\`batch_actions
+[
+  {"tool": "submit_candidate", "params": {
+    "title": "[Bootstrap] 维度/子主题",
+    "code": "# 标题 — 项目特写\\n\\n> 本项目使用 XX 模式, N 个文件采用此写法\\n\\n描述...\\n\\n\`\`\`objc\\n// 真实代码示例\\n\`\`\`\\n\\n要点说明...",
+    "language": "objectivec",
+    "category": "Tool",
+    "summary": "≤80字精准摘要,引用真实类名和数字",
+    "tags": ["bootstrap", "维度id"],
+    "source": "bootstrap",
+    "reasoning": {"whyStandard": "为什么值得保留", "sources": ["真实文件名"], "confidence": 0.7}
+  }},
+  {"tool": "submit_candidate", "params": {...}}
+]
+\`\`\`
+
+将你上面分析出的每个有价值的发现都转化为一条 submit_candidate 调用。code 字段写「项目特写」风格: 描述和代码交织,用项目真实类名和代码。`;
 
 export class ChatAgent {
   #toolRegistry;
@@ -46,6 +120,14 @@ export class ChatAgent {
   #projectBriefingCache = '';
   /** @type {Memory|null} 跨对话轻量记忆 */
   #memory = null;
+  /** @type {ConversationStore|null} 对话持久化 */
+  #conversations = null;
+  /** @type {string|null} 当前 execute 调用的 source — 'user' | 'system' */
+  #currentSource = null;
+  /** @type {Array|null} 内存文件缓存（bootstrap 场景注入，search_project_code/read_project_file 优先使用） */
+  #fileCache = null;
+  /** @type {Set<string>} 跨维度已提交候选标题（bootstrap 全局去重） */
+  #globalSubmittedTitles = new Set();
 
   /**
    * @param {object} opts
@@ -62,11 +144,18 @@ export class ChatAgent {
     /** 是否有 AI Provider（只读） */
     this.hasAI = !!aiProvider;
 
-    // 初始化跨对话记忆
+    /**
+     * 是否有真实（非 Mock）AI Provider
+     * MockProvider 不具备实际推理能力，bootstrap 编排时应视为 AI 不可用
+     */
+    this.hasRealAI = !!aiProvider && aiProvider.name !== 'mock';
+
+    // 初始化跨对话记忆 + 对话持久化
     try {
       const projectRoot = container?.singletons?._projectRoot || process.cwd();
       this.#memory = new Memory(projectRoot);
-    } catch { /* Memory init failed, degrade silently */ }
+      this.#conversations = new ConversationStore(projectRoot);
+    } catch { /* Memory/ConversationStore init failed, degrade silently */ }
 
     // 注册内置 DAG 管线
     this.#registerBuiltinPipelines();
@@ -74,6 +163,22 @@ export class ChatAgent {
 
   // ─── 公共 API ─────────────────────────────────────────
 
+  /**
+   * 注入内存文件缓存（bootstrap 场景: allFiles 已在内存中，避免重复磁盘读取）
+   * 调用后 search_project_code / read_project_file 优先从缓存查找
+   * @param {Array|null} files — [{ relativePath, content, name }]
+   */
+  setFileCache(files) {
+    this.#fileCache = files;
+  }
+
+  /**
+   * 重置跨维度全局提交标题（新 bootstrap session 开始时调用）
+   */
+  resetGlobalSubmittedTitles() {
+    this.#globalSubmittedTitles.clear();
+  }
+
   /**
    * 交互式对话（Dashboard Chat 入口）
    * 自动带 ReAct 循环: LLM 可决定调用工具或直接回答
@@ -81,88 +186,674 @@ export class ChatAgent {
    * @param {string} prompt — 用户消息
    * @param {object} opts
    * @param {Array}  opts.history — 对话历史 [{role, content}]
-   * @returns {Promise<{reply: string, toolCalls: Array, hasContext: boolean}>}
+   * @param {string} [opts.conversationId] — 对话 ID（启用持久化时）
+   * @param {'user'|'system'} [opts.source='user'] — 调用来源（影响 Memory 隔离）
+   * @param {object} [opts.dimensionMeta] — Bootstrap 维度元数据 { id, outputType, allowedKnowledgeTypes }
+   * @returns {Promise<{reply: string, toolCalls: Array, hasContext: boolean, conversationId?: string}>}
    */
-  async execute(prompt, { history = [] } = {}) {
+  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, // 覆盖默认温度
+  } = {}) {
+    this.#currentSource = source;
+    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 budget = budgetOverrides
+      ? { ...DEFAULT_BUDGET, ...budgetOverrides }
+      : { ...DEFAULT_BUDGET };
+
+    // 对话持久化: 如果传了 conversationId，从 ConversationStore 加载历史
+    let effectiveHistory = history;
+    if (conversationId && this.#conversations) {
+      effectiveHistory = this.#conversations.load(conversationId);
+      this.#logger.info(`[ChatAgent] loaded ${effectiveHistory.length} messages from conversation store`);
+      this.#conversations.append(conversationId, { role: 'user', content: prompt });
+    }
+
     // 每次对话刷新项目概况（不是每轮 ReAct）
     this.#projectBriefingCache = await this.#buildProjectBriefing();
 
+    // ── 双模路由: 原生函数调用 vs 文本解析 ──
+    // 支持原生函数调用的 Provider (如 Gemini) 走结构化路径，
+    // 其他 Provider 走传统文本 ReAct 解析路径
+    let result;
+    if (this.#aiProvider.supportsNativeToolCalling) {
+      this.#logger.info(`[ChatAgent] ✨ using NATIVE tool calling mode (${this.#aiProvider.name})`);
+      result = await this.#executeWithNativeTools(prompt, {
+        effectiveHistory, conversationId, source, execStartTime, budget, dimensionMeta,
+        // v3.0 新增
+        systemPromptOverride, allowedTools, disablePhaseRouter, temperatureOverride,
+      });
+    } else {
+      this.#logger.info(`[ChatAgent] 📝 using TEXT parsing mode (${this.#aiProvider.name})`);
+      result = await this.#executeWithTextParsing(prompt, {
+        effectiveHistory, conversationId, source, execStartTime,
+      });
+    }
+
+    // 持久化 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.#extractMemory(prompt, result.reply);
+
+    return { ...result, conversationId };
+  }
+
+  // ─── Native Tool Calling ReAct 循环 ──────────────────────
+
+  /**
+   * 原生结构化函数调用 ReAct 循环
+   *
+   * 三层架构:
+   *   1. ContextWindow — 消息生命周期 + 三级递进压缩
+   *   2. PhaseRouter — 阶段状态机 (EXPLORE→PRODUCE→SUMMARIZE)
+   *   3. ToolResultLimiter — 工具结果入口压缩 (动态配额)
+   *
+   * @param {string} prompt
+   * @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,
+  }) {
+    const isSystem = source === 'system';
+    const isSkillOnly = dimensionMeta?.outputType === 'skill';
+    const temperature = temperatureOverride ?? (isSystem ? 0.3 : 0.7);
+
+    // ── Layer 1: ContextWindow ──
+    // messages[0] = prompt（不可压缩），历史消息在前面
+    const ctx = new ContextWindow(isSystem ? 24000 : 16000);
+    for (const h of effectiveHistory) {
+      if (h.role === 'assistant') {
+        ctx.appendAssistantText(h.content);
+      } else {
+        ctx.appendUserMessage(h.content);
+      }
+    }
+    // prompt 作为最终 user message（Anthropic 最佳实践: 查询放在所有上下文之后）
+    ctx.appendUserMessage(prompt);
+
+    // ── 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})`);
+      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.`);
+      }
+    }
+
+    // ── Layer 2: PhaseRouter (仅 system 源且未禁用时使用) ──
+    const phaseRouter = (isSystem && !disablePhaseRouter) ? new PhaseRouter(budget, isSkillOnly) : null;
+
+    // ── 系统提示词 (支持外部覆盖) ──
+    const baseSystemPrompt = systemPromptOverride || this.#buildNativeToolSystemPrompt(budget);
+
+    // Bootstrap 场景限制可用工具集 (支持外部覆盖)
+    const effectiveAllowedTools = allowedTools || (isSystem ? [
+      'search_project_code', 'read_project_file',
+      'submit_candidate', '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',
+    ] : 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: 独立迭代计数器
+    const submittedTitles = new Set(this.#globalSubmittedTitles);
+
+    // ── 主循环 ──
+    while (true) {
+      // PhaseRouter tick + 退出检查
+      if (phaseRouter) {
+        phaseRouter.tick();
+        if (phaseRouter.shouldExit()) {
+          this.#logger.info(`[ChatAgent] PhaseRouter exit: phase=${phaseRouter.phase}, iter=${phaseRouter.totalIterations}, submits=${phaseRouter.totalSubmits}`);
+          break;
+        }
+      } else if (isSystem && iterationCount >= maxIter) {
+        // v3: system 模式无 PhaseRouter 时用独立迭代计数器硬限制
+        this.#logger.info(`[ChatAgent] Iteration hard cap reached: ${iterationCount}/${maxIter}`);
+        break;
+      } else if (!isSystem && ctx.length > maxIter * 2 + 2) {
+        // 用户对话模式: 简单的消息数限制
+        break;
+      }
+      iterationCount++;
+
+      const iterStartTime = Date.now();
+      const currentIter = phaseRouter?.totalIterations || iterationCount;
+
+      // ── 动态 toolChoice (由 PhaseRouter 决定) ──
+      let currentChoice;
+      if (phaseRouter) {
+        currentChoice = phaseRouter.getToolChoice();
+      } else {
+        currentChoice = 'auto';
+      }
+
+      // ── 压缩检查 (每次 AI 调用前) ──
+      const compactResult = ctx.compactIfNeeded();
+      if (compactResult.level > 0) {
+        this.#logger.info(`[ChatAgent] context compacted: L${compactResult.level}, removed ${compactResult.removed} items`);
+      }
+
+      // ── 构建 systemPrompt (含阶段提示) ──
+      let systemPrompt = baseSystemPrompt;
+      if (phaseRouter) {
+        const hint = phaseRouter.getPhaseHint();
+        if (hint) {
+          systemPrompt += `\n\n## 当前状态\n${hint}`;
+        }
+      }
+
+      // ── AI 调用 ──
+      let aiResult;
+      try {
+        const messages = ctx.toMessages();
+        this.#logger.info(`[ChatAgent] 🔄 iteration ${currentIter}/${maxIter} — phase=${phaseRouter?.phase || 'user'}, ${messages.length} msgs, toolChoice=${currentChoice}, tokens~${ctx.estimateTokens()}`);
+
+        aiResult = await this.#aiProvider.chatWithTools(prompt, {
+          messages,
+          toolSchemas,
+          toolChoice: currentChoice,
+          systemPrompt,
+          temperature,
+          maxTokens: 8192,
+        });
+
+        const aiDuration = Date.now() - iterStartTime;
+        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(', ')}]`);
+        } 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}…"`);
+        }
+        consecutiveAiErrors = 0;
+      } catch (aiErr) {
+        consecutiveAiErrors++;
+        this.#logger.warn(`[ChatAgent] AI call failed (attempt ${consecutiveAiErrors}): ${aiErr.message}`);
+
+        // 熔断器已打开时立即跳出 — 不要继续浪费重试、也避免失败计数加速累积
+        if (aiErr.code === 'CIRCUIT_OPEN') {
+          if (isSystem) {
+            this.#logger.warn(`[ChatAgent] 🛑 circuit breaker is OPEN — skipping to summary`);
+            break;
+          }
+          return {
+            reply: `抱歉，AI 服务暂时不可用（${aiErr.message}）。请稍后重试，或检查 API 配置。`,
+            toolCalls,
+            hasContext: toolCalls.length > 0,
+          };
+        }
+
+        if (consecutiveAiErrors >= 2) {
+          if (isSystem) {
+            this.#logger.warn(`[ChatAgent] 🛑 2 consecutive AI errors — resetting context, breaking to summary`);
+            ctx.resetToPromptOnly();
+            break;
+          }
+          return {
+            reply: `抱歉，AI 服务暂时不可用（${aiErr.message}）。请稍后重试，或检查 API 配置。`,
+            toolCalls,
+            hasContext: toolCalls.length > 0,
+          };
+        }
+        await new Promise(r => setTimeout(r, 2000));
+        continue;
+      }
+
+      // ── 处理 functionCalls ──
+      if (aiResult.functionCalls && aiResult.functionCalls.length > 0) {
+        // 限制单次工具调用数量（防上下文溢出）
+        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}`);
+          activeCalls = activeCalls.slice(0, MAX_TOOL_CALLS_PER_ITER);
+        }
+
+        // ContextWindow: 原子追加 assistant + tool results
+        ctx.appendAssistantWithToolCalls(aiResult.text || null, activeCalls);
+
+        let roundSubmitCount = 0;
+
+        for (const fc of activeCalls) {
+          const toolStartTime = Date.now();
+          this.#logger.info(`[ChatAgent] 🔧 ${fc.name}(${JSON.stringify(fc.args).substring(0, 100)})`);
+
+          let toolResult;
+          try {
+            toolResult = await this.#toolRegistry.execute(
+              fc.name,
+              fc.args,
+              this.#getToolContext({ _sessionToolCalls: toolCalls, _dimensionMeta: dimensionMeta, _submittedTitles: submittedTitles }),
+            );
+            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`);
+          } catch (toolErr) {
+            this.#logger.warn(`[ChatAgent] 🔧 FAILED: ${fc.name} — ${toolErr.message}`);
+            toolResult = { error: `tool "${fc.name}" failed: ${toolErr.message}` };
+          }
+
+          // 记录到全局 toolCalls
+          const summarized = this.#summarizeResult(toolResult);
+          toolCalls.push({ tool: fc.name, params: fc.args, result: summarized });
+
+          // ── Layer 3: ToolResultLimiter — 动态配额压缩 ──
+          const quota = ctx.getToolResultQuota();
+          let resultStr = limitToolResult(fc.name, toolResult, quota);
+
+          // ── 重复提交 / 维度范围校验 ──
+          if (fc.name === 'submit_candidate' || 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');
+
+            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'}`);
+            } else if (submittedTitles.has(title)) {
+              resultStr = `⚠ 重复提交: "${title}" 已存在。`;
+              this.#logger.info(`[ChatAgent] 🔁 duplicate: "${title}"`);
+            } else {
+              submittedTitles.add(title);
+              this.#globalSubmittedTitles.add(title);
+              roundSubmitCount++;
+            }
+          }
+
+          // ContextWindow: 追加 tool result（与 assistant 保持原子性）
+          ctx.appendToolResult(fc.id, fc.name, resultStr);
+        }
+
+        // ── PhaseRouter 更新 ──
+        if (phaseRouter) {
+          const transition = phaseRouter.update({
+            functionCalls: activeCalls,
+            submitCount: roundSubmitCount,
+            isTextOnly: false,
+          });
+
+          // ── EXPLORE→PRODUCE 阶段过渡: 注入提交引导消息 ──
+          // 原生工具调用模式下，仅靠 systemPrompt 附加 hint 不够显著，
+          // 需要一条 user 消息明确告知 AI 切换到提交模式
+          if (transition.transitioned && transition.newPhase === 'PRODUCE') {
+            ctx.appendUserNudge(
+              '你已充分探索了项目代码，现在请开始调用 submit_candidate 工具来提交你发现的知识候选。不要再搜索，直接提交。'
+            );
+            this.#logger.info('[ChatAgent] 📝 injected PRODUCE transition nudge');
+          }
+
+          // ── EXPLORE→SUMMARIZE / PRODUCE→SUMMARIZE 阶段过渡: 注入 digest 引导 ──
+          // skill-only 维度从 EXPLORE 直接进入 SUMMARIZE (跳过 PRODUCE)，
+          // 需要明确告知 AI 输出 dimensionDigest JSON
+          if (transition.transitioned && transition.newPhase === 'SUMMARIZE') {
+            const submitCount = toolCalls.filter(tc => tc.tool === 'submit_candidate' || 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 留空数组 \`[]\`。如果有未来得及处理的信号，请在此标记，系统会在下次运行时续传。`
+            );
+            this.#logger.info('[ChatAgent] 📝 injected SUMMARIZE transition nudge');
+          }
+        }
+
+        continue;
+      }
+
+      // ── 文字回答 ──
+      // 空响应重试（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));
+        continue;
+      }
+      // 收到非空响应时重置空响应计数器
+      if (aiResult.text) {
+        consecutiveEmptyResponses = 0;
+      }
+
+      // PhaseRouter: 文字回答触发阶段转换
+      if (phaseRouter) {
+        const transition = phaseRouter.update({
+          functionCalls: null,
+          submitCount: 0,
+          isTextOnly: true,
+        });
+
+        // SUMMARIZE 阶段的文字回答 = 最终回答
+        if (phaseRouter.phase === 'SUMMARIZE') {
+          // 刚从 EXPLORE/PRODUCE 转入 SUMMARIZE 的文字回答可能不含 digest，
+          // 注入 nudge 让 AI 再输出一次 digest JSON
+          if (transition.transitioned) {
+            ctx.appendAssistantText(aiResult.text || '');
+            const submitCount = toolCalls.filter(tc => tc.tool === 'submit_candidate' || 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)');
+            continue;
+          }
+          // 已在 SUMMARIZE 阶段 — 这就是最终回答
+          const reply = this.#cleanFinalAnswer(aiResult.text || '');
+          const totalDuration = Date.now() - execStartTime;
+          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 };
+        }
+
+        if (!transition.transitioned) {
+          // 在 EXPLORE/PRODUCE 阶段收到文本但未转阶段 — 可能是 AI 的中间分析
+          // 注入提交引导并继续循环，而非立即返回
+          if (phaseRouter.phase === 'EXPLORE' || phaseRouter.phase === 'PRODUCE') {
+            ctx.appendAssistantText(aiResult.text || '');
+            if (phaseRouter.phase === 'PRODUCE') {
+              ctx.appendUserNudge(
+                '你的分析很好。请继续调用 submit_candidate 提交你发现的知识候选，每个值得记录的模式/实践都应该提交。'
+              );
+              this.#logger.info('[ChatAgent] 📝 injected submit nudge (text in PRODUCE, not transitioning)');
+            }
+            continue;
+          }
+          // 非生产阶段的未转换文本 = 最终回答
+          const reply = this.#cleanFinalAnswer(aiResult.text || '');
+          const totalDuration = Date.now() - execStartTime;
+          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 };
+        }
+
+        // 其他阶段的文字回答 → 继续循环（PhaseRouter 已自动转换阶段）
+        ctx.appendAssistantText(aiResult.text || '');
+        continue;
+      }
+
+      // 用户对话: 文字回答即最终回答
+      const reply = this.#cleanFinalAnswer(aiResult.text || '');
+      const totalDuration = Date.now() - execStartTime;
+      this.#logger.info(`[ChatAgent] ✅ final answer — ${reply.length} chars, ${toolCalls.length} tool calls, ${totalDuration}ms`);
+      return { reply, toolCalls, hasContext: toolCalls.length > 0 };
+    }
+
+    // ── 循环退出: 产出 dimensionDigest 总结 ──
+    return this.#produceForcedSummary({
+      source, toolCalls, toolSchemas, ctx, phaseRouter, execStartTime,
+    });
+  }
+
+  /**
+   * 强制退出后的摘要生成 — 独立方法，避免主循环代码膨胀
+   * @private
+   */
+  async #produceForcedSummary({ source, toolCalls, toolSchemas, ctx, phaseRouter, execStartTime }) {
+    const iterations = phaseRouter?.totalIterations || 0;
+    this.#logger.info(`[ChatAgent] ⚠ producing forced summary (${iterations} iters, ${toolCalls.length} calls)`);
+
+    const candidateCount = toolCalls.filter(tc =>
+      tc.tool === 'submit_candidate' || tc.tool === 'submit_with_check'
+    ).length;
+
+    let finalReply;
+
+    // 如果熔断器已打开，跳过 AI 调用直接合成 digest（避免无用的失败 + 计数累积）
+    const isCircuitOpen = this.#aiProvider._circuitState === 'OPEN';
+    if (isCircuitOpen) {
+      this.#logger.warn(`[ChatAgent] circuit breaker is OPEN — skipping AI summary, using synthetic digest`);
+    }
+
+    try {
+      if (isCircuitOpen) throw new Error('circuit open — skip to synthetic digest');
+
+      const submitSummary = toolCalls
+        .filter(tc => tc.tool === 'submit_candidate' || tc.tool === 'submit_with_check')
+        .map((tc, i) => `${i + 1}. ${tc.params?.title || tc.params?.category || 'untitled'}`)
+        .join('\n');
+
+      const summaryPrompt = source === 'system'
+        ? `你已完成 ${iterations} 轮工具调用（共 ${toolCalls.length} 次），提交了 ${candidateCount} 个候选。
+${submitSummary ? `已提交候选:\n${submitSummary}\n` : ''}
+**必须**输出 dimensionDigest JSON（用 \`\`\`json 包裹）：
+\`\`\`json
+{
+  "dimensionDigest": {
+    "summary": "本维度分析总结",
+    "candidateCount": ${candidateCount},
+    "keyFindings": ["发现1", "发现2"],
+    "crossRefs": {},
+    "gaps": ["未覆盖方面"],
+    "remainingTasks": [
+      { "signal": "未处理信号名", "reason": "达到提交上限/时间限制", "priority": "high", "searchHints": ["搜索词"] }
+    ]
+  }
+}
+\`\`\`
+> remainingTasks: 列出本次未来得及处理的信号/主题。已全部覆盖则留空 \`[]\`。`
+        : `Completed ${iterations} iterations with ${toolCalls.length} tool calls. Please summarize.`;
+
+      // 用空 messages 避免累积上下文导致 400
+      const summaryResult = await this.#aiProvider.chatWithTools(
+        summaryPrompt,
+        {
+          messages: [],
+          toolSchemas,
+          toolChoice: 'none',
+          systemPrompt: '直接输出 dimensionDigest JSON 总结，不要调用工具。',
+          temperature: 0.3,
+          maxTokens: 8192,
+        },
+      );
+      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_candidate' || tc.tool === 'submit_with_check')
+        .map(tc => tc.params?.title || 'untitled');
+      finalReply = `\`\`\`json
+{
+  "dimensionDigest": {
+    "summary": "通过 ${toolCalls.length} 次工具调用分析了项目代码，提交了 ${candidateCount} 个候选。",
+    "candidateCount": ${candidateCount},
+    "keyFindings": ${JSON.stringify(titles.slice(0, 5))},
+    "crossRefs": {},
+    "gaps": ["AI 服务异常，部分分析未完成"]
+  }
+}
+\`\`\``;
+    }
+
+    const totalDuration = Date.now() - execStartTime;
+    this.#logger.info(`[ChatAgent] ✅ forced summary — ${finalReply.length} chars, ${totalDuration}ms total`);
+    return { reply: finalReply, toolCalls, hasContext: toolCalls.length > 0 };
+  }
+
+  // ─── Text Parsing ReAct 循环 (legacy) ─────────────────
+
+  /**
+   * 文本解析 ReAct 循环 — 传统模式
+   * 适用于不支持原生函数调用的 Provider (DeepSeek, OpenAI 兼容等)
+   * AI 输出文本 → #parseActions() 正则解析 → 执行工具 → 循环
+   */
+  async #executeWithTextParsing(prompt, { effectiveHistory, conversationId, source, execStartTime }) {
     const toolSchemas = this.#toolRegistry.getToolSchemas();
     const systemPrompt = this.#buildSystemPrompt(toolSchemas);
 
-    // 首次 LLM 调用
     const messages = [
-      ...history,
+      ...effectiveHistory,
       { role: 'user', content: prompt },
     ];
 
     const toolCalls = [];
     let iterations = 0;
     let currentPrompt = prompt;
+    let consecutiveAiErrors = 0;
+    const maxIter = source === 'system' ? MAX_ITERATIONS_SYSTEM : MAX_ITERATIONS;
 
-    while (iterations < MAX_ITERATIONS) {
+    while (iterations < maxIter) {
       iterations++;
+      const iterStartTime = Date.now();
 
-      const response = await this.#aiProvider.chat(currentPrompt, {
-        history: messages.slice(0, -1), // 不含最新 user prompt
-        systemPrompt,
-      });
+      let response;
+      try {
+        this.#logger.info(`[ChatAgent] 🔄 text iteration ${iterations}/${maxIter} — calling AI (${messages.length} messages)`);
+        response = await this.#aiProvider.chat(currentPrompt, {
+          history: messages.slice(0, -1),
+          systemPrompt,
+        });
+        const aiDuration = Date.now() - iterStartTime;
+        const responsePreview = (response || '').substring(0, 120).replace(/\n/g, '↵');
+        this.#logger.info(`[ChatAgent] ✓ AI responded in ${aiDuration}ms (${(response || '').length} chars) — "${responsePreview}…"`);
+        consecutiveAiErrors = 0;
+      } catch (aiErr) {
+        consecutiveAiErrors++;
+        this.#logger.warn(`[ChatAgent] AI call failed (attempt ${consecutiveAiErrors}): ${aiErr.message}`);
+
+        // 熔断器已打开 → 立即返回
+        if (aiErr.code === 'CIRCUIT_OPEN') {
+          return {
+            reply: `抱歉，AI 服务暂时不可用（${aiErr.message}）。请稍后重试，或检查 API 配置。`,
+            toolCalls,
+            hasContext: toolCalls.length > 0,
+          };
+        }
 
-      // 尝试解析 Action 块
-      const action = this.#parseAction(response);
+        if (consecutiveAiErrors >= 2) {
+          return {
+            reply: `抱歉，AI 服务暂时不可用（${aiErr.message}）。请稍后重试，或检查 API 配置。`,
+            toolCalls,
+            hasContext: toolCalls.length > 0,
+          };
+        }
+        await new Promise(r => setTimeout(r, 2000));
+        continue;
+      }
+
+      const actions = this.#parseActions(response);
+
+      if (!actions) {
+        // ── 系统调用自动续跑 ──
+        const hasSubmits = toolCalls.some(tc => tc.tool === 'submit_candidate' || tc.tool === 'submit_with_check');
+        if (source === 'system' && iterations < maxIter && !hasSubmits) {
+          if (this.#looksLikeIncompleteStep(response)) {
+            this.#logger.info(`[ChatAgent] 🔄 detected planning-only response at iteration ${iterations}, injecting continuation prompt`);
+            messages.push({ role: 'assistant', content: response });
+            currentPrompt = SYSTEM_CONTINUATION_PROMPT;
+            messages.push({ role: 'user', content: currentPrompt });
+            continue;
+          }
+          if (toolCalls.length > 0) {
+            this.#logger.info(`[ChatAgent] 🔄 detected analysis-without-submission at iteration ${iterations} (${toolCalls.length} tool calls, 0 submits), injecting submission prompt`);
+            messages.push({ role: 'assistant', content: response });
+            currentPrompt = SYSTEM_SUBMIT_PROMPT;
+            messages.push({ role: 'user', content: currentPrompt });
+            continue;
+          }
+        }
 
-      if (!action) {
-        // 没有 Action → 最终回答
         const reply = this.#cleanFinalAnswer(response);
-        this.#extractMemory(prompt, reply);
+        const totalDuration = Date.now() - execStartTime;
+        this.#logger.info(`[ChatAgent] ✅ text final answer — ${reply.length} chars, ${iterations} iterations, ${toolCalls.length} tool calls, ${totalDuration}ms total`);
+
         return { reply, toolCalls, hasContext: toolCalls.length > 0 };
       }
 
       // 执行工具
-      this.#logger.info('ChatAgent tool call', {
-        tool: action.tool,
-        iteration: iterations,
-      });
+      const isBatch = actions.length > 1;
+      if (isBatch) {
+        this.#logger.info(`[ChatAgent] 📦 batch tool call: ${actions.length} actions [${actions.map(a => a.tool).join(', ')}]`, { iteration: iterations });
+      }
 
-      const toolResult = await this.#toolRegistry.execute(
-        action.tool,
-        action.params,
-        this.#getToolContext(),
-      );
+      const batchResults = [];
+      for (const action of actions) {
+        this.#logger.info(`[ChatAgent] 🔧 tool call: ${action.tool}(${JSON.stringify(action.params).substring(0, 100)})`, {
+          iteration: iterations,
+          batch: isBatch,
+        });
 
-      toolCalls.push({
-        tool: action.tool,
-        params: action.params,
-        result: this.#summarizeResult(toolResult),
-      });
+        let toolResult;
+        const toolStartTime = Date.now();
+        try {
+          toolResult = await this.#toolRegistry.execute(
+            action.tool,
+            action.params,
+            this.#getToolContext({ _sessionToolCalls: toolCalls }),
+          );
+          const toolDuration = Date.now() - toolStartTime;
+          const resultSize = typeof toolResult === 'string' ? toolResult.length : JSON.stringify(toolResult).length;
+          this.#logger.info(`[ChatAgent] 🔧 tool done: ${action.tool} → ${resultSize} chars in ${toolDuration}ms`);
+        } catch (toolErr) {
+          this.#logger.warn(`[ChatAgent] 🔧 tool FAILED: ${action.tool} — ${toolErr.message} (${Date.now() - toolStartTime}ms)`);
+          toolResult = `Error: tool "${action.tool}" failed — ${toolErr.message}. Try a different approach or provide your answer based on available information.`;
+        }
+
+        const summarized = this.#summarizeResult(toolResult);
+        toolCalls.push({
+          tool: action.tool,
+          params: action.params,
+          result: summarized,
+        });
+        batchResults.push({ tool: action.tool, result: toolResult });
+      }
 
       // 将工具结果注入为下一轮 prompt
-      const observation = typeof toolResult === 'string'
-        ? toolResult
-        : JSON.stringify(toolResult, null, 2);
+      let observation;
+      if (batchResults.length === 1) {
+        const r = batchResults[0];
+        const obsText = typeof r.result === 'string' ? r.result : JSON.stringify(r.result, null, 2);
+        observation = `Observation from tool "${r.tool}":\n${this.#truncate(obsText, 4000)}`;
+      } else {
+        observation = `Batch observation (${batchResults.length} tools):\n` +
+          batchResults.map((r, i) => {
+            const obsText = typeof r.result === 'string' ? r.result : JSON.stringify(r.result, null, 2);
+            return `[${i + 1}] ${r.tool}: ${this.#truncate(obsText, 2000)}`;
+          }).join('\n\n');
+      }
 
-      currentPrompt = `Observation from tool "${action.tool}":\n${this.#truncate(observation, 4000)}\n\nBased on the above observation, continue reasoning about the user's question: "${prompt}".\nIf you have enough information, provide your final answer directly (without Action block). Otherwise, call another tool.`;
+      currentPrompt = `${observation}\n\nBased on the above observation, continue reasoning about the user's question: "${prompt}".\nIf you have enough information, provide your final answer directly (without Action block). Otherwise, call another tool.`;
 
-      // 追加到消息历史中以保持上下文
       messages.push({ role: 'assistant', content: response });
       messages.push({ role: 'user', content: currentPrompt });
+
+      this.#condenseIfNeeded(messages);
     }
 
-    // 达到最大迭代次数，要求 LLM 总结
+    // 达到最大迭代次数
     const summaryPrompt = `You have used ${iterations} tool calls. Summarize what you found and answer the user's original question: "${prompt}"`;
-    const finalResponse = await this.#aiProvider.chat(summaryPrompt, {
-      history: messages,
-      systemPrompt: '直接回答用户问题，不要再调用工具。',
-    });
+    let finalResponse;
+    try {
+      finalResponse = await this.#aiProvider.chat(summaryPrompt, {
+        history: messages,
+        systemPrompt: '直接回答用户问题，不要再调用工具。',
+      });
+    } catch (err) {
+      this.#logger.warn(`[ChatAgent] Final summary AI call failed: ${err.message}`);
+      finalResponse = `根据 ${toolCalls.length} 次工具调用的结果，以下是收集到的信息：\n\n` +
+        toolCalls.map(tc => `• ${tc.tool}: ${typeof tc.result === 'string' ? tc.result.substring(0, 200) : JSON.stringify(tc.result).substring(0, 200)}`).join('\n') +
+        '\n\n（注：AI 总结服务暂时不可用，上述为原始工具输出摘要）';
+    }
 
     const finalReply = this.#cleanFinalAnswer(finalResponse);
-    this.#extractMemory(prompt, finalReply);
-
-    return {
-      reply: finalReply,
-      toolCalls,
-      hasContext: toolCalls.length > 0,
-    };
+    return { reply: finalReply, toolCalls, hasContext: toolCalls.length > 0 };
   }
 
   /**
@@ -177,6 +868,40 @@ export class ChatAgent {
     return this.#toolRegistry.execute(toolName, params, this.#getToolContext());
   }
 
+  // ─── 对话管理 API ──────────────────────────────────────
+
+  /**
+   * 创建新对话（用于 Dashboard 前端）
+   * @param {object} [opts]
+   * @param {'user'|'system'} [opts.category='user']
+   * @param {string} [opts.title]
+   * @returns {string} conversationId
+   */
+  createConversation({ category = 'user', title = '' } = {}) {
+    if (!this.#conversations) return null;
+    return this.#conversations.create({ category, title });
+  }
+
+  /**
+   * 获取对话列表
+   * @param {object} [opts]
+   * @param {'user'|'system'} [opts.category]
+   * @param {number} [opts.limit=20]
+   * @returns {Array}
+   */
+  getConversations({ category, limit = 20 } = {}) {
+    if (!this.#conversations) return [];
+    return this.#conversations.list({ category, limit });
+  }
+
+  /**
+   * 获取 ConversationStore 实例（供外部使用，如 HTTP 路由）
+   * @returns {ConversationStore|null}
+   */
+  getConversationStore() {
+    return this.#conversations;
+  }
+
   /**
    * 预定义任务流
    * 将常见多步骤操作封装为一个任务名。
@@ -481,20 +1206,16 @@ ${code.substring(0, 3000)}
   /**
    * 注册内置 DAG 管线
    *
-   * 设计原则: 项目内 AI 都走 ChatAgent + tool，DAG 编排 AI 步骤。
-   * bootstrapKnowledge() 只做启发式 Phase 1-5，不调 AI。
-   * AI 增强步骤由 ChatAgent DAG 编排:
-   *
-   * bootstrap_full_pipeline:
-   *   Phase 0: bootstrap（SPM 扫描 + Skill 增强维度 + 候选创建，纯启发式）
-   *   Phase 1: enrich（AI 结构补齐，依赖 bootstrap 产出的候选 ID）
-   *   Phase 1: loadSkill（并行加载语言参考 Skill，用于润色提示）
-   *   Phase 2: refine（AI 内容润色，依赖 enrich + loadSkill）
+   * v6 变更:
+   *   - 移除旧的 4 步 DAG (bootstrap → enrich → loadSkill → refine)
+   *   - 冷启动 AI 增强现在通过 orchestrator.js 中的 ChatAgent per-dimension production 完成
+   *   - 保留简化版 bootstrap_full_pipeline: 只做 Phase 1-4 启发式
+   *     (Phase 5 ChatAgent 生产由 orchestrator.js 管理,不再走 DAG 编排)
    */
   #registerBuiltinPipelines() {
-    const hasAI = !!this.#aiProvider;
-
-    // ── bootstrap_full_pipeline (DAG) ──────────────────────
+    // ── bootstrap_full_pipeline (v6 简化版) ──────────────────
+    // 只做启发式 Phase 1-5.5 (含 ChatAgent per-dimension production)
+    // 不再需要 enrich/refine 后置步骤
     this.registerPipeline(new TaskPipeline('bootstrap_full_pipeline', [
       {
         name: 'bootstrap',
@@ -506,69 +1227,6 @@ ${code.substring(0, 3000)}
           loadSkills: true,
         },
       },
-      {
-        name: 'enrich',
-        tool: 'enrich_candidate',
-        dependsOn: ['bootstrap'],
-        params: {
-          candidateIds: (ctx) => {
-            const bc = ctx._results.bootstrap?.bootstrapCandidates;
-            return bc?.ids || bc?.candidateIds || [];
-          },
-        },
-        when: (ctx) => {
-          const ids = ctx._results.bootstrap?.bootstrapCandidates?.ids
-            || ctx._results.bootstrap?.bootstrapCandidates?.candidateIds;
-          return Array.isArray(ids) && ids.length > 0;
-        },
-        errorStrategy: 'continue',
-      },
-      {
-        name: 'loadSkill',
-        tool: 'load_skill',
-        dependsOn: ['bootstrap'],
-        params: {
-          skillName: (ctx) => {
-            const loaded = ctx._results.bootstrap?.skillsLoaded || [];
-            return loaded.find(s => s.startsWith('autosnippet-reference-')) || 'autosnippet-coldstart';
-          },
-        },
-        when: (ctx) => {
-          const autoRefine = ctx._inputs.autoRefine;
-          return autoRefine !== false && hasAI;
-        },
-        errorStrategy: 'continue',
-      },
-      {
-        name: 'refine',
-        tool: 'refine_bootstrap_candidates',
-        dependsOn: ['enrich', 'loadSkill'],
-        params: {
-          userPrompt: (ctx) => {
-            const parts = [];
-
-            // Skill 业界标准参考
-            const skillContent = ctx._results.loadSkill?.content;
-            if (skillContent) {
-              parts.push(`请参考以下业界最佳实践标准润色候选，确保 summary 精准、tags 丰富、confidence 合理:\n${skillContent.substring(0, 3000)}`);
-            }
-
-            // AST 代码结构分析 — 帮助 AI 理解继承体系和设计模式
-            const astCtx = ctx._results.bootstrap?.astContext;
-            if (astCtx) {
-              parts.push(`\n# 项目代码结构分析 (Tree-sitter AST)\n以下是项目的 AST 分析结果，请在润色时参考类继承关系、设计模式和代码质量指标:\n${astCtx.substring(0, 2000)}`);
-            }
-
-            return parts.length > 0 ? parts.join('\n\n') : ctx._inputs.refinePrompt;
-          },
-        },
-        when: (ctx) => {
-          const autoRefine = ctx._inputs.autoRefine;
-          const created = ctx._results.bootstrap?.bootstrapCandidates?.created || 0;
-          return autoRefine !== false && created > 0 && hasAI;
-        },
-        errorStrategy: 'continue',
-      },
     ]));
   }
 
@@ -576,14 +1234,41 @@ ${code.substring(0, 3000)}
 
   /**
    * 构建系统提示词（含工具描述 + Skills 感知）
+   *
+   * 工具注入策略（Lazy Tool Schema — 类似 Cline .clinerules 按需加载）:
+   *   - 首屏只注入工具名 + 一行描述（compact list）
+   *   - 系统提示词中告知 LLM 可通过 get_tool_details 获取完整参数
+   *   - 少量核心工具（search_project_code, read_project_file, search_knowledge,
+   *     submit_with_check, analyze_code, bootstrap_knowledge, load_skill,
+   *     suggest_skills）直接展开完整 schema
+   *
+   * 效果: 44 个工具的 prompt 从 ~5000 tokens 降到 ~1500 tokens
    */
   #buildSystemPrompt(toolSchemas) {
-    const toolDescriptions = toolSchemas.map(t => {
-      const paramsDesc = Object.entries(t.parameters.properties || {})
-        .map(([k, v]) => `    - ${k} (${v.type}): ${v.description || ''}`)
-        .join('\n');
-      return `- **${t.name}**: ${t.description}\n  Parameters:\n${paramsDesc || '    (none)'}`;
-    }).join('\n\n');
+    // 核心工具 — 使用最频繁，直接展示完整 schema
+    const coreTools = new Set([
+      'search_project_code', 'read_project_file',
+      'search_knowledge', 'submit_candidate', 'submit_with_check', 'analyze_code',
+      'bootstrap_knowledge', 'load_skill', 'suggest_skills',
+      'create_skill', 'knowledge_overview', 'get_tool_details',
+      'plan_task', 'review_my_output',
+    ]);
+
+    const compactDescriptions = [];
+    const detailedDescriptions = [];
+
+    for (const t of toolSchemas) {
+      if (coreTools.has(t.name)) {
+        const paramsDesc = Object.entries(t.parameters.properties || {})
+          .map(([k, v]) => `    - ${k} (${v.type}): ${v.description || ''}`)
+          .join('\n');
+        detailedDescriptions.push(`- **${t.name}**: ${t.description}\n  Parameters:\n${paramsDesc || '    (none)'}`);
+      } else {
+        compactDescriptions.push(`- ${t.name}: ${t.description}`);
+      }
+    }
+
+    const toolDescriptions = `### 核心工具（完整参数）\n\n${detailedDescriptions.join('\n\n')}\n\n### 其他工具（调用 get_tool_details 获取参数详情）\n\n${compactDescriptions.join('\n')}`;
 
     // Skills 清单 — 让 LLM 知道有哪些领域知识可加载
     const skillList = this.#listAvailableSkills();
@@ -602,7 +1287,7 @@ ${code.substring(0, 3000)}
     return `${soulSection}
 你是 AutoSnippet 项目的统一 AI 中心。项目内所有 AI 推理和分析都通过你执行。
 你拥有 ${toolSchemas.length} 个工具覆盖知识库管理全链路：搜索、提交、审核、质量评估、Guard 检查、知识图谱、冷启动等。
-${this.#projectBriefingCache}${this.#memory?.toPromptSection() || ''}
+${this.#projectBriefingCache}${this.#memory?.toPromptSection({ source: this.#currentSource === 'system' ? undefined : 'user' }) || ''}
 可用工具:
 
 ${toolDescriptions}
@@ -615,7 +1300,15 @@ ${skillSection}
 {"tool": "tool_name", "params": {"key": "value"}}
 \`\`\`
 
-3. 每次只调用一个工具。
+3. 当需要连续调用多个**同类工具**（如批量提交候选）时，可使用批量格式:
+
+\`\`\`batch_actions
+[
+  {"tool": "submit_candidate", "params": {"title": "...", "code": "..."}},
+  {"tool": "submit_candidate", "params": {"title": "...", "code": "..."}}
+]
+\`\`\`
+
 4. 如果不需要工具就能回答，直接回答，不要输出 action 块。
 5. 回答时使用用户的语言（中文/英文）。
 6. 回答要简洁、有依据（引用工具返回的数据）。
@@ -627,68 +1320,379 @@ ${skillSection}
    - 不确定做什么 → load_skill("autosnippet-intent")
 8. 你可以组合多个工具完成复杂任务（如：查重 → 提交 → 质量评分 → 知识图谱关联）。
 9. 当工具返回 _meta.confidence = "none" 时，告知用户无匹配并建议下一步，不要凭空编造。当 _meta.confidence = "low" 时，明确标注结果不确定性。
-10. 优先使用组合工具（analyze_code, knowledge_overview, submit_with_check）减少调用轮次。`;
+10. 优先使用组合工具（analyze_code, knowledge_overview, submit_with_check）减少调用轮次。
+11. 当你发现用户在重复解释编码规范、操作约定或项目特有模式时，主动调用 suggest_skills 检查是否需要创建 Skill。如果有高优先级建议，向用户说明并在确认后调用 create_skill 创建。
+12. 当对话中出现值得长期记忆的信息（用户偏好、项目规范、关键决策、技术栈事实），在回复中嵌入记忆标签：\`[MEMORY:type] 内容 [/MEMORY]\`，type 可选 preference/decision/context。这些标签会被自动提取并持久化，不会显示给用户。`;
   }
 
   /**
-   * 从 LLM 响应中解析 Action 块
-   * 格式: ```action\n{"tool":"...", "params":{...}}\n```
+   * 构建原生函数调用模式的系统提示词
+   *
+   * 设计原则:
+   *   - 精简: bootstrap 模式不注入 SOUL.md 人格（节省 ~500 token）
+   *   - 分层: 静态指令放 systemPrompt，动态上下文放 user prompt
+   *   - 控制通过 PhaseRouter 状态机实现，不通过追加 user 消息
+   *   - 工具描述已通过 functionDeclarations 传递，不重复
+   */
+  #buildNativeToolSystemPrompt(budget = DEFAULT_BUDGET) {
+    // 用户对话模式: 完整提示词（含 SOUL、Memory、项目概况）
+    if (this.#currentSource !== 'system') {
+      let soulSection = '';
+      try {
+        if (fs.existsSync(SOUL_PATH)) {
+          soulSection = '\n' + fs.readFileSync(SOUL_PATH, 'utf-8').trim() + '\n';
+        }
+      } catch { /* SOUL.md not available */ }
+
+      return `${soulSection}
+你是 AutoSnippet 项目的统一 AI 中心。项目内所有 AI 推理和分析都通过你执行。
+${this.#projectBriefingCache}${this.#memory?.toPromptSection({ source: 'user' }) || ''}
+
+## 使用规则
+1. 当需要查询数据时，直接调用相应工具。
+2. 工具参数严格按照工具声明中的 schema 传递。
+3. 对于代码分析任务，先 search_project_code 搜索，再 read_project_file 读取。
+4. 回答时使用用户的语言（中文/英文）。
+5. 当工具返回错误时，尝试不同参数或方法。`;
+    }
+
+    // Bootstrap 系统模式: LLM 以领域大脑的能力处理任务
+    return `你以「领域大脑」的能力来处理任务 — 你对软件工程领域拥有深厚的专家知识。
+你将分析一个真实项目，自主发现其中有价值的代码知识。
+${this.#projectBriefingCache}
+
+## 你的能力定位
+你具备深度技术洞察力，能够理解代码背后的设计意图。
+你知道什么知识对开发团队最有价值 — 不是显而易见的样板代码，
+而是体现项目独有设计决策、架构模式和工程智慧的知识。
+
+## 你的工作方式
+1. **全局感知** → list_project_structure 了解项目结构
+2. **定向探索** → get_file_summary 快速了解文件角色
+3. **深入研读** → search_project_code / read_project_file 获取真实代码
+4. **语义发现** → semantic_search_code 在知识库查找相关知识
+5. **知识产出** → submit_candidate 提交有价值的发现
+
+## 「项目特写」= 基本用法 + 项目特征融合
+submit_candidate 的 code 字段必须是「项目特写」— 将技术的基本用法与本项目的特征融合为一体:
+1. **项目选择了什么**: 采用了哪种写法/模式/约定
+2. **为什么这样选**: 统计数据（N 个文件、占比 M%）
+3. **项目禁止什么**: 被放弃的写法、反模式、显式禁用标记
+4. **新代码怎么写**: 可直接复制使用的代码模板
+
+## 核心原则
+- 代码必须真实，来自工具返回，不可编造
+- 引用具体类名、方法名、数字，禁止「本模块」「该文件」等泛化描述
+- 质量优先于数量，证据不足宁可不提交
+- 高效利用步数 (≤${budget.maxIterations} 轮)`;
+  }
+
+  /**
+   * 从 LLM 响应中解析 Action 块（单条）
+   *
+   * 兼容多家 AI 服务商的工具调用格式：
+   *   1. ```action {"tool":"...", "params":{...}} ```          — 标准格式
+   *   2. ```tool_code tool_name(key="value") ```               — Gemini 常用
+   *   3. ```python / ```javascript 围栏内函数调用               — 各家偶发
+   *   4. Action: tool_name / Action Input: {...}                — ReAct (GPT/DeepSeek)
+   *   5. <tool_call>{"name":"...", "arguments":{...}}</tool_call>  — 训练遗留 XML
+   *   6. ```json {"name":"...", "arguments":{...}} ```          — GPT function_call 文本化
+   *   7. {"tool":"...", "params":{...}} 裸 JSON                — 通用降级
+   *   8. response 末尾裸函数调用 tool_name(key="value")         — 通用降级
    */
   #parseAction(response) {
     if (!response) return null;
 
-    // 尝试匹配 ```action ... ``` 代码块
+    // ── 1. 标准 ```action {...} ``` ──
     const blockMatch = response.match(/```action\s*\n?([\s\S]*?)```/);
     if (blockMatch) {
-      try {
-        const parsed = JSON.parse(blockMatch[1].trim());
-        if (parsed.tool && this.#toolRegistry.has(parsed.tool)) {
-          return { tool: parsed.tool, params: parsed.params || {} };
+      const parsed = this.#tryParseToolJson(blockMatch[1].trim());
+      if (parsed) return parsed;
+    }
+
+    // ── 2. ```tool_code fn(k=v) ``` (Gemini 常用) ──
+    const toolCodeMatch = response.match(/```tool_code\s*\n?([\s\S]*?)```/);
+    if (toolCodeMatch) {
+      const parsed = this.#parseToolCodeBlock(toolCodeMatch[1].trim());
+      if (parsed) return parsed;
+    }
+
+    // ── 3. ```python / ```javascript / ```js 围栏内函数调用 ──
+    const langFenceMatch = response.match(/```(?:python|javascript|js|typescript|ts)\s*\n?([\s\S]*?)```/);
+    if (langFenceMatch) {
+      const inner = langFenceMatch[1].trim();
+      const parsed = this.#parseToolCodeBlock(inner);
+      if (parsed) return parsed;
+      // JS 对象字面量: tool_name({key: "value"})
+      const jsObjMatch = inner.match(/^(\w+)\(\s*(\{[\s\S]*\})\s*\)$/s);
+      if (jsObjMatch) {
+        const toolName = jsObjMatch[1];
+        if (this.#toolRegistry.has(toolName)) {
+          try {
+            let params;
+            try { params = JSON.parse(jsObjMatch[2]); } catch {
+              const normalized = jsObjMatch[2]
+                .replace(/,\s*([}\]])/g, '$1')
+                .replace(/'/g, '"')
+                .replace(/([{,]\s*)(\w+)\s*:/g, '$1"$2":');
+              params = JSON.parse(normalized);
+            }
+            return { tool: toolName, params };
+          } catch { /* parse failed */ }
         }
-      } catch { /* parse failed */ }
+      }
+    }
+
+    // ── 4. ReAct: Action: tool_name\nAction Input: {...} (GPT/DeepSeek) ──
+    const reactMatch = response.match(/Action\s*:\s*(\w+)\s*\n+Action\s*Input\s*:\s*([\s\S]*?)(?:\n\s*(?:Thought|Observation|$))/i);
+    if (reactMatch) {
+      const toolName = reactMatch[1];
+      if (this.#toolRegistry.has(toolName)) {
+        try {
+          return { tool: toolName, params: JSON.parse(reactMatch[2].trim()) };
+        } catch {
+          const parsed = this.#parseToolCodeBlock(`${toolName}(${reactMatch[2].trim()})`);
+          if (parsed) return parsed;
+        }
+      }
+    }
+    // Action/Action Input 在末尾（无后续 Thought）
+    const reactEndMatch = response.match(/Action\s*:\s*(\w+)\s*\n+Action\s*Input\s*:\s*(\{[\s\S]*\})\s*$/i);
+    if (reactEndMatch) {
+      const toolName = reactEndMatch[1];
+      if (this.#toolRegistry.has(toolName)) {
+        try { return { tool: toolName, params: JSON.parse(reactEndMatch[2].trim()) }; } catch { /* ignore */ }
+      }
+    }
+
+    // ── 5. XML: <tool_call>...</tool_call> / <function_call>...</function_call> ──
+    const xmlMatch = response.match(/<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/);
+    if (xmlMatch) {
+      const parsed = this.#tryParseToolJson(xmlMatch[1].trim());
+      if (parsed) return parsed;
+    }
+    const fcMatch = response.match(/<function_call>\s*([\s\S]*?)\s*<\/function_call>/);
+    if (fcMatch) {
+      const parsed = this.#tryParseToolJson(fcMatch[1].trim());
+      if (parsed) return parsed;
     }
 
-    // 降级: 尝试匹配 JSON-like 结构 {"tool": "...", "params": {...}}
-    const jsonMatch = response.match(/\{\s*"tool"\s*:\s*"([^"]+)"\s*,\s*"params"\s*:\s*(\{[\s\S]*?\})\s*\}/);
+    // ── 6. ```json {...} ``` 内的 function_call 格式 ──
+    const jsonFenceMatch = response.match(/```json\s*\n?([\s\S]*?)```/);
+    if (jsonFenceMatch) {
+      const parsed = this.#tryParseToolJson(jsonFenceMatch[1].trim());
+      if (parsed) return parsed;
+    }
+
+    // ── 7. 裸 JSON: {"tool":"..."} 或 {"name":"..."} ──
+    const jsonMatch = response.match(/\{\s*"(?:tool|name|function)"\s*:\s*"([^"]+)"[\s\S]*?\}/);
     if (jsonMatch) {
+      const parsed = this.#tryParseToolJson(jsonMatch[0]);
+      if (parsed) return parsed;
+    }
+
+    // ── 8. 末尾裸函数调用: tool_name(key="value") ──
+    const trailingFnMatch = response.match(/\b(\w+)\(([^)]*)\)\s*$/);
+    if (trailingFnMatch) {
+      const parsed = this.#parseToolCodeBlock(`${trailingFnMatch[1]}(${trailingFnMatch[2]})`);
+      if (parsed) return parsed;
+    }
+
+    return null;
+  }
+
+  /**
+   * 尝试从 JSON 文本解析工具调用
+   * 兼容多种 key 命名:
+   *   - {"tool": "x", "params": {...}}         — 标准格式
+   *   - {"name": "x", "arguments": {...}}      — OpenAI function_call
+   *   - {"function": "x", "parameters": {...}} — 变体
+   *   - {"tool": "x", "input": {...}}          — Claude 变体
+   */
+  #tryParseToolJson(text) {
+    if (!text) return null;
+    try {
+      const obj = JSON.parse(text);
+      const toolName = obj.tool || obj.name || obj.function;
+      if (!toolName || !this.#toolRegistry.has(toolName)) return null;
+      const params = obj.params || obj.arguments || obj.parameters || obj.input || {};
+      return { tool: toolName, params };
+    } catch { return null; }
+  }
+
+  /**
+   * 解析 tool_code 函数调用格式
+   * 支持三种参数格式:
+   *   1. key=value:  search_project_code(query="xxx", language="objc")
+   *   2. JSON 对象:  read_project_file({"file_path": "Code/X.m"})
+   *   3. 单字符串:   read_project_file("Code/X.m")
+   */
+  #parseToolCodeBlock(text) {
+    if (!text) return null;
+    const fnMatch = text.match(/^(\w+)\((.*)\)$/s);
+    if (!fnMatch) return null;
+
+    const toolName = fnMatch[1];
+    if (!this.#toolRegistry.has(toolName)) return null;
+
+    const argsStr = fnMatch[2].trim();
+    if (!argsStr) return { tool: toolName, params: {} };
+
+    // 尝试 1: key=value 格式 (Python 风格)
+    const params = {};
+    const argRegex = /(\w+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^,\s]+))/g;
+    let m;
+    while ((m = argRegex.exec(argsStr)) !== null) {
+      params[m[1]] = m[2] ?? m[3] ?? m[4];
+    }
+    if (Object.keys(params).length > 0) return { tool: toolName, params };
+
+    // 尝试 2: JSON 对象参数 — read_project_file({"file_path": "..."})
+    if (argsStr.startsWith('{')) {
       try {
-        const tool = jsonMatch[1];
-        const params = JSON.parse(jsonMatch[2]);
-        if (this.#toolRegistry.has(tool)) {
-          return { tool, params };
+        const jsonParams = JSON.parse(argsStr);
+        if (typeof jsonParams === 'object' && jsonParams !== null) {
+          return { tool: toolName, params: jsonParams };
         }
-      } catch { /* parse failed */ }
+      } catch { /* not valid JSON, fall through */ }
     }
 
-    return null;
+    // 尝试 3: 单字符串参数 — read_project_file("Code/X.m") → 映射到首个 required 参数
+    const strMatch = argsStr.match(/^["'](.+?)["']$/);
+    if (strMatch) {
+      const toolDef = this.#toolRegistry.getToolSchemas().find(t => t.name === toolName);
+      const firstRequired = toolDef?.parameters?.required?.[0];
+      if (firstRequired) {
+        return { tool: toolName, params: { [firstRequired]: strMatch[1] } };
+      }
+    }
+
+    return { tool: toolName, params };
+  }
+
+  /**
+   * 从 LLM 响应中解析 Action 块（支持批量）
+   *
+   * 优先匹配:
+   *   ```batch_actions [...]```
+   * 降级匹配:
+   *   - 多个 <tool_call> XML 标签
+   *   - 多个 ReAct Action 块
+   *   - 单条 #parseAction()
+   *
+   * @returns {Array<{tool:string, params:object}>|null}
+   */
+  #parseActions(response) {
+    if (!response) return null;
+
+    // 1. 优先尝试 ```batch_actions``` 块
+    const batchMatch = response.match(/```batch_actions\s*\n?([\s\S]*?)```/);
+    if (batchMatch) {
+      try {
+        const arr = JSON.parse(batchMatch[1].trim());
+        if (Array.isArray(arr) && arr.length > 0) {
+          const valid = arr.filter(a => a.tool && this.#toolRegistry.has(a.tool));
+          if (valid.length > 0) {
+            return valid.map(a => ({ tool: a.tool, params: a.params || {} }));
+          }
+        }
+      } catch { /* batch parse failed, fall through */ }
+    }
+
+    // 2. 多个 <tool_call> XML 块 (DeepSeek/Qwen)
+    const xmlMatches = [...response.matchAll(/<tool_call>\s*([\s\S]*?)\s*<\/tool_call>/g)];
+    if (xmlMatches.length > 1) {
+      const results = xmlMatches
+        .map(m => this.#tryParseToolJson(m[1].trim()))
+        .filter(Boolean);
+      if (results.length > 0) return results;
+    }
+
+    // 3. 多个 ReAct Action 块
+    const reactMatches = [...response.matchAll(/Action\s*:\s*(\w+)\s*\n+Action\s*Input\s*:\s*(\{[\s\S]*?\})/gi)];
+    if (reactMatches.length > 1) {
+      const results = reactMatches
+        .map(m => {
+          const toolName = m[1];
+          if (!this.#toolRegistry.has(toolName)) return null;
+          try { return { tool: toolName, params: JSON.parse(m[2].trim()) }; } catch { return null; }
+        })
+        .filter(Boolean);
+      if (results.length > 0) return results;
+    }
+
+    // 4. 降级到单 action
+    const single = this.#parseAction(response);
+    return single ? [single] : null;
   }
 
   /**
-   * 清理最终回答（去除 Thought/preamble）
+   * 清理最终回答（去除 Thought/preamble + MEMORY 标签）
    */
   #cleanFinalAnswer(response) {
     if (!response) return '';
-    // 去除 "Final Answer:" 前缀
     return response
       .replace(/^(Final Answer|最终回答|Answer)\s*[:：]\s*/i, '')
+      .replace(/\[MEMORY:\w+\]\s*[\s\S]*?\s*\[\/MEMORY\]/g, '')
+      .replace(/\n{3,}/g, '\n\n')
       .trim();
   }
 
+  /**
+   * 检测 AI 回复是否为「未完成的中间步骤」— 输出分析/计划文本但未实际调用工具
+   *
+   * Gemini 常见行为: 收到 production prompt 后先输出一段纯文本的
+   * "执行计划" 或 "信号审视" 而不包含任何 action/tool_code block,
+   * 导致 #parseActions() 返回 null,被误判为 final answer。
+   *
+   * 检测策略: 回复包含计划/分析关键词 + 不包含 dimensionDigest JSON
+   */
+  #looksLikeIncompleteStep(response) {
+    if (!response || response.length < 100) return false;
+
+    // 如果已包含 dimensionDigest → 是真正的最终回答
+    if (response.includes('"dimensionDigest"') || response.includes('dimensionDigest')) return false;
+
+    // 计划/分析性关键词 (中文 Gemini 常用)
+    const planningPatterns = [
+      /制定执行计划/,
+      /信号质量预判/,
+      /执行计划/,
+      /我将按照/,
+      /开始分析/,
+      /我将分析/,
+      /接下来我将/,
+      /我来分析/,
+      /首先[，,]?\s*我/,
+      /\*\*0\.\s*制定/,
+      /\*\*Signal\s+\d+/,                     // 信号列表分析
+      /质量[：:]\s*(高|中|低)/,                // 信号质量评估
+      /保留[。；]|丢弃[。；]|跳过[。；]/,       // 信号去留判断
+    ];
+
+    const matchCount = planningPatterns.filter(p => p.test(response)).length;
+    return matchCount >= 2; // 至少匹配 2 个模式才认为是计划性回复
+  }
+
   /**
    * 获取工具执行上下文
+   * @param {object} [extras] — 额外注入到上下文的字段（如 _sessionToolCalls）
    */
-  #getToolContext() {
+  #getToolContext(extras) {
     return {
       container: this.#container,
       aiProvider: this.#aiProvider,
       projectRoot: this.#container?.singletons?._projectRoot || process.cwd(),
       logger: this.#logger,
+      source: this.#currentSource,
+      fileCache: this.#fileCache || null,
+      ...extras,
     };
   }
 
   /**
    * 列出可用的 Skills 及其摘要（用于系统提示词）
-   * 加载顺序: 内置 skills/ → 项目级 .autosnippet/skills/（同名覆盖）
+   * 加载顺序: 内置 skills/ → 项目级 AutoSnippet/skills/（同名覆盖）
    * @returns {{ name: string, summary: string }[]}
    */
   #listAvailableSkills() {
@@ -772,27 +1776,92 @@ ${skillSection}
   }
 
   /**
-   * 从用户消息中提取偏好/决策写入 Memory
-   * 使用正则匹配，不调 AI — 零延迟
+   * 从对话中提取值得记忆的信息写入 Memory
+   *
+   * 双层策略:
+   *   1. 规则快速匹配（零延迟，覆盖明确的中英文模式）
+   *   2. AI 驱动提取（异步后台，从 reply 中提取 [MEMORY] 标签）
+   *
+   * source 隔离: 标记 memory 来源，避免系统分析污染用户记忆
    */
-  #extractMemory(prompt, _reply) {
+  #extractMemory(prompt, reply) {
     if (!this.#memory) return;
+    const source = this.#currentSource || 'user';
+
     try {
+      // ── 层 1: 规则快速匹配（中文 + 英文） ──
       const prefPatterns = [
         /我们(项目|团队)?(不用|不使用|禁止|避免|偏好|习惯|规范是)/,
         /以后(都|请|要)/,
         /记住/,
+        /we\s+(don'?t|never|always|prefer|avoid)\s+use/i,
+        /remember\s+(to|that)/i,
+        /our\s+(convention|standard|rule)\s+is/i,
       ];
       if (prefPatterns.some(p => p.test(prompt))) {
         this.#memory.append({
           type: 'preference',
           content: prompt.substring(0, 200),
+          source,
           ttl: 30,
         });
       }
+
+      const decisionPatterns = [
+        /决定(了|用|采用|使用)/,
+        /(确认|同意|通过)(了|这个方案|审核)/,
+        /就(这样|这么)(做|定|办)/,
+        /let'?s\s+(go\s+with|use|adopt)/i,
+        /approved|confirmed|decided/i,
+      ];
+      if (decisionPatterns.some(p => p.test(prompt))) {
+        this.#memory.append({
+          type: 'decision',
+          content: prompt.substring(0, 200),
+          source,
+          ttl: 60,
+        });
+      }
+
+      // ── 层 2: 从 AI reply 中提取 [MEMORY] 标签 ──
+      // AI 可在回复中嵌入: [MEMORY:preference] 内容 [/MEMORY]
+      if (reply) {
+        const memoryTagRegex = /\[MEMORY:(\w+)\]\s*([\s\S]*?)\s*\[\/MEMORY\]/g;
+        let match;
+        while ((match = memoryTagRegex.exec(reply)) !== null) {
+          const type = match[1]; // preference | decision | context
+          const content = match[2].trim();
+          if (content && ['preference', 'decision', 'context'].includes(type)) {
+            this.#memory.append({
+              type,
+              content: content.substring(0, 200),
+              source,
+              ttl: type === 'context' ? 90 : type === 'decision' ? 60 : 30,
+            });
+          }
+        }
+      }
     } catch { /* memory write failure is non-critical */ }
   }
 
+  /**
+   * 自动压缩过长的对话（异步后台执行）
+   * 当对话消息数超过 12 条时触发 AI 摘要压缩
+   */
+  async #autoSummarize(conversationId) {
+    if (!this.#conversations || !this.#aiProvider) return;
+    try {
+      const messages = this.#conversations.load(conversationId, { tokenBudget: Infinity });
+      if (messages.length >= 12) {
+        await this.#conversations.summarize(conversationId, {
+          aiProvider: this.#aiProvider,
+        });
+      }
+    } catch {
+      // 摘要失败不影响主流程
+    }
+  }
+
   /**
    * 事件驱动入口（P2 预留接口）
    * @param {{ type: string, payload: object, source?: string }} event
@@ -800,7 +1869,7 @@ ${skillSection}
   async executeEvent(event) {
     const { type, payload } = event;
     const prompt = this.#eventToPrompt(type, payload);
-    return this.execute(prompt, { history: [] });
+    return this.execute(prompt, { history: [], source: 'system' });
   }
 
   #eventToPrompt(type, payload) {
@@ -816,6 +1885,54 @@ ${skillSection}
     }
   }
 
+  /**
+   * Context Window 自动压缩（受 Cline AutoCondense 启发）
+   *
+   * 在 ReAct 循环中实时检测消息总 token 数。
+   * 当超过 TOKEN_BUDGET 时，保留:
+   *   - 首条消息（可能是 system / 用户首问）
+   *   - 最后 4 条消息（当前推理上下文）
+   * 中间消息压缩为一条摘要。
+   *
+   * 策略: 非阻塞、纯规则（不调 AI），避免 ReAct 循环内引入额外 AI 调用。
+   */
+  #condenseIfNeeded(messages, tokenBudget = 10000) {
+    const estimateTokens = (text) => Math.ceil((text || '').length / 3.5);
+
+    let totalTokens = 0;
+    for (const m of messages) totalTokens += estimateTokens(m.content);
+
+    if (totalTokens <= tokenBudget || messages.length <= 6) return;
+
+    // 保留首条 + 最后 4 条，压缩中间
+    const keepTail = 4;
+    const first = messages[0];
+    const tail = messages.slice(-keepTail);
+    const middle = messages.slice(1, -keepTail);
+
+    if (middle.length === 0) return;
+
+    // 生成摘要
+    const toolCallSummary = middle
+      .filter(m => m.role === 'user' && m.content.startsWith('Observation from tool'))
+      .map(m => {
+        const toolMatch = m.content.match(/Observation from tool "([^"]+)"/);
+        return toolMatch ? toolMatch[1] : null;
+      })
+      .filter(Boolean);
+
+    const condensed = {
+      role: 'system',
+      content: `[上下文压缩] 省略了 ${middle.length} 条中间消息（含工具调用: ${toolCallSummary.join(', ') || '无'}）。请基于最近的 observation 继续推理。`,
+    };
+
+    // 原地修改数组
+    messages.length = 0;
+    messages.push(first, condensed, ...tail);
+
+    this.#logger.debug(`[ChatAgent] condensed ${middle.length} messages (${totalTokens} → ~${estimateTokens(first.content) + estimateTokens(condensed.content) + tail.reduce((s, m) => s + estimateTokens(m.content), 0)} tokens)`);
+  }
+
   /**
    * 截断长文本
    */