myagent-ai 1.9.5 → 1.9.7

package/agents/main_agent.py

@@ -5,15 +5,13 @@ agents/main_agent.py - 主 Agent
 """
 from __future__ import annotations
 
-import json
 import asyncio
 from typing import Any, Callable, Dict, List, Optional
 
 from core.logger import get_logger
 from core.llm import LLMClient, LLMResponse, Message
 from agents.base import BaseAgent, AgentContext
-from core.utils import generate_id, timestamp, safe_json_parse, truncate_str
-from core.context_manager import ContextManager, ContextConfig, estimate_tokens
+from core.utils import generate_id, timestamp, truncate_str
 from core.context_builder import ContextBuilder
 from core.output_parser import ParsedOutput, parse_output, validate_output, extract_surrounding_text
 
@@ -36,147 +34,10 @@ class MainAgent(BaseAgent):
     name = "main_agent"
     description = "AI助手主控Agent，负责理解用户意图、规划任务、调度执行"
 
-    SYSTEM_PROMPT = """你是 MyAgent - 一个强大的本地桌面AI助手。你拥有以下能力:
-
-## 核心能力
-1. **代码执行**: 可以运行 Python、Shell/Bash、PowerShell 代码
-2. **文件操作**: 读取、写入、搜索、管理文件
-3. **网络搜索**: 搜索互联网、读取网页
-4. **系统操作**: 查询系统信息、管理进程
-5. **浏览器操作**: 自动化浏览器(如已安装 Playwright)
-6. **记忆系统**: 记住用户偏好、历史任务、避免重复犯错
-
-## 工作方式（遵循智能体循环规范）
-你必须严格按照 **思考→执行→观察→思考** 的循环模式工作：
-1. **思考**: 分析当前状态，确定下一步要做什么，用自然语言说明你的思路
-2. **执行**: 执行操作（一个命令或一个技能调用）
-3. **观察**: 查看执行结果，分析是否成功
-4. **继续思考**: 基于结果决定下一步，重复以上循环
-
-**执行模式**：
-- **step 模式**（默认）：每次只执行一个 action，等待结果后再决定下一步。适用于：
-  - 后续操作依赖前一步结果（如先读文件再修改）
-  - 操作可能有副作用需要确认（如删除、写入）
-  - 不确定操作是否会成功
-- **batch 模式**：一次执行多个互不依赖的 action。仅适用于：
-  - 所有操作之间完全独立，不需要前一步的结果
-  - 都是简单的只读操作（如读取多个文件、查看多个系统信息）
-  - 你有很高信心所有操作都会成功
-
-**关键原则**：
-- 默认使用 step 模式（安全优先）
-- 只有当你确信多个操作互不依赖时才用 batch 模式
-- 每个操作前，用 thought 字段说明你为什么要执行这一步
-- 如果前一步失败了，先分析原因，再尝试修复或换一种方法
-- 不要猜测结果，始终基于实际执行结果来判断
-
-## ⏰ 超时控制规则（强制要求）
-对于每个需要执行的命令(action type="code")，你**必须**在 action 中包含 "timeout_seconds" 字段，
-指定该命令的预估最大执行超时时间（秒）。这是一项强制要求，不能省略。
-
-超时时间设定指南:
-- 简单打印/计算: 10-30秒
-- 文件读写/搜索: 30-60秒
-- 网络请求/API调用: 60-120秒
-- 数据处理/批量操作: 120-300秒
-- 大规模编译/安装: 300-600秒
-- 如果不确定，默认设为 120秒
-
-**如果命令执行超时**: 系统会自动将超时信息反馈给你，包含命令已产生的部分输出。
-你需要分析超时原因并给出改进方案（如优化算法、添加超时参数、分批处理等）。
-
-## 输出格式（重要：流式友好）
-
-**核心原则：先用纯文本说明你的思路，只在执行操作时才输出 JSON。**
-
-### 情况 1：需要执行操作
-先用纯文本/markdown简要说明你的分析和计划（用户会实时看到），然后用 JSON 输出操作指令：
-
-让我先检查一下文件内容...
-
-```action
-{"thought": "需要查看文件内容", "mode": "step", "actions": [{"type": "skill", "name": "file_read", "params": {"path": "/a.txt"}}]}
-```
-
-### 情况 2：不需要执行操作
-直接用纯文本/markdown回复即可，不需要任何 JSON。
-
-### 情况 3：执行完操作后的总结
-操作完成后，直接用纯文本/markdown总结结果，不要再用 JSON。
-
-### JSON 操作指令格式
-将 JSON 放在 ```action``` 代码块中，系统会自动识别并执行：
-
-**step 模式**（默认，逐步执行）:
-```action
-{"thought": "说明你当前的分析和下一步计划", "mode": "step", "actions": [{"type": "code", "language": "python", "code": "代码", "timeout_seconds": 60}]}
-```
-
-**batch 模式**（多个独立操作）:
-```action
-{"thought": "说明为什么可以批量执行", "mode": "batch", "actions": [{"type": "skill", "name": "file_read", "params": {"path": "/a.txt"}}, {"type": "skill", "name": "file_read", "params": {"path": "/b.txt"}}]}
-```
-
-action type="code" 必须包含 "timeout_seconds" 字段。action type="skill" 或 "memory" 不需要此字段。
-省略 mode 字段时默认为 "step"。
-
-**注意**：你也可以直接输出裸 JSON（不用 ```action``` 包裹），系统同样能识别。但推荐使用 ```action``` 格式，这样你的分析文本能实时流式展示给用户。
-
-## 执行模式任务追踪（重要：强制 JSON 格式）
-
-当你处于**执行模式**（Execution Mode）时，你**必须**在每次回复中包含一个 JSON 格式的任务进度列表。
-这个 JSON 必须放在 ```tasklist``` 代码块中，系统会自动解析并实时展示给用户。
-
-格式要求：
-```tasklist
-[
-  {"text": "分析需求", "status": "done"},
-  {"text": "检查文件结构", "status": "done"},
-  {"text": "修改代码", "status": "running"},
-  {"text": "测试验证", "status": "pending"}
-]
-```
-
-status 取值：
-- `"pending"` — 待执行
-- `"running"` — 正在执行（当前步骤，每次只能有一个）
-- `"done"` — 已完成
-- `"blocked"` — 被阻塞（等待依赖或其他原因）
-
-规则：
-1. 每次回复开头先用纯文本简要分析当前状态（这段文本会实时流式展示给用户）
-2. 然后输出 ```tasklist``` 代码块更新任务进度
-3. 如果需要执行操作，在 tasklist 之后输出 ```action``` 代码块
-4. 如果不需要执行操作（纯文本回复），在 tasklist 之后直接写总结
-5. 如果是简单任务（一步完成），也必须输出任务列表（只有一个条目）
-6. 每次只将一个任务标记为 `running`，其余为 `pending` 或 `done`
-7. 不要手动输出 markdown 格式的任务列表，只用 JSON 格式
-
-回复结构示例：
-```
-让我先检查一下文件内容...
-
-```tasklist
-[{"text": "检查文件内容", "status": "running"}, {"text": "根据结果修改", "status": "pending"}]
-```
-
-```action
-{"thought": "需要查看文件", "mode": "step", "actions": [{"type": "skill", "name": "file_read", "params": {"path": "/a.txt"}}]}
-```
-```
-
-## 重要规则
-- 优先使用技能系统完成操作，而不是直接写代码
-- 执行危险操作前先警告用户
-- 保持回复简洁明了
-- 用中文回复
-- 绝对不要在回复开头进行自我介绍
-- 不要重复问候"""
-
     # =========================================================================
-    # V2 系统提示词 — 结构化输出格式
+    # 系统提示词 — 结构化输出格式
     # =========================================================================
-    SYSTEM_PROMPT_V2 = """你是一个强内容分析格式转化引擎，要深入分析以下上下文内容：
+    SYSTEM_PROMPT = """你是一个强内容分析格式转化引擎，要深入分析以下上下文内容：
 
 严格格式化输出以下内容:
 <output>
@@ -219,12 +80,7 @@ status 取值：
         self._iteration_count = 0
         self._current_task_id: str = ""
         self._registered_task: bool = False
-        # 组织上下文缓存（避免重复加载）
-        self._org_context_cache: str = ""
-        self._org_context_mtime: float = 0  # 文件修改时间，用于检测变更
-        # Token 上下文管理器 (滚动摘要 + 预算控制)
-        self.context_manager = ContextManager(ContextConfig())
-        # V2 Context Builder (结构化上下文构建)
+        # Context Builder (结构化上下文构建)
         self.context_builder: Optional[ContextBuilder] = None
         # 执行事件追踪（用于前端展示命令执行过程）
         self._execution_events: List[Dict] = []
@@ -233,13 +89,13 @@ status 取值：
         self.active_contexts: Dict[str, AgentContext] = {}
 
     def init_context_builder(self, memory_manager=None, skill_registry=None, knowledge_base_dir=None):
-        """初始化 V2 Context Builder（在系统启动后调用，注入依赖）"""
+        """初始化 Context Builder（在系统启动后调用，注入依赖）"""
         self.context_builder = ContextBuilder(
             memory_manager=memory_manager,
             skill_registry=skill_registry,
             knowledge_base_dir=knowledge_base_dir,
         )
-        logger.info("V2 Context Builder 已初始化" + (f" (知识库: {knowledge_base_dir})" if knowledge_base_dir else ""))
+        logger.info("Context Builder 已初始化" + (f" (知识库: {knowledge_base_dir})" if knowledge_base_dir else ""))
 
     def _add_exec_event(self, event_type: str, data: Dict):
         """记录一个执行事件（供前端展示）"""
@@ -293,11 +149,7 @@ status 取值：
         logger.info(f"[{task_id}] 开始处理用户请求: {context.user_message[:100]}")
 
         try:
-            # V2 路由: 如果 context_builder 已初始化，使用 V2 结构化输出循环
-            if self.context_builder is not None:
-                logger.info(f"[{task_id}] 检测到 V2 Context Builder，使用 V2 执行循环")
-                return await self.process_v2(context)
-            return await self._process_inner(context, task_id)
+            return await self.process_v2(context)
         finally:
             # 移除活跃上下文
             self.active_contexts.pop(context.session_id, None)
@@ -306,838 +158,98 @@ status 取值：
                 self.config_broadcaster.unregister(task_id)
                 self._registered_task = False
 
-    async def _process_inner(self, context: AgentContext, task_id: str) -> AgentContext:
-        """内部处理逻辑（被 process 包裹，用于确保注册/注销广播器）"""
-
-        # Step 1: 加载相关记忆
-        if self.memory_agent:
-            mem_context = AgentContext(
-                task_id=task_id,
-                session_id=context.session_id,
-                user_message=context.user_message,
-                metadata={"memory_action": "get_relevant"},
-            )
-            await self.memory_agent.process(mem_context)
-            if "memory_context_prompt" in mem_context.working_memory:
-                context.working_memory["memory_context_prompt"] = \
-                    mem_context.working_memory["memory_context_prompt"]
-
-        # Step 2: 保存用户消息到短期记忆
-        if self.memory:
-            self.memory.add_short_term(
-                session_id=context.session_id,
-                role="user",
-                content=context.user_message,
-            )
-
-        # Step 3: 主循环(计划-执行-反思)
-        final_response = ""
-        max_iter = self.config.agent.max_iterations
-
-        while self._iteration_count < max_iter:
-            self._iteration_count += 1
-            logger.debug(f"[{task_id}] 迭代 {self._iteration_count}/{max_iter}")
-
-            # 检查配置热加载广播（每次迭代前检查）
-            if self.config_broadcaster:
-                reloaded, reload_type = await self.config_broadcaster.check_and_wait(task_id)
-                if reloaded:
-                    logger.info(f"[{task_id}] 🔄 {reload_type}已热更新，继续执行 (iteration={self._iteration_count})")
-                    # 更新迭代检查点
-                    if self.config_broadcaster._active_tasks.get(task_id):
-                        self.config_broadcaster._active_tasks[task_id].iteration = self._iteration_count
-                    # 代码热更新后，LLM 客户端可能已被刷新，下次调用会自动重建
-                    if reload_type == "code":
-                        logger.info(f"[{task_id}] 代码模块已热更新，LLM 客户端将在下次调用时自动重建")
-
-            # ── 检查并处理注入的消息 ──
-            if context.pending_injected_messages:
-                injected = context.pending_injected_messages.copy()
-                context.pending_injected_messages.clear()
-                for msg_text in injected:
-                    logger.info(f"[{task_id}] 注入消息到对话历史: {msg_text[:50]}...")
-                    # 如果不是第一轮，且历史最后一条不是 user 消息，则注入
-                    context.conversation_history.append(
-                        Message(role="user", content=f"[用户中断/补充]: {msg_text}")
-                    )
-                    # 同时也保存到短期记忆
-                    if self.memory:
-                        self.memory.add_short_term(
-                            session_id=context.session_id,
-                            role="user",
-                            content=f"[中断补充]: {msg_text}",
-                        )
-
-            # 构建消息列表
-            messages = self._build_messages(context)
-
-            # 添加可用工具
-            tools = self._get_tools()
-
-            # 调用 LLM
-            response = await self._call_llm(messages, tools=tools)
-
-            if not response.success:
-                final_response = f"⚠️ LLM 调用失败: {response.error}"
-                break
-
-            # 解析响应
-            content = response.content
-
-            # 检查是否有工具调用 (OpenAI function calling)
-            if response.tool_calls:
-                # 先将 assistant 的 tool_calls 消息加入历史（OpenAI 格式要求）
-                context.conversation_history.append(
-                    Message(role="assistant",
-                           content=response.content or "",
-                           tool_calls=response.tool_calls)
-                )
-                # 记录工具调用事件
-                for tc in response.tool_calls:
-                    self._add_exec_event("tool_call", {
-                        "title": f"调用工具: {tc['name']}",
-                        "tool_name": tc["name"],
-                        "arguments": tc.get("arguments", {}),
-                    })
-                # 执行工具调用
-                tool_results = await self._handle_tool_calls(
-                    response.tool_calls, context, task_id
-                )
-                # 记录工具结果事件
-                for tc, result in tool_results:
-                    self._add_exec_event("tool_result", {
-                        "title": f"工具结果: {tc['name']}",
-                        "tool_name": tc["name"],
-                        "success": result.get("success", False),
-                        "summary": truncate_str(result.get("output", result.get("error", "")), 500),
-                        "result": result,
-                    })
-                # 再将工具结果加入消息历史
-                for tc, result in tool_results:
-                    context.conversation_history.append(
-                        Message(role="tool", content=json.dumps(result, ensure_ascii=False),
-                               tool_call_id=tc["id"], name=tc["name"])
-                    )
-                # 继续循环，让 LLM 处理工具结果
-                continue
-
-            # 尝试解析 JSON 操作指令
-            action_data = safe_json_parse(content)
-
-            if action_data and isinstance(action_data, dict):
-                # 有结构化的操作指令
-                if "actions" in action_data:
-                    action_mode = action_data.get("mode", "step")
-
-                    # step 模式安全保护：只执行第一个 action
-                    if action_mode == "step" and len(action_data.get("actions", [])) > 1:
-                        action_data = {
-                            "thought": action_data.get("thought", ""),
-                            "mode": "step",
-                            "actions": [action_data["actions"][0]],
-                        }
-
-                    # 执行操作列表
-                    results = await self._execute_actions(
-                        action_data, context, task_id
-                    )
-                    # 将结果反馈给 LLM
-                    context.conversation_history.append(
-                        Message(role="assistant", content=content)
-                    )
-                    result_summary = self._summarize_action_results(results)
-
-                    # 如果有超时诊断，追加详细信息供 LLM 分析
-                    has_timeout = any(r.get("timed_out") for r in results)
-                    timeout_detail = ""
-                    if has_timeout:
-                        timeout_details = []
-                        for i, r in enumerate(results, 1):
-                            if r.get("timed_out"):
-                                diag = r.get("timeout_diagnosis", {})
-                                timeout_details.append(
-                                    f"### 命令 {i} 超时诊断\n"
-                                    f"- 原因: {diag.get('diagnosis', '未知')}\n"
-                                    f"- 进展: {diag.get('progress', '未知')}\n"
-                                    f"- 是否建议重试: {'是' if diag.get('should_retry') else '否'}\n"
-                                    f"- 重试策略: {diag.get('retry_strategy', '无')}\n"
-                                    f"- 改进建议:\n"
-                                )
-                                for s in diag.get("suggestions", []):
-                                    timeout_details.append(f"  - {s}")
-                        timeout_detail = "\n\n## ⏰ 超时诊断详情\n" + "\n".join(timeout_details)
-
-                    feedback_msg = f"[执行结果]\n{result_summary}\n\n请基于以上结果继续。"
-                    if timeout_detail:
-                        feedback_msg += timeout_detail + "\n\n请根据以上诊断信息决定下一步操作。"
-
-                    context.conversation_history.append(
-                        Message(role="user", content=feedback_msg)
-                    )
-
-                    # 退出循环判断：step 模式始终继续让 LLM 决定，batch 模式全部成功则退出
-                    all_success = all(r.get("success", False) for r in results)
-                    if action_mode == "batch" and all_success and results:
-                        final_response = action_data.get("thought", "")
-                        if "plan" in action_data and action_data["plan"]:
-                            final_response += "\n\n已完成: " + " → ".join(action_data["plan"])
-                        break
-
-                    # 如果有超时且诊断建议不重试，强制中断循环避免无效重试
-                    if has_timeout:
-                        should_abort = False
-                        abort_reasons = []
-                        for i, r in enumerate(results, 1):
-                            if r.get("timed_out"):
-                                diag = r.get("timeout_diagnosis", {})
-                                if diag.get("should_retry") is False:
-                                    should_abort = True
-                                    abort_reasons.append(
-                                        f"命令{i}: {diag.get('diagnosis', '不可恢复的超时')}"
-                                    )
-                        if should_abort:
-                            logger.warning(
-                                f"[{task_id}] ⛔ 超时诊断建议不重试，终止当前执行循环 "
-                                f"(iteration={self._iteration_count})"
-                            )
-                            # 构建诊断反馈，强制LLM输出final_answer
-                            abort_msg = (
-                                "[系统通知] 以下命令因超时被终止，且超时诊断结果表明不应重试:\n"
-                            )
-                            for reason in abort_reasons:
-                                abort_msg += f"- {reason}\n"
-                            abort_msg += (
-                                "\n请直接以纯文本或 {\"type\": \"final_answer\", \"content\": \"...\"} "
-                                "格式回复，告知用户任务无法完成的原因和建议的替代方案。"
-                                "不要再尝试执行相同的命令。"
-                            )
-                            context.conversation_history.append(
-                                Message(role="user", content=abort_msg)
-                            )
-                            continue  # 让LLM生成final_answer，而不是重试命令
-
-                    continue
-
-                # 单个 action
-                if action_data.get("type") == "final_answer":
-                    final_response = action_data.get("content", content)
-                    break
-
-            # 纯文本回复(没有工具调用)
-            final_response = content
-            break
-
-        # 保存助手回复到短期记忆
-        if self.memory and final_response:
-            self.memory.add_short_term(
-                session_id=context.session_id,
-                role="assistant",
-                content=final_response,
-            )
-
-        # ── 保存工具调用过程到短期记忆（供历史记录查看）──
-        if self.memory and self._execution_events:
-            try:
-                tool_summary_parts = []
-                for evt in self._execution_events:
-                    etype = evt.get("type", "")
-                    if etype in ("tool_call", "skill_call"):
-                        tool_name = evt.get("tool_name") or evt.get("skill_name", "")
-                        args = evt.get("arguments") or evt.get("params", {})
-                        tool_summary_parts.append(f"🔧 调用工具: {tool_name}({json.dumps(args, ensure_ascii=False)[:200]})")
-                    elif etype in ("tool_result", "skill_result"):
-                        tool_name = evt.get("tool_name") or evt.get("skill_name", "")
-                        success = evt.get("success", False)
-                        summary = evt.get("summary", "")
-                        status = "✅" if success else "❌"
-                        tool_summary_parts.append(f"  {status} 结果: {summary[:300]}")
-                    elif etype == "code_exec":
-                        lang = evt.get("language", "")
-                        code_preview = evt.get("code_preview", "")
-                        stdout = evt.get("stdout", "")
-                        success = evt.get("success", False)
-                        status = "✅" if success else "❌"
-                        tool_summary_parts.append(f"💻 执行 {lang}: {code_preview[:150]}")
-                        if stdout:
-                            tool_summary_parts.append(f"  {status} 输出: {stdout[:300]}")
-                    elif etype == "code_result":
-                        pass  # code_result is duplicate of code_exec with final status
-                if tool_summary_parts:
-                    exec_log = "\n".join(tool_summary_parts)
-                    self.memory.add_short_term(
-                        session_id=context.session_id,
-                        role="tool",
-                        content=exec_log,
-                        importance=0.3,
-                    )
-            except Exception as e:
-                logger.warning(f"保存工具调用过程失败: {e}")
-
-        # 清理工作记忆
-        context.working_memory["final_response"] = final_response
-        context.working_memory["iterations"] = self._iteration_count
-
-        logger.info(f"[{task_id}] 处理完成 (迭代 {self._iteration_count} 次)")
-
-        # 检查是否需要增量总结对话 (使用滚动摘要，不再清空短期记忆)
-        if self.memory_agent and self._iteration_count > 5:
-            try:
-                summary_context = AgentContext(
-                    session_id=context.session_id,
-                    metadata={"memory_action": "summarize"},
-                )
-                await self.memory_agent.process(summary_context)
-                # 将生成的摘要更新到 ContextManager 的滚动摘要缓冲
-                summary_result = summary_context.working_memory.get("summary_result", "")
-                if summary_result:
-                    self.context_manager.summary_buffer.update_summary(
-                        session_id=context.session_id,
-                        new_summary=summary_result,
-                        summarized_count=summary_context.working_memory.get("summarized_count", 0),
-                    )
-                    logger.info(
-                        f"[{task_id}] 滚动摘要已更新 (session={context.session_id})"
-                    )
-            except Exception as e:
-                logger.warning(f"对话总结失败: {e}")
-
-        return context
-
-    def _build_messages(self, context: AgentContext) -> List[Message]:
-        """构建完整的消息列表 (使用 ContextManager 进行 Token 预算优化)"""
-        # 合并系统提示 + 组织上下文
-        system_prompt = self.SYSTEM_PROMPT
-        org_context = self._build_org_context(context)
-        if org_context:
-            system_prompt += "\n\n" + org_context
-
-        # 注入 Agent 专属 system_prompt（如果有覆盖）
-        agent_prompt = context.metadata.get("agent_override_prompt") if context.metadata else None
-        agent_path = context.metadata.get("agent_override_path") if context.metadata else None
-        if agent_prompt:
-            prefix = f"## 当前角色\n你当前正在扮演「{agent_path}」Agent。请严格遵循以下角色设定:\n\n"
-            system_prompt += "\n\n" + prefix + agent_prompt
-
-        # 通用规则：禁止重复自我介绍（避免每次对话都问好）
-        system_prompt += "\n\n## 对话规则\n- 绝对不要在回复开头进行自我介绍（如'你好，我是XXX'），直接回答用户的问题或执行任务\n- 不要重复问候，除非用户主动打招呼"
-
-        # 执行模式：强调主动执行能力
-        chat_mode = (context.metadata.get("chat_mode") or '') if context.metadata else ''
-        if chat_mode == 'exec':
-            system_prompt += "\n\n## 执行模式 (当前激活)\n你当前处于执行模式，请务必主动使用可用工具执行操作，而不是只提供建议或反问用户。\n- 默认逐步执行（step 模式），每次一个操作，等待结果再决定下一步\n- 仅当多个操作完全独立时使用 batch 模式\n- 优先使用技能系统（skill）完成任务\n- 需要执行代码时，直接使用 code action 执行\n- 遇到不确定的操作，先尝试执行，失败后再调整\n- 不要反复询问用户是否要执行，直接执行并报告结果\n- 每步操作前先用 thought 说明你的计划"
-
-        # 记忆上下文
-        memory_ctx = context.working_memory.get("memory_context_prompt", "")
-
-        # 使用 ContextManager 构建优化后的消息列表
-        raw_messages = self.context_manager.build_context(
-            system_prompt=system_prompt,
-            memory_context=memory_ctx,
-            conversation_history=context.conversation_history,
-            user_message=context.user_message,
-            session_id=context.session_id,
-        )
-
-        # 转换回 Message 对象 (ContextManager 返回 dict)
-        messages = []
-        for m in raw_messages:
-            if isinstance(m, dict):
-                messages.append(Message(**m))
-            elif isinstance(m, Message):
-                messages.append(m)
-            else:
-                messages.append(m)
-
-        return messages
-
-    def _get_tools(self) -> Optional[List[Dict]]:
-        """获取可用工具列表(OpenAI function calling 格式)"""
-        if not self.skills:
-            return None
-        try:
-            return self.skills.get_all_schemas()
-        except Exception as e:
-            logger.warning(f"获取工具列表失败: {e}")
-            return None
-
-    @staticmethod
-    def _get_skill_permission(skill_name: str) -> Optional[str]:
-        """
-        根据技能名称映射到对应的权限项。
-
-        Returns:
-            权限项名称，或 None（不需要特殊权限的技能）
-        """
-        # 文件技能
-        if skill_name in ("file_write", "file_delete", "file_move"):
-            return "file_write"
-        if skill_name in ("file_read", "file_list", "file_search"):
-            return "file_read"
-        # 网络/搜索技能
-        if skill_name in ("web_search", "web_read", "url_read"):
-            return "network"
-        # 系统技能涉及执行
-        if skill_name in ("command_run",):
-            return "execution"
-        # 浏览器技能需要网络
-        if skill_name in ("browser_open", "browser_click", "browser_fill"):
-            return "network"
-        # 浏览器扩展技能 - 截图/JS执行/导航/关闭
-        if skill_name in ("browser_screenshot", "browser_eval", "browser_navigate", "browser_close"):
-            return "network"
-        # 桌面 GUI 自动化技能 - 涉及系统级执行权限
-        if skill_name in ("screenshot", "mouse_click", "mouse_drag", "type_text",
-                          "hotkey", "window_list", "window_focus", "screen_element"):
-            return "execution"
-        # 其他技能不需要特殊权限检查
-        return None
-
-    async def _handle_tool_calls(
-        self,
-        tool_calls: List[Dict],
-        context: AgentContext,
-        task_id: str,
-    ) -> List[tuple]:
-        """处理 OpenAI function calling 工具调用"""
-        results = []
-        for tc in tool_calls:
-            name = tc["name"]
-            args = tc.get("arguments", {})
-            logger.info(f"[{task_id}] 调用工具: {name}({args})")
+    # =========================================================================
+    # 执行循环 — 结构化输出 + Context Builder + Output Parser
+    # =========================================================================
 
+    async def _emit_v2_event(self, event_type: str, data: Dict, stream_callback: Optional[Callable] = None):
+        """发送 V2 SSE 事件。如果 stream_callback 不存在则仅记录日志。"""
+        event = {"type": event_type, **data}
+        if stream_callback is not None:
             try:
-                if self.skills:
-                    result = await self.skills.execute(name, **args)
-                    result_dict = result.to_dict()
+                if asyncio.iscoroutinefunction(stream_callback):
+                    await stream_callback(event)
                 else:
-                    result_dict = {"success": False, "error": "技能系统未初始化"}
+                    stream_callback(event)
             except Exception as e:
-                result_dict = {"success": False, "error": str(e)}
-
-            results.append((tc, result_dict))
-
-            # 记录错误模式
-            if not result_dict.get("success") and self.memory:
-                self.memory.record_error_pattern(
-                    error=f"工具 {name} 失败: {result_dict.get('error', '')}",
-                )
-
-        return results
-
-    async def _execute_actions(
-        self,
-        action_data: Dict,
-        context: AgentContext,
-        task_id: str,
-    ) -> List[Dict]:
-        """执行操作列表"""
-        results = []
-        actions = action_data.get("actions", [])
-
-        for action in actions:
-            action_type = action.get("type", "")
-
-            if action_type == "skill" and self.skills:
-                # 权限检查: 根据技能类别检查权限
-                skill_name = action.get("name", "")
-                skill_perm = self._get_skill_permission(skill_name)
-                if skill_perm and not self.check_permission(skill_perm):
-                    from core.permissions import PermissionManager
-                    label = PermissionManager.PERMISSION_LABELS.get(skill_perm, skill_perm)
-                    results.append({
-                        "success": False,
-                        "error": f"[权限] 当前 Agent 没有'{label}'权限，操作被拒绝",
-                        "metadata": {"permission_denied": skill_perm},
-                    })
-                    self._add_exec_event("skill_call", {
-                        "title": f"技能调用被拒: {skill_name}",
-                        "skill_name": skill_name,
-                        "success": False,
-                        "error": f"权限不足: {label}",
-                    })
-                    continue
-
-                # 记录技能调用事件
-                self._add_exec_event("skill_call", {
-                    "title": f"调用技能: {skill_name}",
-                    "skill_name": skill_name,
-                    "params": action.get("params", {}),
-                })
-                result = await self.skills.execute(
-                    action.get("name", ""),
-                    **action.get("params", {}),
-                )
-                result_dict = result.to_dict()
-                results.append(result_dict)
-                # 记录技能结果事件
-                self._add_exec_event("skill_result", {
-                    "title": f"技能结果: {skill_name}",
-                    "skill_name": skill_name,
-                    "success": result_dict.get("success", False),
-                    "summary": truncate_str(str(result_dict.get("output", result_dict.get("error", ""))), 500),
-                })
-
-            elif action_type == "code" and self.executor:
-                # 权限检查: execution
-                if not self.check_permission("execution"):
-                    results.append({
-                        "success": False,
-                        "error": "[权限] 当前 Agent 没有代码执行权限，操作被拒绝",
-                        "metadata": {"permission_denied": "execution"},
-                    })
-                    self._add_exec_event("code_exec", {
-                        "title": f"代码执行被拒",
-                        "language": action.get("language", "unknown"),
-                        "code_preview": truncate_str(action.get("code", ""), 200),
-                        "success": False,
-                        "error": "代码执行权限不足",
-                    })
-                    continue
-
-                code_lang = action.get("language", "python")
-                code_text = action.get("code", "")
-
-                # 提取 LLM 预估的超时时间
-                timeout_seconds = action.get("timeout_seconds")
-                if timeout_seconds is None:
-                    # 如果 LLM 未提供 timeout_seconds，使用默认值并记录警告
-                    timeout_seconds = self.config.executor.timeout if hasattr(self.config, 'executor') else 120
-                    logger.warning(
-                        f"[{task_id}] LLM 未指定 timeout_seconds，使用默认值 {timeout_seconds}s"
-                    )
-                else:
-                    try:
-                        timeout_seconds = int(timeout_seconds)
-                        # 限制超时范围: 最小 5s，最大 3600s
-                        timeout_seconds = max(5, min(timeout_seconds, 3600))
-                    except (ValueError, TypeError):
-                        timeout_seconds = 120
-                        logger.warning(
-                            f"[{task_id}] timeout_seconds 值无效，使用默认值 120s"
-                        )
-
-                # 记录代码执行开始事件
-                self._add_exec_event("code_exec", {
-                    "title": f"执行 {code_lang} 代码",
-                    "language": code_lang,
-                    "code": code_text,
-                    "code_preview": truncate_str(code_text, 200),
-                    "status": "running",
-                    "timeout": timeout_seconds,
-                })
-
-                # 注入权限检查器到 executor（用于更细粒度的检查）
-                self.executor.set_permission_checker(
-                    self.check_permission, self.name
-                )
-
-                exec_result = await self.executor.execute(
-                    language=action.get("language", "python"),
-                    code=action.get("code", ""),
-                    timeout=timeout_seconds,
-                )
-
-                # 设置超时追踪字段（executor 已直接设置 timed_out，这里确保 timeout_limit）
-                if not exec_result.timeout_limit:
-                    exec_result.timeout_limit = timeout_seconds
-
-                result_dict = exec_result.to_dict()
-
-                # 记录代码执行结果事件
-                self._add_exec_event("code_result", {
-                    "title": f"{'超时' if exec_result.timed_out else '成功' if exec_result.success else '失败'}: {code_lang}",
-                    "language": code_lang,
-                    "code_preview": truncate_str(action.get("code", ""), 200),
-                    "success": exec_result.success,
-                    "timed_out": exec_result.timed_out,
-                    "exit_code": exec_result.exit_code,
-                    "execution_time": round(exec_result.execution_time, 3),
-                    "timeout": timeout_seconds,
-                    "stdout": truncate_str(exec_result.stdout, 5000),
-                    "stderr": truncate_str(exec_result.stderr, 3000),
-                    "error": truncate_str(exec_result.error, 2000),
-                    "result": result_dict,
-                })
-
-                # 超时后自动触发 LLM 诊断分析
-                if exec_result.timed_out:
-                    logger.info(
-                        f"[{task_id}] ⏰ 命令执行超时 ({timeout_seconds}s)，"
-                        f"自动触发 LLM 诊断分析..."
-                    )
-                    diagnosis = await self._diagnose_timeout(
-                        action, exec_result, context, task_id
-                    )
-                    result_dict["timeout_diagnosis"] = diagnosis
-
-                results.append(result_dict)
-
-            elif action_type == "memory" and self.memory_agent:
-                mem_ctx = AgentContext(
-                    task_id=task_id,
-                    session_id=context.session_id,
-                    metadata={
-                        "memory_action": action.get("action", ""),
-                        **action.get("data", {}),
-                    },
-                )
-                await self.memory_agent.process(mem_ctx)
-                results.append({"success": True, "action": "memory"})
-
-            elif action_type == "final":
-                break
-
-            else:
-                results.append({
-                    "success": False,
-                    "error": f"未知操作类型: {action_type}",
-                })
-
-        return results
-
-    @staticmethod
-    def _build_timeout_diagnosis_message(action: Dict, exec_result: 'ExecResult') -> str:
-        """构建超时诊断的用户消息（避免 f-string 内换行问题）"""
-        parts = []
-        parts.append("## 超时命令信息")
-        parts.append(f"- 语言: {action.get('language', 'unknown')}")
-        parts.append(f"- 超时上限: {exec_result.timeout_limit}s")
-        parts.append(f"- 实际执行时间: {exec_result.execution_time:.1f}s")
-        parts.append(f"- 代码:")
-        parts.append(f"```{action.get('language', '')}")
-        parts.append(f"{action.get('code', '')}")
-        parts.append("```")
-        parts.append("")
-        parts.append("## 执行输出（超时前）")
-
-        if exec_result.stdout and exec_result.stdout.strip():
-            parts.append("### 标准输出")
-            parts.append("```")
-            parts.append(exec_result.stdout[:5000])
-            parts.append("```")
-            parts.append("")
-        else:
-            parts.append("(无输出)")
-            parts.append("")
-
-        if exec_result.stderr and exec_result.stderr.strip():
-            parts.append("### 标准错误")
-            parts.append("```")
-            parts.append(exec_result.stderr[:3000])
-            parts.append("```")
+                logger.debug(f"V2 SSE 事件发送失败 ({event_type}): {e}")
         else:
-            parts.append("(无错误输出)")
-
-        return "\n".join(parts)
+            logger.debug(f"[v2-event] {event_type}: {data}")
 
-    async def _diagnose_timeout(
+    async def _merge_duplicate_memory(
         self,
-        action: Dict,
-        exec_result: 'ExecResult',
+        old_memory,
+        new_content: str,
         context: AgentContext,
         task_id: str,
-    ) -> Dict[str, Any]:
+    ) -> Optional[str]:
         """
-        超时后自动调用 LLM 诊断分析执行问题。
+        当发现新旧记忆高度相似时，调用 LLM API 让其判断最终记忆内容。
 
-        分析维度:
-          1. 超时原因诊断（死循环/网络阻塞/数据量过大/缺少输入等）
-          2. 基于已有输出的进展评估
-          3. 具体改进建议（优化代码/拆分任务/添加超时参数等）
-          4. 是否值得重试
+        将旧记忆、新记忆、当前上下文发送给 LLM，由 LLM 决定:
+          - 合并为一条更完整的记忆
+          - 保留新记忆（旧记忆已过时）
+          - 保留旧记忆（新记忆无新增信息）
 
         Returns:
-            诊断结果字典
+            合并后的记忆内容，或 None（合并失败）
         """
-        diagnosis_messages = [
-            Message(
-                role="system",
-                content=(
-                    "你是一个执行超时诊断专家。一个命令刚刚因超时被强制终止，"
-                    "请仔细分析以下信息，给出诊断结论和改进建议。\n\n"
-                    "请用 JSON 格式回复:\n"
-                    "{\n"
-                    '  "diagnosis": "超时原因诊断（简明扼要）",\n'
-                    '  "progress": "已完成的进度评估",\n'
-                    '  "suggestions": ["改进建议1", "改进建议2", ...],\n'
-                    '  "should_retry": true/false,\n'
-                    '  "retry_strategy": "如果建议重试，说明重试策略",\n'
-                    '  "estimated_fix_time": "预计修复后需要的时间(秒)"\n'
-                    "}"
-                ),
-            ),
-            Message(
-                role="user",
-                content=self._build_timeout_diagnosis_message(action, exec_result),
-            ),
-        ]
-
-        try:
-            diagnosis = await self._call_llm_json(diagnosis_messages)
-            if "error" in diagnosis:
-                logger.warning(f"[{task_id}] 超时诊断 LLM 调用失败: {diagnosis['error']}")
-                return {
-                    "diagnosis": "LLM 诊断调用失败",
-                    "suggestions": ["检查命令是否有死循环", "尝试减少处理数据量"],
-                    "should_retry": False,
-                }
-
-            # 记录诊断结果
-            logger.info(
-                f"[{task_id}] ⏰ 超时诊断完成: {diagnosis.get('diagnosis', 'N/A')}"
-            )
-
-            # 如果诊断建议重试且提供了重试策略，记录到记忆中
-            if diagnosis.get("should_retry") and self.memory:
-                self.memory.record_error_pattern(
-                    error=(
-                        f"命令超时 ({exec_result.timeout_limit}s): "
-                        f"{action.get('code', '')[:200]}\n"
-                        f"诊断: {diagnosis.get('diagnosis', '')}\n"
-                        f"建议: {'; '.join(diagnosis.get('suggestions', []))}"
-                    )
-                )
-
-            return diagnosis
-
-        except Exception as e:
-            logger.error(f"[{task_id}] 超时诊断异常: {e}")
-            return {
-                "diagnosis": f"诊断过程异常: {str(e)}",
-                "suggestions": ["检查命令逻辑", "手动测试命令"],
-                "should_retry": False,
-            }
-
-    def _summarize_action_results(self, results: List[Dict]) -> str:
-        """汇总操作结果"""
-        if not results:
-            return "无操作结果"
-
-        parts = []
-        for i, r in enumerate(results, 1):
-            status = "✅" if r.get("success") else "❌"
-            msg = r.get("message", r.get("error", ""))[:200]
-
-            # 超时特殊标记
-            if r.get("timed_out"):
-                status = "⏰"
-                limit = r.get("timeout_limit", "?")
-                actual = r.get("execution_time", "?")
-                msg = f"执行超时 (上限{limit}s, 实际{actual}s)"
-
-                # 追加诊断结果
-                diagnosis = r.get("timeout_diagnosis")
-                if diagnosis:
-                    diag_text = diagnosis.get("diagnosis", "")
-                    suggestions = diagnosis.get("suggestions", [])
-                    msg += f"\n  诊断: {diag_text}"
-                    if suggestions:
-                        msg += f"\n  建议: {'; '.join(suggestions[:3])}"
-
-            parts.append(f"{i}. {status} {msg}")
-
-        return "\n".join(parts)
-
-    def _build_org_context(self, context: AgentContext) -> str:
-        """
-        构建组织上下文信息。
-
-        如果组织功能已启用:
-        1. 读取 organization.md 内容
-        2. 对用户查询进行 RAG 搜索，获取相关知识片段
-        3. 返回格式化的上下文字符串
+        if not self.llm:
+            logger.warning(f"[{task_id}] 记忆合并: 无 LLM 客户端，跳过合并")
+            return None
 
-        Returns:
-            格式化的组织上下文，未启用时返回空字符串
-        """
-        try:
-            # 检查配置中是否启用了组织功能
-            org_enabled = False
-            if hasattr(self.config, 'organization'):
-                org_enabled = self.config.organization.enabled
-            if not org_enabled:
-                return ""
+        from datetime import datetime
+        old_time = old_memory.created_at or "未知时间"
+        new_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        user_msg = context.user_message or ""
 
-            parts = []
+        merge_prompt = f"""你是一个记忆管理系统。现在系统检测到两条高度相似的记忆，请你判断如何合并它们。
 
-            # 1. 读取 organization.md（使用 mtime 缓存检测变更）
-            try:
-                from config import get_config
-                config_mgr = get_config()
-                org_dir = config_mgr.data_dir / "organization"
-                org_info_path = org_dir / "organization.md"
-                if org_info_path.exists():
-                    current_mtime = org_info_path.stat().st_mtime
-                    if current_mtime != self._org_context_mtime:
-                        content = org_info_path.read_text(encoding="utf-8")
-                        # 检查是否仍是模板（包含占位注释）
-                        is_template = "<!-- 在此填写" in content
-                        if not is_template:
-                            self._org_context_cache = content
-                        else:
-                            self._org_context_cache = ""
-                        self._org_context_mtime = current_mtime
-            except Exception as e:
-                logger.debug(f"读取组织信息失败: {e}")
+## 旧记忆（创建于 {old_time}）
+{old_memory.content}
 
-            if self._org_context_cache:
-                parts.append("## 组织信息\n")
-                # 截取合理的长度，避免占用过多 token
-                org_text = self._org_context_cache[:3000]
-                parts.append(org_text)
-                parts.append("")
+## 新记忆（创建于 {new_time}）
+{new_content}
 
-            # 2. RAG 搜索组织知识库
-            try:
-                from config import get_config
-                from knowledge.rag import KnowledgeRAG
-
-                config_mgr = get_config()
-                kb_dir = config_mgr.data_dir / "organization" / "knowledge"
-                if kb_dir.exists() and any(kb_dir.iterdir()):
-                    rag = KnowledgeRAG(kb_dir=kb_dir)
-                    rag.build_index()
-
-                    if rag.total_chunks > 0:
-                        # 使用用户消息作为查询
-                        query = context.user_message
-                        results = rag.search(query, top_k=3)
-                        if results:
-                            parts.append("## 相关知识库内容\n")
-                            for r in results:
-                                parts.append(
-                                    f"### 📄 {r.file_name} (片段 {r.chunk_index + 1})\n"
-                                    f"{r.content[:1000]}\n"
-                                )
-            except Exception as e:
-                logger.debug(f"组织知识库搜索失败: {e}")
+## 当前用户输入
+{user_msg}
 
-            if not parts:
-                return ""
+## 任务
+请分析新旧记忆，输出一条最终的合并记忆。规则：
+1. 如果新记忆包含了旧记忆的信息并有更新，则合并为更完整的表述
+2. 如果新记忆只是旧记忆的重复或信息量更少，保留旧记忆中更完整的信息
+3. 如果新记忆提供了全新的信息，以新记忆为主，补充旧记忆中的有效部分
+4. 合并后的记忆应当简洁、准确、包含时间上下文
+5. 直接输出合并后的记忆内容，不要输出任何解释或标记
 
-            return "[组织上下文]\n请参考以下组织信息回答用户问题。如果组织信息与用户问题无关，可以忽略。\n\n" + "\n".join(parts)
+请输出合并后的记忆："""
 
+        try:
+            messages = [
+                Message(role="system", content="你是一个记忆管理系统，负责合并重复或相似的记忆条目。只输出合并后的记忆内容，不要输出任何额外说明。"),
+                Message(role="user", content=merge_prompt),
+            ]
+
+            response = await self._call_llm(messages)
+
+            if response.success and response.content:
+                merged = response.content.strip()
+                # 清理可能的引号包裹
+                if merged.startswith('"') and merged.endswith('"'):
+                    merged = merged[1:-1]
+                if merged.startswith("'") and merged.endswith("'"):
+                    merged = merged[1:-1]
+                logger.info(
+                    f"[{task_id}] 记忆合并成功: 旧({len(old_memory.content)}字) + "
+                    f"新({len(new_content)}字) → 合并({len(merged)}字)"
+                )
+                return merged
+            else:
+                logger.warning(f"[{task_id}] 记忆合并 LLM 调用失败: {response.error}")
+                return None
         except Exception as e:
-            logger.debug(f"构建组织上下文失败: {e}")
-            return ""
-
-    # =========================================================================
-    # V2 执行循环 — 结构化输出 + Context Builder + Output Parser
-    # =========================================================================
-
-    async def _emit_v2_event(self, event_type: str, data: Dict, stream_callback: Optional[Callable] = None):
-        """发送 V2 SSE 事件。如果 stream_callback 不存在则仅记录日志。"""
-        event = {"type": event_type, **data}
-        if stream_callback is not None:
-            try:
-                if asyncio.iscoroutinefunction(stream_callback):
-                    await stream_callback(event)
-                else:
-                    stream_callback(event)
-            except Exception as e:
-                logger.debug(f"V2 SSE 事件发送失败 ({event_type}): {e}")
-        else:
-            logger.debug(f"[v2-event] {event_type}: {data}")
+            logger.warning(f"[{task_id}] 记忆合并异常: {e}")
+            return None
 
     async def process_v2(
         self,
@@ -1154,7 +266,7 @@ status 取值：
 
         核心流程:
           1. 使用 ContextBuilder 构建 <context> XML
-          2. 将 context 注入 SYSTEM_PROMPT_V2，调用 LLM
+          2. 将 context 注入 SYSTEM_PROMPT，调用 LLM
           3. 使用 OutputParser 解析 <output> XML
           4. 根据 parsed.tools_to_call 依次执行工具
           5. 任一工具超时 → 强制回调 LLM
@@ -1176,11 +288,7 @@ status 取值：
         self._current_task_id = task_id
         self.clear_execution_events()
 
-        if not self.context_builder:
-            logger.warning("Context Builder 未初始化，回退到 V1 执行循环")
-            return await self._process_inner(context, task_id)
-
-        logger.info(f"[{task_id}] V2 执行循环启动: {context.user_message[:100]}")
+        logger.info(f"[{task_id}] 执行循环启动: {context.user_message[:100]}")
 
         try:
             return await self._process_v2_inner(
@@ -1210,6 +318,8 @@ status 取值：
         all_tool_outputs = ""
         recall_content = ""
         get_knowledge_content = ""
+        # 追踪流式推送的 reasoning 文本（用于构建有意义的最终回复）
+        _v2_reasoning_collected: List[str] = []
 
         conversation_history = list(context.conversation_history or [])
 
@@ -1273,8 +383,14 @@ status 取值：
                 stream_callback,
             )
 
-            # Step 2: 构建系统消息 (SYSTEM_PROMPT_V2 + context XML)
-            system_content = self.SYSTEM_PROMPT_V2 + "\n\n" + context_xml
+            # Step 2: 构建系统消息 — 将 context XML 插入 SYSTEM_PROMPT 的 "上下文" 占位处
+            _CONTEXT_PLACEHOLDER = "__CONTEXT_PLACEHOLDER__"
+            _prompt_with_placeholder = (
+                "你是一个强内容分析格式转化引擎，要深入分析以下上下文内容：\n\n"
+                + _CONTEXT_PLACEHOLDER + "\n\n"
+                + self.SYSTEM_PROMPT.split("\n", 1)[1]
+            )
+            system_content = _prompt_with_placeholder.replace(_CONTEXT_PLACEHOLDER, context_xml)
 
             # Step 3: 调用 LLM
             messages = [Message(role="system", content=system_content)]
@@ -1347,38 +463,63 @@ status 取值：
             if parsed.usersays_correct:
                 context.working_memory["usersays_correct"] = parsed.usersays_correct
 
-            # Step 6: 处理 remember — 查重后存入长期记忆
+            # Step 6: 处理 remember — 查重+LLM合并后存入长期记忆
             if parsed.remember:
                 try:
-                    # 查重：跳过与已有记忆高度重复的内容
-                    is_dup = False
                     if self.memory:
-                        is_dup = self.memory.is_duplicate_memory(
+                        # 查找是否有相似记忆
+                        dup_memory = self.memory.find_duplicate_memory(
                             content=parsed.remember,
                             session_id=context.session_id,
                             key="conversation_insight",
                         )
-                    if is_dup:
-                        logger.debug(f"[{task_id}] 记忆查重: 跳过重复内容")
-                    else:
-                        if self.memory_agent:
-                            mem_ctx = AgentContext(
-                                task_id=task_id,
-                                session_id=context.session_id,
-                                metadata={
-                                    "memory_action": "save",
-                                    "content": parsed.remember,
-                                },
+                        if dup_memory:
+                            # 发现相似记忆 → 调用 LLM API 合并新旧记忆
+                            logger.info(
+                                f"[{task_id}] 记忆查重: 发现相似内容，调用LLM合并 "
+                                f"(旧记忆ID={dup_memory.id}, 创建于={dup_memory.created_at})"
                             )
-                            await self.memory_agent.process(mem_ctx)
-                        elif self.memory:
-                            self.memory.add_long_term(
-                                session_id=context.session_id,
-                                key="conversation_insight",
-                                content=parsed.remember,
-                                summary=truncate_str(parsed.remember, 200),
-                                importance=0.7,
+                            merged_content = await self._merge_duplicate_memory(
+                                old_memory=dup_memory,
+                                new_content=parsed.remember,
+                                context=context,
+                                task_id=task_id,
                             )
+                            if merged_content:
+                                # 用 LLM 合并后的内容替换旧记忆
+                                self.memory.update_memory(
+                                    memory_id=dup_memory.id,
+                                    content=merged_content,
+                                    summary=truncate_str(merged_content, 200),
+                                )
+                                logger.info(f"[{task_id}] 记忆已合并更新: {dup_memory.id}")
+                            else:
+                                # LLM 合并失败，直接更新为新内容
+                                self.memory.update_memory(
+                                    memory_id=dup_memory.id,
+                                    content=parsed.remember,
+                                )
+                                logger.info(f"[{task_id}] 记忆直接更新为新内容: {dup_memory.id}")
+                        else:
+                            # 无重复，直接存储新记忆
+                            if self.memory_agent:
+                                mem_ctx = AgentContext(
+                                    task_id=task_id,
+                                    session_id=context.session_id,
+                                    metadata={
+                                        "memory_action": "save",
+                                        "content": parsed.remember,
+                                    },
+                                )
+                                await self.memory_agent.process(mem_ctx)
+                            else:
+                                self.memory.add_long_term(
+                                    session_id=context.session_id,
+                                    key="conversation_insight",
+                                    content=parsed.remember,
+                                    summary=truncate_str(parsed.remember, 200),
+                                    importance=0.7,
+                                )
                         await self._emit_v2_event(
                             "v2_memory_saved",
                             {"content": truncate_str(parsed.remember, 200)},
@@ -1474,6 +615,7 @@ status 取值：
 
                 # 发送 beforecalltext 作为显示文本
                 if before_call:
+                    _v2_reasoning_collected.append(before_call)
                     await self._emit_v2_event(
                         "v2_reasoning",
                         {"content": before_call},
@@ -1552,9 +694,15 @@ status 取值：
             # 核心逻辑: finish=true 表示任务已完成/不需要再调用LLM，即使工具设置了callback=true
             if parsed.finish:
                 logger.info(f"[{task_id}] finish=true，任务已完成，不回调 LLM")
-                final_text = "已完成所有操作。"
-                if current_task_plan:
-                    final_text += f"\n\n任务计划:\n{current_task_plan}"
+                # 构建有意义的最终回复：使用收集到的 reasoning text + 任务计划摘要
+                if _v2_reasoning_collected:
+                    final_text = "\n".join(_v2_reasoning_collected)
+                    if current_task_plan:
+                        final_text += f"\n\n{current_task_plan}"
+                else:
+                    final_text = "已完成所有操作。"
+                    if current_task_plan:
+                        final_text += f"\n\n任务计划:\n{current_task_plan}"
                 context.working_memory["final_response"] = final_text
                 await self._emit_v2_event("v2_reasoning", {"content": truncate_str(final_text, 3000)}, stream_callback)
                 if self.memory:
@@ -1568,9 +716,14 @@ status 取值：
             # finish=false: 根据工具的 callback 标志决定是否回调
             if not need_callback:
                 logger.info(f"[{task_id}] 所有工具无需回调且 finish=false，结束循环")
-                final_text = "已完成所有操作。"
-                if current_task_plan:
-                    final_text += f"\n\n任务计划:\n{current_task_plan}"
+                if _v2_reasoning_collected:
+                    final_text = "\n".join(_v2_reasoning_collected)
+                    if current_task_plan:
+                        final_text += f"\n\n{current_task_plan}"
+                else:
+                    final_text = "已完成所有操作。"
+                    if current_task_plan:
+                        final_text += f"\n\n任务计划:\n{current_task_plan}"
                 context.working_memory["final_response"] = final_text
                 await self._emit_v2_event("v2_reasoning", {"content": truncate_str(final_text, 3000)}, stream_callback)
                 if self.memory: