myagent-ai 1.10.6 → 1.10.7

package/agents/main_agent.py

@@ -48,8 +48,9 @@ class MainAgent(BaseAgent):
 <toolstocal>
 <tool><beforecalltext>连接词，介绍调用什么工具，达到什么目的。</beforecalltext><toolname>工具名</toolname><parms>JSON格式的参数对象，例如: {"query": "搜索关键词", "num": 5}</parms><timeout>预估超时时限(秒)</timeout><callback>true/false,要求解析器在该工具执行完后是否要回调llm大模型，将所有工具输出结果+新构造的"context"输入给llm</callback></tool>
 </toolstocal>
-<remember>仅从最新用户输入（userprint 或 usersays_correct）中提炼值得长期记忆的信息（如用户偏好、重要结论、错误经验等）。不要从历史对话中重复提炼旧记忆。如果本轮用户输入没有新信息需要记忆，则为空。</remember>
+<remember><type>global或session</type><content>仅从最新用户输入（userprint 或 usersays_correct）中提炼值得记忆的信息（如用户偏好、重要结论、错误经验等）。type=global表示跨会话全局记忆，type=session表示仅当前会话可用的记忆。如果本轮没有新信息需要记忆，则<content>为空、<type>不填。</content></remember>
 <recall>下一轮执行需要调取的记忆，这里要设计接上记忆库</recall>
+<knowledge>从本轮对话或工具执行结果中提炼值得长期保存到知识库的专业知识、事实、经验法则、技术要点等。这些知识将被持久化存储，未来可通过 <get_knowledge> 检索复用。如果本轮没有需要保存的知识，则为空。格式要求：简洁明确，每条知识一行，用换行分隔。</knowledge>
 <get_knowledge>下一轮执行时需要从知识库搜索获得的知识，填写检索关键词或描述。如context中已包含充足的<knowledge>内容，则为空。如需更多专业知识支撑，则填写相关搜索词。</get_knowledge>
 <askuser>需要询问用户的内容，如无，则为空</askuser>
 <finish>true/false，是否结束循环调用llm。如"askuser"为非空，则"finish"输出true。否则，根据"context"判断任务是否已完成，是否结束llm回调</finish>
@@ -67,14 +68,15 @@ class MainAgent(BaseAgent):
 6. <parms>: **必须使用严格合法的JSON格式**，例如 {"query": "关键词", "num": 10}，不要使用其他格式
 7. <timeout>: 预估超时秒数（简单操作10-30s，文件操作30-60s，网络请求60-120s，数据处理120-300s）
 8. <callback>: 如果该工具的执行结果对后续决策有影响，设为 true；否则设为 false
-9. <remember>: 仅从最新用户输入（userprint 或 usersays_correct）中提炼值得长期记忆的关键信息，不要重复提炼历史对话中已有的记忆。如果本轮没有新信息需要记忆，则为空
+9. <remember>: 包含 <type> 和 <content> 子标签。type 填 "global"（跨会话全局记忆）或 "session"（仅当前会话）。content 填从最新用户输入中提炼的值得记忆的关键信息。如果本轮无需记忆，content 为空且不填 type。注意：用户个人偏好、重要结论、通用经验用 global；当前任务的临时上下文、过程信息用 session
 10. <recall>: 描述下一轮执行时需要从记忆库中检索的内容关键词
-11. <get_knowledge>: 如果当前 <knowledge> 内容不足以完成任务，填写需要从知识库搜索的关键词；否则为空
-12. <askuser>: 当信息不足需要用户补充时，在此填写要问的问题
-13. <finish>: 当任务已完成或需要等待用户回应时为 true；否则为 false 继续执行
-14. <finish_reason>: **finish=true 时必须填写**，详细说明结束原因（任务完成/等待用户/信息不足/无法处理等）
-15. <next_step>: **finish=false 时必须填写**，描述下一步计划做什么，要求简洁明确（1-2句话）
-16. 使用中文输出所有内容
+11. <knowledge>: 从本轮对话或工具执行结果中提炼值得长期保存的专业知识、事实、经验法则、技术要点等。这些知识会被持久化到知识库文件，未来可通过 get_knowledge 检索复用。如果没有需要保存的知识，则为空。格式：简洁明确，每条知识一行
+12. <get_knowledge>: 如果当前 <knowledge> 内容不足以完成任务，填写需要从知识库搜索的关键词；否则为空
+13. <askuser>: 当信息不足需要用户补充时，在此填写要问的问题
+14. <finish>: 当任务已完成或需要等待用户回应时为 true；否则为 false 继续执行
+15. <finish_reason>: **finish=true 时必须填写**，详细说明结束原因（任务完成/等待用户/信息不足/无法处理等）
+16. <next_step>: **finish=false 时必须填写**，描述下一步计划做什么，要求简洁明确（1-2句话）
+17. 使用中文输出所有内容
 
 ## 工具选择指南
 - **搜索信息**: 用 `web_search`（返回标题+URL+摘要），不要用 browser_open
@@ -261,6 +263,108 @@ class MainAgent(BaseAgent):
             logger.warning(f"[{task_id}] 记忆合并异常: {e}")
             return None
 
+    async def _save_knowledge_to_base(
+        self,
+        content: str,
+        session_id: str,
+        task_id: str,
+    ) -> bool:
+        """
+        将 LLM 输出的 <knowledge> 内容追加到知识库文件。
+
+        存储策略:
+        - 知识按会话 (session_id) 分文件存储
+        - 文件路径: {knowledge_base_dir}/auto_knowledge/{session_id}.md
+        - 每次追加时检查重复（TF-IDF 相似度 ≥ 0.9 视为重复，跳过）
+        - 追加时带有时间戳标记
+
+        Returns:
+            True 表示成功存储了新知识，False 表示跳过（重复）或失败
+        """
+        if not self.context_builder or not self.context_builder.knowledge_base_dir:
+            logger.debug(f"[{task_id}] 知识库未配置，跳过 knowledge 存储")
+            return False
+
+        from datetime import datetime
+        from pathlib import Path
+
+        kb_dir = Path(self.context_builder.knowledge_base_dir)
+        auto_kb_dir = kb_dir / "auto_knowledge"
+        auto_kb_dir.mkdir(parents=True, exist_ok=True)
+
+        # 使用 session_id 作为文件名（取前8位避免过长）
+        safe_session = session_id.replace("-", "")[:8] if session_id else "default"
+        kb_file = auto_kb_dir / f"{safe_session}.md"
+
+        now_str = datetime.now().strftime("%Y-%m-%d %H:%M")
+
+        # 检查重复：与已有文件内容做相似度比较
+        existing_content = ""
+        if kb_file.exists():
+            try:
+                existing_content = kb_file.read_text(encoding="utf-8")
+            except Exception:
+                existing_content = ""
+
+        if existing_content and content.strip():
+            # 简单去重：检查新知识是否已存在于文件中
+            # 使用逐行比对 + 关键词匹配
+            new_lines = [line.strip() for line in content.strip().split("\n") if line.strip()]
+            existing_lines = [line.strip() for line in existing_content.split("\n") if line.strip() and not line.strip().startswith("- [")]
+
+            dup_count = 0
+            for new_line in new_lines:
+                # 精确匹配或高度相似（共现字符占比 > 85%）
+                is_dup = False
+                for ex_line in existing_lines:
+                    # 计算字符重叠率
+                    set_new = set(new_line)
+                    set_ex = set(ex_line)
+                    if not set_new or not set_ex:
+                        continue
+                    overlap = len(set_new & set_ex) / max(len(set_new), len(set_ex))
+                    if overlap >= 0.85 or new_line == ex_line:
+                        is_dup = True
+                        break
+                if is_dup:
+                    dup_count += 1
+
+            if dup_count == len(new_lines):
+                logger.info(f"[{task_id}] 知识全部重复，跳过存储 ({dup_count}/{len(new_lines)} 条)")
+                return False
+            elif dup_count > 0:
+                # 过滤掉重复的行
+                filtered_lines = []
+                for new_line in new_lines:
+                    is_dup = False
+                    for ex_line in existing_lines:
+                        set_new = set(new_line)
+                        set_ex = set(ex_line)
+                        if not set_new or not set_ex:
+                            continue
+                        overlap = len(set_new & set_ex) / max(len(set_new), len(set_ex))
+                        if overlap >= 0.85 or new_line == ex_line:
+                            is_dup = True
+                            break
+                    if not is_dup:
+                        filtered_lines.append(new_line)
+                content = "\n".join(filtered_lines)
+                logger.info(f"[{task_id}] 知识去重: {dup_count}/{len(new_lines)} 条重复，{len(filtered_lines)} 条新增")
+
+        # 追加写入
+        try:
+            with open(kb_file, "a", encoding="utf-8") as f:
+                f.write(f"\n## {now_str}\n")
+                f.write(content.strip() + "\n")
+            logger.info(
+                f"[{task_id}] 知识已存入知识库: {kb_file.name} "
+                f"({len(content)} 字符, {len(content.strip().split(chr(10)))} 条)"
+            )
+            return True
+        except Exception as e:
+            logger.warning(f"[{task_id}] 知识写入失败: {e}")
+            return False
+
     async def process_v2(
         self,
         context: AgentContext,
@@ -402,6 +506,7 @@ class MainAgent(BaseAgent):
                 task_plan=current_task_plan,
                 agent_override_prompt=agent_override_prompt,
                 get_knowledge=get_knowledge_content,
+                recall=recall_content,
             )
 
             await self._emit_v2_event(
@@ -517,77 +622,92 @@ class MainAgent(BaseAgent):
                 if response_text:
                     logger.debug(f"[{task_id}] 模型回复用户: {response_text[:100]}")
                     context.working_memory["model_response"] = response_text
+                    _v2_reasoning_collected.append(response_text)
                     await self._emit_v2_event(
                         "v2_reasoning",
                         {"content": response_text},
                         stream_callback,
                     )
 
-            # Step 6: 处理 remember — 查重+LLM合并后存入长期记忆
+            # Step 6: 处理 remember — 按 type 分全局/会话存储
             if parsed.remember:
                 try:
                     if self.memory:
-                        # 查找是否有相似记忆
-                        dup_memory = self.memory.find_duplicate_memory(
-                            content=parsed.remember,
-                            session_id=context.session_id,
-                            key="conversation_insight",
-                        )
-                        if dup_memory:
-                            # 发现相似记忆 → 调用 LLM API 合并新旧记忆
-                            logger.info(
-                                f"[{task_id}] 记忆查重: 发现相似内容，调用LLM合并 "
-                                f"(旧记忆ID={dup_memory.id}, 创建于={dup_memory.created_at})"
-                            )
-                            merged_content = await self._merge_duplicate_memory(
-                                old_memory=dup_memory,
-                                new_content=parsed.remember,
-                                context=context,
-                                task_id=task_id,
+                        _rem_type = parsed.remember_type or "session"
+
+                        if _rem_type == "global":
+                            # === 全局记忆：查重 + LLM 合并 → add_global ===
+                            dup_memory = self.memory.find_duplicate_memory(
+                                content=parsed.remember,
+                                session_id=context.session_id,
+                                key="conversation_insight",
                             )
-                            if merged_content:
-                                # 用 LLM 合并后的内容替换旧记忆
-                                self.memory.update_memory(
-                                    memory_id=dup_memory.id,
-                                    content=merged_content,
-                                    summary=truncate_str(merged_content, 200),
+                            if dup_memory:
+                                logger.info(
+                                    f"[{task_id}] 全局记忆查重: 发现相似内容，调用LLM合并 "
+                                    f"(旧记忆ID={dup_memory.id}, 创建于={dup_memory.created_at})"
                                 )
-                                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(
+                                merged_content = await self._merge_duplicate_memory(
+                                    old_memory=dup_memory,
+                                    new_content=parsed.remember,
+                                    context=context,
                                     task_id=task_id,
-                                    session_id=context.session_id,
-                                    metadata={
-                                        "memory_action": "save",
-                                        "content": parsed.remember,
-                                    },
                                 )
-                                await self.memory_agent.process(mem_ctx)
+                                if merged_content:
+                                    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:
+                                    self.memory.update_memory(
+                                        memory_id=dup_memory.id,
+                                        content=parsed.remember,
+                                    )
+                                    logger.info(f"[{task_id}] 全局记忆直接更新: {dup_memory.id}")
                             else:
-                                self.memory.add_long_term(
+                                self.memory.add_global(
                                     session_id=context.session_id,
                                     key="conversation_insight",
                                     content=parsed.remember,
                                     summary=truncate_str(parsed.remember, 200),
                                     importance=0.7,
                                 )
+                        else:
+                            # === 会话记忆：直接存储 → add_session ===
+                            self.memory.add_session(
+                                session_id=context.session_id,
+                                key="conversation_insight",
+                                content=parsed.remember,
+                                importance=0.6,
+                            )
+
                         await self._emit_v2_event(
                             "v2_memory_saved",
-                            {"content": truncate_str(parsed.remember, 200)},
+                            {"type": _rem_type, "content": truncate_str(parsed.remember, 200)},
                             stream_callback,
                         )
                 except Exception as e:
                     logger.warning(f"[{task_id}] 存入记忆失败: {e}")
 
+            # Step 6.5: 处理 knowledge — 存入知识库文件
+            if parsed.knowledge:
+                try:
+                    kb_saved = await self._save_knowledge_to_base(
+                        content=parsed.knowledge,
+                        session_id=context.session_id,
+                        task_id=task_id,
+                    )
+                    if kb_saved:
+                        await self._emit_v2_event(
+                            "v2_knowledge_saved",
+                            {"content": truncate_str(parsed.knowledge, 200)},
+                            stream_callback,
+                        )
+                except Exception as e:
+                    logger.warning(f"[{task_id}] 存入知识库失败: {e}")
+
             # Step 7: 处理 recall — 记录下一轮需要检索的记忆内容
             if parsed.recall:
                 recall_content = parsed.recall
@@ -660,6 +780,7 @@ class MainAgent(BaseAgent):
             # Step 11: 有工具调用 — 先执行所有工具，再根据 finish 决定回调
             need_callback = False
             tool_outputs_parts = []
+            _reasoning_len_before_round = len(_v2_reasoning_collected)  # 记录本轮开始时的长度
 
             for tool_info in parsed.tools_to_call:
                 tool_name = tool_info.get("toolname", "").strip()
@@ -706,38 +827,103 @@ class MainAgent(BaseAgent):
 
                 # 发送工具结果事件
                 # 提取实际输出：SkillResult 有 output/message/data，ExecResult 有 stdout/stderr
-                def _format_data_for_llm(data):
-                    """将结构化 data 格式化为 LLM 可读的文本"""
-                    if data is None:
+                def _format_data_for_llm(data, _depth=0):
+                    """将结构化 data 递归格式化为 LLM 可读的文本"""
+                    _MAX_DEPTH = 3
+                    _MAX_LIST_ITEMS = 50
+
+                    if data is None or _depth > _MAX_DEPTH:
                         return ""
                     if isinstance(data, str):
                         return data
+                    if isinstance(data, (int, float, bool)):
+                        return str(data)
+
+                    if isinstance(data, list):
+                        lines = []
+                        for i, item in enumerate(data[:_MAX_LIST_ITEMS], 1):
+                            if isinstance(item, dict):
+                                # 优先提取名称类字段作为主标题
+                                name = (
+                                    item.get("name") or item.get("title")
+                                    or item.get("text") or item.get("path")
+                                    or item.get("file") or item.get("url") or ""
+                                )
+                                # 其余字段作为详细信息
+                                detail_parts = []
+                                for k, v in item.items():
+                                    if k in ("name", "title", "text") and name:
+                                        continue
+                                    if v is None or v == "" or v == []:
+                                        continue
+                                    if isinstance(v, (list, dict)):
+                                        sub = _format_data_for_llm(v, _depth + 1)
+                                        if sub:
+                                            detail_parts.append(f"{k}={sub}")
+                                    else:
+                                        detail_parts.append(f"{k}={v}")
+                                detail = ", ".join(detail_parts)
+                                lines.append(
+                                    f"{i}. {name}" + (f" ({detail})" if detail else "")
+                                )
+                            elif isinstance(item, (list, dict)):
+                                sub = _format_data_for_llm(item, _depth + 1)
+                                lines.append(f"{i}. {sub}" if sub else f"{i}. (空)")
+                            else:
+                                lines.append(f"{i}. {item}")
+                        if len(data) > _MAX_LIST_ITEMS:
+                            lines.append(f"... 共 {len(data)} 项，仅显示前 {_MAX_LIST_ITEMS} 项")
+                        return "\n".join(lines)
+
                     if isinstance(data, dict):
                         # 搜索结果列表格式 (web_search)
                         results = data.get("results")
                         if isinstance(results, list):
                             lines = []
-                            for i, r in enumerate(results, 1):
-                                title = r.get("title", "")
-                                url = r.get("url", "")
-                                snippet = r.get("snippet", "")
-                                lines.append(f"{i}. {title}\n   URL: {url}\n   {snippet}")
+                            for i, r in enumerate(results[:_MAX_LIST_ITEMS], 1):
+                                if isinstance(r, dict):
+                                    title = r.get("title", "")
+                                    url = r.get("url", "")
+                                    snippet = r.get("snippet", "")
+                                    lines.append(
+                                        f"{i}. {title}\n   URL: {url}\n   {snippet}"
+                                    )
+                                else:
+                                    lines.append(f"{i}. {r}")
                             return "\n".join(lines)
+
                         # 网页内容格式 (web_read)
                         if "url" in data and "content" in data:
                             title = data.get("title", "")
                             content = data.get("content", "")
-                            lines = [f"标题: {title}", f"URL: {data['url']}", f"内容:\n{content}"]
+                            lines = [
+                                f"标题: {title}",
+                                f"URL: {data['url']}",
+                                f"内容:\n{content}",
+                            ]
                             return "\n".join(lines)
-                        # 通用 dict: key-value 格式
+
+                        # 通用 dict: 递归格式化嵌套结构
                         parts = []
                         for k, v in data.items():
                             if k == "results":
                                 continue  # 已在上面处理
-                            parts.append(f"{k}: {v}")
+                            if isinstance(v, list):
+                                if len(v) == 0:
+                                    parts.append(f"{k}: (空)")
+                                else:
+                                    sub = _format_data_for_llm(v, _depth + 1)
+                                    parts.append(f"{k}:\n{sub}")
+                            elif isinstance(v, dict):
+                                if not v:
+                                    parts.append(f"{k}: (空)")
+                                else:
+                                    sub = _format_data_for_llm(v, _depth + 1)
+                                    parts.append(f"{k}:\n{sub}")
+                            else:
+                                parts.append(f"{k}: {v}")
                         return "\n".join(parts) if parts else str(data)
-                    if isinstance(data, list):
-                        return "\n".join(str(item) for item in data)
+
                     return str(data)
 
                 def _extract_tool_output(tr):
@@ -790,8 +976,20 @@ class MainAgent(BaseAgent):
                     need_callback = True
 
                 output_str = tool_output_text
-                # 搜索和网页读取类工具允许更长的输出
-                _max_output = 6000 if tool_name in ("web_search", "web_read", "url_read") else 3000
+                # 数据密集型工具允许更长的输出
+                _HEAVY_TOOLS = ("web_search", "web_read", "url_read", "file_list",
+                                "file_search", "browser_open", "process_list")
+                # OpenClaw prompt-only 技能也允许较长输出（SKILL.md 指令）
+                _is_openclaw = (
+                    isinstance(tool_result.get("data"), dict)
+                    and tool_result.get("data", {}).get("skill_type") == "openclaw"
+                )
+                if tool_name in _HEAVY_TOOLS:
+                    _max_output = 6000
+                elif _is_openclaw:
+                    _max_output = 8000
+                else:
+                    _max_output = 3000
                 tool_outputs_parts.append(
                     f"### {before_call}\n"
                     f"**工具**: {tool_name}\n"
@@ -831,8 +1029,15 @@ class MainAgent(BaseAgent):
             # 核心逻辑: finish=true 表示任务已完成/不需要再调用LLM，即使工具设置了callback=true
             if parsed.finish:
                 logger.info(f"[{task_id}] finish=true，任务已完成，不回调 LLM")
-                # 构建有意义的最终回复：使用收集到的 reasoning text + 任务计划摘要
-                if _v2_reasoning_collected:
+                # 构建有意义的最终回复：使用当前轮次的 reasoning text + 任务计划摘要
+                # 注意：之前回调时已保存前几轮的文本，这里只保存当前轮次新增的部分
+                _current_round = _v2_reasoning_collected[_reasoning_len_before_round:]
+                if _current_round:
+                    final_text = "\n".join(_current_round)
+                    if current_task_plan:
+                        final_text += f"\n\n{current_task_plan}"
+                elif _v2_reasoning_collected:
+                    # 没有回调历史（第一轮就 finish），保存全部
                     final_text = "\n".join(_v2_reasoning_collected)
                     if current_task_plan:
                         final_text += f"\n\n{current_task_plan}"
@@ -853,7 +1058,13 @@ class MainAgent(BaseAgent):
             # finish=false: 根据工具的 callback 标志决定是否回调
             if not need_callback:
                 logger.info(f"[{task_id}] 所有工具无需回调且 finish=false，结束循环")
-                if _v2_reasoning_collected:
+                # 只保存当前轮次新增的文本（前几轮已通过回调保存）
+                _current_round = _v2_reasoning_collected[_reasoning_len_before_round:]
+                if _current_round:
+                    final_text = "\n".join(_current_round)
+                    if current_task_plan:
+                        final_text += f"\n\n{current_task_plan}"
+                elif _v2_reasoning_collected:
                     final_text = "\n".join(_v2_reasoning_collected)
                     if current_task_plan:
                         final_text += f"\n\n{current_task_plan}"
@@ -873,6 +1084,30 @@ class MainAgent(BaseAgent):
 
             logger.info(f"[{task_id}] finish=false 且 need_callback=true，回调 LLM...")
 
+            # 回调前，保存当前轮次的 LLM 输出到短期记忆
+            # 这样每轮工具调用都有对应的 assistant 消息记录
+            if self.memory:
+                _round_items = _v2_reasoning_collected[_reasoning_len_before_round:]
+                if _round_items:
+                    _round_output = "\n".join(_round_items)
+                    if _round_output.strip():
+                        self.memory.add_short_term(
+                            session_id=context.session_id,
+                            role="assistant",
+                            content=_round_output,
+                        )
+
+        # 循环正常结束（max_iter 耗尽）时兜底保存
+        else:
+            if self.memory and _v2_reasoning_collected:
+                _fallback_text = "\n".join(_v2_reasoning_collected)
+                if _fallback_text.strip():
+                    self.memory.add_short_term(
+                        session_id=context.session_id,
+                        role="assistant",
+                        content=_fallback_text,
+                    )
+
         context.working_memory["iterations"] = self._iteration_count
         if current_task_plan:
             context.working_memory["task_plan"] = current_task_plan

package/agents/memory_agent.py

@@ -22,9 +22,9 @@ class MemoryAgent(BaseAgent):
     记忆管理 Agent。
 
     职责:
-      - 对话上下文管理(短期记忆)
-      - 任务进度跟踪(工作记忆)
-      - 知识/经验存储(长期记忆)
+      - 对话上下文管理(会话记忆 session)
+      - 任务进度跟踪(会话记忆 session)
+      - 知识/经验存储(全局记忆 global)
       - 记忆检索与总结
       - 错误模式记录(避免重复犯错)
     """
@@ -101,14 +101,14 @@ class MemoryAgent(BaseAgent):
         return context
 
     async def _save_conversation(self, context: AgentContext, session_id: str):
-        """保存对话消息到短期记忆"""
+        """保存对话消息到会话记忆"""
         if not self.memory:
             return
 
         for msg in context.conversation_history:
             if msg.role in ("user", "assistant", "system", "tool"):
                 # 避免重复保存
-                self.memory.add_short_term(
+                self.memory.add_session(
                     session_id=session_id,
                     role=msg.role,
                     content=msg.content,
@@ -119,7 +119,7 @@ class MemoryAgent(BaseAgent):
         max_msgs = self.config.memory.max_short_term
         self.memory.prune_conversation(session_id, max_msgs)
 
-        logger.debug(f"对话已保存到短期记忆 (session={session_id})")
+        logger.debug(f"对话已保存到会话记忆 (session={session_id})")
 
     async def _get_context(self, context: AgentContext, session_id: str):
         """获取对话上下文"""
@@ -133,25 +133,27 @@ class MemoryAgent(BaseAgent):
         logger.debug(f"已加载对话上下文: {len(entries)} 条")
 
     async def _save_progress(self, context: AgentContext, session_id: str):
-        """保存任务进度到工作记忆"""
+        """保存任务进度到会话记忆"""
         if not self.memory:
             return
 
         progress = context.metadata.get("progress_data", {})
         for key, value in progress.items() if isinstance(progress, dict) else []:
-            self.memory.add_working(
+            self.memory.add_session(
                 session_id=session_id,
                 key=key,
                 content=str(value) if not isinstance(value, str) else value,
+                importance=0.7,
             )
 
         # 也保存整体状态
         task_status = context.working_memory.get("task_status", "进行中")
-        self.memory.add_working(
+        self.memory.add_session(
             session_id=session_id,
             key="task_status",
             content=task_status,
             metadata=context.working_memory,
+            importance=0.7,
         )
         logger.debug(f"工作进度已保存 (session={session_id})")
 
@@ -230,7 +232,7 @@ class MemoryAgent(BaseAgent):
             # 保存偏好
             preferences = result.get("preferences", {})
             for key, value in preferences.items():
-                self.memory.add_long_term(
+                self.memory.add_global(
                     session_id="global",
                     key="user_pref",
                     content=f"{key}: {value}",
@@ -278,7 +280,7 @@ class MemoryAgent(BaseAgent):
         pref_key = context.metadata.get("pref_key", "")
         pref_value = context.metadata.get("pref_value", "")
         if pref_key and pref_value:
-            self.memory.add_long_term(
+            self.memory.add_global(
                 session_id="global",
                 key="user_pref",
                 content=f"{pref_key}: {pref_value}",
@@ -293,9 +295,9 @@ class MemoryAgent(BaseAgent):
 
         query = context.user_message
 
-        # 搜索长期记忆
-        long_term = self.memory.search(
-            query, session_id="", category="long_term", limit=5
+        # 搜索全局记忆
+        global_memories = self.memory.search(
+            query, session_id="", category="global", limit=5
         )
         # 搜索错误模式
         errors = self.memory.get_error_patterns(session_id="global", limit=3)
@@ -303,9 +305,9 @@ class MemoryAgent(BaseAgent):
         prefs = self.memory.get_preferences(session_id="global")
 
         context.working_memory["relevant_memories"] = {
-            "long_term": [
+            "global": [
                 {"content": e.content[:500], "key": e.key, "summary": e.summary}
-                for e in long_term
+                for e in global_memories
             ],
             "error_patterns": [
                 {"content": e.content[:300]} for e in errors
@@ -325,9 +327,9 @@ class MemoryAgent(BaseAgent):
             context_parts.append("\n## 历史错误(避免重复)")
             context_parts.extend(f"- {e.content[:200]}" for e in errors)
 
-        if long_term:
+        if global_memories:
             context_parts.append("\n## 相关经验")
-            context_parts.extend(f"- {e.summary or e.content[:200]}" for e in long_term)
+            context_parts.extend(f"- {e.summary or e.content[:200]}" for e in global_memories)
 
         if context_parts:
             context.working_memory["memory_context_prompt"] = "\n".join(context_parts)

package/config.py

@@ -45,11 +45,16 @@ class LLMConfig:
 class MemoryConfig:
     """记忆系统配置"""
     db_path: str = ""                  # SQLite 数据库路径，默认 ~/.myagent/memory.db
-    max_short_term: int = 50           # 短期记忆最大轮数
-    max_working: int = 100             # 工作记忆最大条数
+    max_session: int = 50              # 会话记忆最大对话轮数
+    max_working: int = 100             # 任务进度最大条数
     auto_summarize: bool = True        # 自动总结开关
     summarize_threshold: int = 20      # 触发总结的对话轮数
 
+    # 兼容旧配置名
+    @property
+    def max_short_term(self) -> int:
+        return self.max_session
+
 
 @dataclass
 class ExecutorConfig: