myagent-ai 1.12.0 → 1.12.3

package/agents/main_agent.py

@@ -49,7 +49,7 @@ class MainAgent(BaseAgent):
 <tool><beforecalltext>连接词，介绍调用什么工具，达到什么目的。</beforecalltext><toolname>工具名</toolname><parms>JSON格式的参数对象，例如: {"query": "搜索关键词", "num": 5}</parms><timeout>预估超时时限(秒)</timeout><callback>true/false,要求解析器在该工具执行完后是否要回调llm大模型，将所有工具输出结果+新构造的"context"输入给llm</callback></tool>
 </toolstocal>
 <remember><type>global或session</type><content>仅从最新用户输入（userprint 或 usersays_correct）中提炼值得记忆的信息（如用户偏好、重要结论、错误经验等）。type=global表示跨会话全局记忆，type=session表示仅当前会话可用的记忆。如果本轮没有新信息需要记忆，则<content>为空、<type>不填。</content></remember>
-<recall>下一轮执行需要调取的记忆，这里要设计接上记忆库</recall>
+<recall>下一轮需要主动召回的记忆描述。填写需要从记忆库中检索的关键字或描述。如果不填写则为空。如果需要更多记忆支持当前任务，填写相关关键词（可包含时间参考，如"2025年1月的项目"），系统将在下一轮搜索top5相关记忆并通过<recall_memory>注入上下文。你也可以直接调用recall_memory工具即时搜索。</recall>
 <knowledge>从本轮对话或工具执行结果中提炼值得长期保存到知识库的专业知识、事实、经验法则、技术要点等。这些知识将被持久化存储，未来可通过 <get_knowledge> 检索复用。如果本轮没有需要保存的知识，则为空。格式要求：简洁明确，每条知识一行，用换行分隔。</knowledge>
 <get_knowledge>下一轮执行时需要从知识库搜索获得的知识，填写检索关键词或描述。如context中已包含充足的<knowledge>内容，则为空。如需更多专业知识支撑，则填写相关搜索词。</get_knowledge>
 <askuser>需要询问用户的内容，如无，则为空</askuser>
@@ -69,7 +69,7 @@ class MainAgent(BaseAgent):
 7. <timeout>: 预估超时秒数（简单操作10-30s，文件操作30-60s，网络请求60-120s，数据处理120-300s）
 8. <callback>: 如果该工具的执行结果对后续决策有影响，设为 true；否则设为 false
 9. <remember>: 包含 <type> 和 <content> 子标签。type 填 "global"（跨会话全局记忆）或 "session"（仅当前会话）。content 填从最新用户输入中提炼的值得记忆的关键信息。如果本轮无需记忆，content 为空且不填 type。注意：用户个人偏好、重要结论、通用经验用 global；当前任务的临时上下文、过程信息用 session
-10. <recall>: 描述下一轮执行时需要从记忆库中检索的内容关键词
+10. <recall>: 填写下一轮需要从记忆库中主动召回的内容描述和关键字（可包含时间参考）。系统将根据这些信息搜索top5相关记忆，在下一轮通过 <recall_memory> 标签注入上下文。如果当前 <automemory> 中的记忆已足够完成任务，<recall> 为空；如果需要更多历史记忆支撑，则填写。你也可以直接使用 recall_memory 工具在当前轮即时搜索
 11. <knowledge>: 从本轮对话或工具执行结果中提炼值得长期保存的专业知识、事实、经验法则、技术要点等。这些知识会被持久化到知识库文件，未来可通过 get_knowledge 检索复用。如果没有需要保存的知识，则为空。格式：简洁明确，每条知识一行
 12. <get_knowledge>: 如果当前 <knowledge> 内容不足以完成任务，填写需要从知识库搜索的关键词；否则为空
 13. <askuser>: 当信息不足需要用户补充时，在此填写要问的问题
@@ -78,6 +78,11 @@ class MainAgent(BaseAgent):
 16. <next_step>: **finish=false 时必须填写**，描述下一步计划做什么，要求简洁明确（1-2句话）
 17. 使用中文输出所有内容
 
+## 上下文中的记忆系统说明
+- <automemory>: 系统自动根据你通过 <remember> 保存的记忆和当前用户输入，搜索出的 top10 相关记忆。这些是你过去主动记住的内容（包含时间信息），可供参考。
+- <recall_memory>: 你在上一轮通过 <recall> 指定的记忆搜索结果。系统根据你提供的关键字和时间点搜索了 top5 相关记忆。
+- 两种记忆互补：automemory 是自动匹配的，recall_memory 是你主动指定搜索的。如果 automemory 不足，使用 <recall> 请求更多。
+
 ## 工具选择指南
 - **搜索信息**: 用 `web_search`（返回标题+URL+摘要），不要用 browser_open
 - **读取网页内容**: 用 `web_read`（传入URL，提取正文）
@@ -85,6 +90,7 @@ class MainAgent(BaseAgent):
 - **执行代码**: 用 `code` 工具（language: python/javascript/shell）
 - **执行命令**: 用 `command` 或 `command_run` 工具
 - **文件操作**: 用 `file_read` / `file_write` / `file_list` 等文件工具
+- **主动召回记忆**: 用 `recall_memory` 工具（参数: keyword=关键字, time_point=可选时间点如"2025-01", limit=数量默认5），根据关键字和时间搜索历史记忆
 """
 
     def __init__(self, tool_agent=None, memory_agent=None, **kwargs):
@@ -553,7 +559,7 @@ class MainAgent(BaseAgent):
             llm_raw = response.content
             logger.debug(f"[{task_id}] LLM 输出 (前500字): {llm_raw[:500]}")
 
-            # 保存 LLM 原始输出到会话记忆（用于回溯和审计）
+            # 保存 LLM 原始输出到会话记忆（用于回溯和审计，key=llm_output 不出现在对话历史中）
             if self.memory:
                 self.memory.add_session(
                     session_id=context.session_id,
@@ -752,31 +758,20 @@ class MainAgent(BaseAgent):
 
             # Step 10: 执行工具调用（无论 finish 值如何，先执行工具）
             if not parsed.tools_to_call:
-                # 无工具调用: 直接根据 finish 判断是否结束
-                if parsed.finish:
-                    logger.info(f"[{task_id}] finish=true 且无工具调用，结束循环")
-                    before, after = extract_surrounding_text(llm_raw)
-                    final_text = (before + "\n" + after).strip() if (before.strip() or after.strip()) else "任务已完成。"
-                    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:
-                        self.memory.add_session(
-                            session_id=context.session_id,
-                            role="assistant",
-                            content=final_text,
-                        )
+                # 无工具调用: 优先使用已收集的 reasoning 文本（包含 parsed.response），避免丢失第一轮输出
+                if _v2_reasoning_collected:
+                    final_text = "\n".join(_v2_reasoning_collected)
                 else:
-                    logger.info(f"[{task_id}] 无工具调用且 finish=false，结束")
                     before, after = extract_surrounding_text(llm_raw)
-                    final_text = (before + "\n" + after).strip() if (before.strip() or after.strip()) else "处理完毕。"
-                    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:
-                        self.memory.add_session(
-                            session_id=context.session_id,
-                            role="assistant",
-                            content=final_text,
-                        )
+                    final_text = (before + "\n" + after).strip() if (before.strip() or after.strip()) else "任务已完成。"
+                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:
+                    self.memory.add_session(
+                        session_id=context.session_id,
+                        role="assistant",
+                        content=final_text,
+                    )
                 break
 
             # Step 11: 有工具调用 — 先执行所有工具，再根据 finish 决定回调
@@ -981,15 +976,8 @@ class MainAgent(BaseAgent):
                 # 数据密集型工具允许更长的输出
                 _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(
@@ -1168,6 +1156,34 @@ class MainAgent(BaseAgent):
                 else:
                     result["error"] = "执行引擎未初始化"
 
+            elif tool_name == "recall_memory":
+                # === 主动召回记忆工具 ===
+                # 根据 memory_agent.recall_memory() 搜索历史记忆
+                try:
+                    if self.memory_agent:
+                        recall_results = await self.memory_agent.recall_memory(
+                            keyword=params.get("keyword", ""),
+                            time_point=params.get("time_point", ""),
+                            session_id=params.get("session_id", ""),
+                            limit=params.get("limit", 5),
+                        )
+                        if recall_results:
+                            output_lines = [f"找到 {len(recall_results)} 条相关记忆:"]
+                            for i, mem in enumerate(recall_results, 1):
+                                output_lines.append(
+                                    f"{i}. [{mem.get('created_at', '')}] "
+                                    f"[{mem.get('category', '')}] "
+                                    f"{mem.get('content', '')}"
+                                )
+                            result = {"success": True, "output": "\n".join(output_lines), "data": recall_results}
+                        else:
+                            result = {"success": True, "output": "未找到相关记忆", "data": []}
+                    else:
+                        result = {"success": False, "error": "记忆系统未初始化"}
+                except Exception as re_err:
+                    result = {"success": False, "error": f"记忆召回失败: {re_err}"}
+                    logger.warning(f"[{task_id}] recall_memory 工具异常: {re_err}")
+
             elif self.skills:
                 exec_result = await self.skills.execute(tool_name, **params)
                 result = exec_result.to_dict()

package/agents/memory_agent.py

@@ -333,3 +333,91 @@ class MemoryAgent(BaseAgent):
 
         if context_parts:
             context.working_memory["memory_context_prompt"] = "\n".join(context_parts)
+
+    async def recall_memory(
+        self,
+        keyword: str = "",
+        time_point: str = "",
+        session_id: str = "",
+        limit: int = 5,
+    ) -> list:
+        """
+        主动召回记忆 —— 根据关键字和时间点搜索历史记忆。
+
+        这是供大模型通过 <recall> 标签调用的工具方法。
+        搜索范围包括全局记忆和会话记忆。
+
+        Args:
+            keyword: 搜索关键字（必填，用于模糊匹配和语义搜索）
+            time_point: 时间参考点（可选），格式如 "2025-01" 或 "2025-01-15"
+                        系统会将其转换为 start_time 进行时间范围过滤
+            session_id: 会话 ID（可选，为空则跨会话搜索）
+            limit: 返回数量（默认 5）
+
+        Returns:
+            匹配的记忆列表，每项包含 content, created_at, key, category
+        """
+        if not self.memory:
+            return []
+
+        # 解析 time_point 为 start_time
+        start_time = ""
+        if time_point:
+            # 支持多种格式: "2025-01", "2025-01-15", "2025年1月"
+            import re as _re
+            # 尝试 "YYYY年MM月" 格式
+            m = _re.match(r"(\d{4})年(\d{1,2})月", time_point)
+            if m:
+                start_time = f"{m.group(1)}-{int(m.group(2)):02d}-01 00:00:00"
+            else:
+                # 尝试 "YYYY-MM" 或 "YYYY-MM-DD"
+                m = _re.match(r"(\d{4})-(\d{1,2})(?:-(\d{1,2}))?", time_point)
+                if m:
+                    year = m.group(1)
+                    month = int(m.group(2))
+                    day = m.group(3)
+                    if day:
+                        start_time = f"{year}-{month:02d}-{int(day):02d} 00:00:00"
+                    else:
+                        start_time = f"{year}-{month:02d}-01 00:00:00"
+
+        # 使用 search_by_time_range 进行精确搜索
+        if start_time or keyword:
+            results = self.memory.search_by_time_range(
+                session_id=session_id,
+                start_time=start_time,
+                keyword=keyword,
+                limit=limit,
+            )
+            if results:
+                return [
+                    {
+                        "content": e.content,
+                        "created_at": e.created_at,
+                        "key": e.key,
+                        "category": e.category,
+                        "summary": e.summary,
+                    }
+                    for e in results
+                ]
+
+        # 回退到普通搜索
+        if keyword:
+            results = self.memory.search(
+                query=keyword,
+                session_id=session_id,
+                limit=limit,
+                mode="hybrid",
+            )
+            return [
+                {
+                    "content": e.content,
+                    "created_at": e.created_at,
+                    "key": e.key,
+                    "category": e.category,
+                    "summary": e.summary,
+                }
+                for e in results
+            ]
+
+        return []

package/core/context_builder.py

@@ -4,14 +4,15 @@ core/context_builder.py - 上下文构建器
 为 LLM 系统提示词构建结构化的 XML <context> 块。
 
 <context> 包含以下段落:
-  <whomi>         - Agent 身份信息（名称、描述）
-  <memory>        - 记忆检索结果（Top 10 相关记忆）
-  <knowledge>     - 知识库 RAG 检索结果（根据 get_knowledge 关键词搜索）
-  <resentdialog>  - 近期对话历史（截断至 ~20K 字符）
-  <userprint>     - 用户键盘输入文本（语音输入时为空）
-  <usersays>      - 用户语音转文本输入（键盘输入时为空）
-  <task_plan>     - 当前任务计划（Markdown 格式，上轮已完成时为空）
-  <tools>         - 可用工具列表（名称、描述、参数格式）
+  <whomi>            - Agent 身份信息（名称、描述）
+  <automemory>       - 自动记忆检索结果（Top 10 相关记忆，由 <remember> 产生）
+  <recall_memory>    - 主动召回记忆（上一轮 <recall> 触发的 Top 5 记忆）
+  <knowledge>        - 知识库 RAG 检索结果（根据 get_knowledge 关键词搜索）
+  <resentdialog>     - 近期对话历史（截断至 ~20K 字符）
+  <userprint>        - 用户键盘输入文本（语音输入时为空）
+  <usersays>         - 用户语音转文本输入（键盘输入时为空）
+  <task_plan>        - 当前任务计划（Markdown 格式，上轮已完成时为空）
+  <tools>            - 可用工具列表（名称、描述、参数格式）
 
 使用示例:
     builder = ContextBuilder(memory_manager=mm, skill_registry=sr)
@@ -51,6 +52,12 @@ class ContextBuilder:
 
     该 XML 块会注入到 LLM 系统提示词中，为模型提供完整的上下文感知能力。
 
+    上下文中的记忆分为两层:
+      - <automemory>: 自动记忆 —— 由大模型 <remember> 产生并持久化的记忆，
+        根据用户当前输入自动搜索 top10 相关记忆供参考。
+      - <recall_memory>: 主动召回记忆 —— 大模型在上一轮通过 <recall> 标签
+        指定要召回的记忆，系统根据关键字+时间搜索 top5 注入。
+
     Args:
         memory_manager: 记忆管理器实例（可选，传入后可检索相关记忆）
         skill_registry: 技能注册表实例（可选，传入后可列出可用工具）
@@ -200,51 +207,102 @@ class ContextBuilder:
 
     def _build_memory(self, query: str, session_id: str, recall: str = "") -> str:
         """
-        构建 <memory> 段落 —— 记忆检索结果。
+        构建 <automemory> 和 <recall_memory> 段落 —— 双层记忆检索结果。
+
+        <automemory>: 根据用户当前输入自动搜索 top10 相关记忆。
+            这些记忆来自大模型通过 <remember> 标签持久化的内容（包含时间信息）。
+            搜索范围: 全局记忆(global) + 当前会话的 remember 类记忆。
 
-        使用 MemoryManager 的混合搜索 (keyword + TF-IDF) 检索
-        与当前查询最相关的 Top 10 条记忆。
+        <recall_memory>: 上一轮 LLM 输出的 <recall> 内容触发的主动召回。
+            根据关键字和时间点搜索 top5 历史记忆，注入到本轮上下文中。
+            如果上一轮未输出 <recall>，则此段为空。
 
         Args:
             query: 搜索查询文本（通常为最新用户消息）
             session_id: 会话 ID
-            recall: LLM 上一轮输出的 <recall> 内容，
-                用于定向检索长期记忆（优先级高于 query）
+            recall: LLM 上一轮输出的 <recall> 内容（关键字+时间描述）
 
         Returns:
-            <memory> XML 段落字符串
+            <automemory> + <recall_memory> XML 段落字符串
         """
         if not self.memory_manager:
-            return "<memory>\n(记忆系统未启用)\n</memory>"
-
-        # 构建搜索查询：优先使用 recall 定向检索，其次用用户消息
-        search_query = recall.strip() if recall.strip() else query.strip()
-        if not search_query:
-            return "<memory>\n(无相关记忆)\n</memory>"
-
-        try:
-            results = self.memory_manager.search(
-                query=search_query,
-                session_id=session_id,
-                limit=10,
-                mode="hybrid",
-            )
-        except Exception as e:
-            logger.warning(f"记忆搜索失败: {e}")
-            return "<memory>\n(记忆搜索不可用)\n</memory>"
-
-        if not results:
-            return "<memory>\n(无相关记忆)\n</memory>"
-
-        # 每条记忆格式化为单行
-        lines: List[str] = ["<memory>"]
-        for i, entry in enumerate(results, 1):
-            content = entry.content.strip()
-            if content:
-                lines.append(f"{i}. {_xml_escape(content)}")
-
-        lines.append("</memory>")
-        return "\n".join(lines)
+            return "<automemory>\n(记忆系统未启用)\n</automemory>\n<recall_memory>\n(记忆系统未启用)\n</recall_memory>"
+
+        # ═══════════════════════════════════════════
+        # Part 1: <automemory> — 自动记忆检索
+        # ═══════════════════════════════════════════
+        search_query = query.strip()
+        auto_lines: List[str] = []
+
+        if search_query:
+            try:
+                # 搜索全局记忆中由 remember 产生的内容
+                global_results = self.memory_manager.search(
+                    query=search_query,
+                    session_id="",  # 跨会话搜索全局记忆
+                    category="global",
+                    limit=10,
+                    mode="hybrid",
+                )
+                # 搜索当前会话中 conversation_insight 类记忆
+                session_results = self.memory_manager.search(
+                    query=search_query,
+                    session_id=session_id,
+                    category="session",
+                    limit=5,
+                    mode="hybrid",
+                )
+                # 合并去重（全局优先，会话补充）
+                seen_ids = set()
+                combined = []
+                for entry in global_results + session_results:
+                    if entry.id not in seen_ids:
+                        seen_ids.add(entry.id)
+                        combined.append(entry)
+
+                if combined:
+                    auto_lines.append("<automemory>")
+                    for i, entry in enumerate(combined[:10], 1):
+                        content = entry.content.strip()
+                        if content:
+                            auto_lines.append(f"{i}. {_xml_escape(content)}")
+                    auto_lines.append("</automemory>")
+            except Exception as e:
+                logger.warning(f"automemory 搜索失败: {e}")
+
+        if not auto_lines:
+            auto_lines = ["<automemory>", "(无相关自动记忆)", "</automemory>"]
+
+        # ═══════════════════════════════════════════
+        # Part 2: <recall_memory> — 主动召回记忆
+        # ═══════════════════════════════════════════
+        recall_lines: List[str] = []
+        recall_text = recall.strip() if recall else ""
+
+        if recall_text:
+            try:
+                # 解析 recall 中的关键字和时间描述
+                # 格式可能是: "关键字1 关键字2" 或 "关于XX的记忆 2025年1月" 等
+                recall_results = self.memory_manager.search(
+                    query=recall_text,
+                    session_id="",  # 跨会话搜索
+                    limit=5,
+                    mode="hybrid",
+                )
+                if recall_results:
+                    recall_lines.append("<recall_memory>")
+                    for i, entry in enumerate(recall_results[:5], 1):
+                        content = entry.content.strip()
+                        if content:
+                            recall_lines.append(f"{i}. {_xml_escape(content)}")
+                    recall_lines.append("</recall_memory>")
+            except Exception as e:
+                logger.warning(f"recall_memory 搜索失败: {e}")
+
+        if not recall_lines:
+            recall_lines = ["<recall_memory>", "(无主动召回记忆)", "</recall_memory>"]
+
+        return "\n".join(auto_lines) + "\n" + "\n".join(recall_lines)
 
     def _build_knowledge(self, query: str) -> str:
         """

package/main.py

@@ -42,6 +42,36 @@ from core.permissions import PermissionManager
 from core.deps_checker import check_and_install_deps
 
 
+def _get_screen_resolution() -> tuple[int, int]:
+    """获取当前屏幕分辨率，跨平台兼容 Windows / macOS / Linux。"""
+    try:
+        import tkinter as tk
+        root = tk.Tk()
+        root.withdraw()  # 不显示窗口
+        w = root.winfo_screenwidth()
+        h = root.winfo_screenheight()
+        root.destroy()
+        return w, h
+    except Exception:
+        pass
+    # Linux 回退方案
+    try:
+        import subprocess
+        result = subprocess.run(
+            ["xdpyinfo"], capture_output=True, text=True, timeout=5
+        )
+        for line in result.stdout.splitlines():
+            if "dimensions:" in line:
+                parts = line.split()
+                for p in parts:
+                    if "x" in p:
+                        w, h = p.split("x")
+                        return int(w), int(h)
+    except Exception:
+        pass
+    return 1920, 1080
+
+
 def _open_browser_kiosk(url: str):
     """打开浏览器窗口（无地址栏模式），回退到系统浏览器。
 
@@ -54,10 +84,9 @@ def _open_browser_kiosk(url: str):
 
         async def _launch():
             pw = await async_playwright().start()
-            # 使用 window-size 和 window-position 确保窗口最大化
+            # 获取实际屏幕分辨率，确保窗口占满屏幕
             # --app 模式下 --start-maximized 不生效，需要手动设置窗口大小
-            screen_width = 1920
-            screen_height = 1080
+            screen_width, screen_height = _get_screen_resolution()
             browser = await pw.chromium.launch(
                 headless=False,
                 args=[
@@ -229,8 +258,6 @@ class MyAgentApp:
         self.skill_registry = SkillRegistry()
         # 注册内置技能
         self._register_builtin_skills()
-        # 加载外部 OpenClaw 技能
-        self.skill_registry.load_openclaw_skills()
         skills = self.skill_registry.list_skills()
         self.logger.info(f"技能系统: {len(skills)} 个技能已注册 - {skills}")
 

package/memory/manager.py

@@ -152,6 +152,8 @@ class MemoryManager:
             CREATE INDEX IF NOT EXISTS idx_key ON memories(key);
             CREATE INDEX IF NOT EXISTS idx_session_category ON memories(session_id, category);
             CREATE INDEX IF NOT EXISTS idx_importance ON memories(importance DESC);
+            CREATE INDEX IF NOT EXISTS idx_created_at ON memories(created_at);
+            CREATE INDEX IF NOT EXISTS idx_session_category_created ON memories(session_id, category, created_at);
 
             CREATE TABLE IF NOT EXISTS session_names (
                 session_id TEXT PRIMARY KEY,
@@ -276,19 +278,28 @@ class MemoryManager:
     # ==========================================================================
 
     def add_session(self, session_id, role="", content="", key="", importance=0.5, metadata=None) -> str:
-        """添加会话记忆。"""
+        """添加会话记忆。内容自动注入时间前缀，确保自包含时间信息。"""
+        from datetime import datetime as _dt
+        _now_str = _dt.now().strftime("%Y-%m-%d %H:%M:%S")
+        # 对话类记忆（user/assistant/system/tool）自动加时间前缀
+        if role and content and not content.startswith("["):
+            timestamped_content = f"[{_now_str}] {content}"
+        else:
+            timestamped_content = truncate_str(content, 50000)
         entry = MemoryEntry(
             session_id=session_id, category="session", role=role,
-            content=truncate_str(content, 50000), key=key,
-            importance=importance, metadata=metadata or {},
+            content=timestamped_content, key=key,
+            importance=importance, metadata={"timestamp": _now_str, **(metadata or {})},
         )
         return self._insert(entry)
 
     def get_conversation(self, session_id, limit=500, include_roles=None) -> List[MemoryEntry]:
-        """获取对话历史（session 分类中 role 非空的条目）"""
+        """获取对话历史（session 分类中 role 非空的条目），按时间正序排列。"""
         conn = self._get_conn()
+        # 排除内部系统条目（llm_output, tool_call, tool_result, conversation_insight）
         sql = """SELECT * FROM memories 
                  WHERE session_id = ? AND category = 'session' AND role != ''
+                 AND key NOT IN ('llm_output', 'tool_call', 'tool_result', 'conversation_insight')
                  ORDER BY created_at ASC LIMIT ?"""
         rows = conn.execute(sql, (session_id, limit)).fetchall()
         entries = [MemoryEntry.from_row(row) for row in rows]
@@ -296,6 +307,60 @@ class MemoryManager:
             entries = [e for e in entries if e.role in include_roles]
         return entries
 
+    def get_conversation_all(self, session_id, limit=5000) -> List[MemoryEntry]:
+        """获取全量对话历史（包含所有内部条目），用于完整回溯。"""
+        conn = self._get_conn()
+        sql = """SELECT * FROM memories 
+                 WHERE session_id = ? AND category = 'session' AND role != ''
+                 ORDER BY created_at ASC LIMIT ?"""
+        rows = conn.execute(sql, (session_id, limit)).fetchall()
+        return [MemoryEntry.from_row(row) for row in rows]
+
+    def search_by_time_range(
+        self,
+        session_id: str = "",
+        start_time: str = "",
+        end_time: str = "",
+        keyword: str = "",
+        limit: int = 10,
+    ) -> List[MemoryEntry]:
+        """
+        按时间范围 + 关键词搜索记忆。
+
+        Args:
+            session_id: 会话 ID（空=跨会话）
+            start_time: 起始时间 ISO 格式（如 "2025-01-01 00:00:00"），空=不限
+            end_time: 截止时间 ISO 格式，空=不限
+            keyword: 关键词过滤（LIKE 模糊匹配），空=不限
+            limit: 返回数量
+
+        Returns:
+            匹配的记忆条目列表（按时间倒序）
+        """
+        conn = self._get_conn()
+        conditions = ["category != ''", "(expires_at = '' OR expires_at > ?)"]
+        params: list = [timestamp()]
+
+        if session_id:
+            conditions.append("session_id = ?")
+            params.append(session_id)
+        if start_time:
+            conditions.append("created_at >= ?")
+            params.append(start_time)
+        if end_time:
+            conditions.append("created_at <= ?")
+            params.append(end_time)
+        if keyword:
+            conditions.append("(content LIKE ? OR summary LIKE ? OR key LIKE ?)")
+            like_pattern = f"%{keyword}%"
+            params.extend([like_pattern, like_pattern, like_pattern])
+
+        where = " AND ".join(conditions)
+        sql = f"SELECT * FROM memories WHERE {where} ORDER BY created_at DESC LIMIT ?"
+        params.append(limit)
+        rows = conn.execute(sql, params).fetchall()
+        return [MemoryEntry.from_row(row) for row in rows]
+
     def get_conversation_text(
         self,
         session_id: str,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "myagent-ai",
-  "version": "1.12.0",
+  "version": "1.12.3",
   "description": "本地桌面端执行型AI助手 - Open Interpreter 风格 | Local Desktop Execution-Oriented AI Assistant",
   "main": "main.py",
   "bin": {