jarvis-ai-assistant 0.7.0__py3-none-any.whl → 0.7.8__py3-none-any.whl

jarvis/jarvis_agent/__init__.py

@@ -25,16 +25,13 @@ from jarvis.jarvis_agent.tool_executor import execute_tool_call
 from jarvis.jarvis_agent.memory_manager import MemoryManager
 from jarvis.jarvis_memory_organizer.memory_organizer import MemoryOrganizer
 from jarvis.jarvis_agent.task_analyzer import TaskAnalyzer
-from jarvis.jarvis_agent.task_planner import TaskPlanner
 from jarvis.jarvis_agent.file_methodology_manager import FileMethodologyManager
 from jarvis.jarvis_agent.prompts import (
     DEFAULT_SUMMARY_PROMPT,
     SUMMARY_REQUEST_PROMPT,
-    TASK_ANALYSIS_PROMPT as TASK_ANALYSIS_PROMPT,
+    TASK_ANALYSIS_PROMPT,  # noqa: F401
 )
 from jarvis.jarvis_tools.registry import ToolRegistry
-from jarvis.jarvis_agent.edit_file_handler import EditFileHandler
-from jarvis.jarvis_agent.rewrite_file_handler import RewriteFileHandler
 from jarvis.jarvis_agent.prompt_manager import PromptManager
 from jarvis.jarvis_agent.event_bus import EventBus
 from jarvis.jarvis_agent.run_loop import AgentRunLoop
@@ -76,20 +73,19 @@ from jarvis.jarvis_utils.config import (
     is_use_methodology,
     get_tool_filter_threshold,
     get_after_tool_call_cb_dirs,
-    get_plan_max_depth,
-    is_plan_enabled,
     get_addon_prompt_threshold,
+    is_enable_memory_organizer,
 )
 from jarvis.jarvis_utils.embedding import get_context_token_count
 from jarvis.jarvis_utils.globals import (
     delete_agent,
     get_interrupt,
+    get_short_term_memories,
     make_agent_name,
     set_agent,
     set_interrupt,
 )
 from jarvis.jarvis_utils.input import get_multiline_input, user_confirm
-from jarvis.jarvis_utils.output import OutputType, PrettyOutput
 from jarvis.jarvis_utils.tag import ot
 
 
@@ -138,6 +134,10 @@ def show_agent_startup_stats(
         if project_memory_dir.exists():
             project_memory_count = len(list(project_memory_dir.glob("*.json")))
 
+        # 检查短期记忆
+        short_term_memories = get_short_term_memories()
+        short_term_memory_count = len(short_term_memories) if short_term_memories else 0
+
         # 获取当前工作目录
         current_dir = os.getcwd()
 
@@ -157,6 +157,12 @@ def show_agent_startup_stats(
                 f"📝  项目记忆: [bold magenta]{project_memory_count}[/bold magenta]"
             )
 
+        # 如果有短期记忆，添加到统计信息中
+        if short_term_memory_count > 0:
+            stats_parts.append(
+                f"💭  短期记忆: [bold blue]{short_term_memory_count}[/bold blue]"
+            )
+
         stats_text = Text.from_markup(" | ".join(stats_parts), justify="center")
 
         # 创建包含欢迎信息和统计信息的面板内容
@@ -180,7 +186,7 @@ def show_agent_startup_stats(
         console.print(Align.center(panel))
 
     except Exception as e:
-        PrettyOutput.print(f"加载统计信息失败: {e}", OutputType.WARNING)
+        print(f"⚠️ 加载统计信息失败: {e}")
 
 
 origin_agent_system_prompt = f"""
@@ -251,9 +257,15 @@ class Agent:
     def clear_history(self):
         """
         Clears the current conversation history by delegating to the session manager.
-        Emits BEFORE_HISTORY_CLEAR/AFTER_HISTORY_CLEAR and reapplies system prompt to preserve constraints.
+        直接调用关键流程函数，事件总线仅用于非关键流程（如日志、监控等）。
         """
-        # 广播清理历史前事件（不影响主流程）
+        # 关键流程：直接调用 memory_manager 确保记忆提示
+        try:
+            self.memory_manager._ensure_memory_prompt(agent=self)
+        except Exception:
+            pass
+        
+        # 非关键流程：广播清理历史前事件（用于日志、监控等）
         try:
             self.event_bus.emit(BEFORE_HISTORY_CLEAR, agent=self)
         except Exception:
@@ -263,6 +275,8 @@ class Agent:
         self.session.clear_history()
         # 重置 addon_prompt 跳过轮数计数器
         self._addon_prompt_skip_rounds = 0
+        # 重置没有工具调用的计数器
+        self._no_tool_call_count = 0
 
         # 重置后重新设置系统提示词，确保系统约束仍然生效
         try:
@@ -270,7 +284,7 @@ class Agent:
         except Exception:
             pass
 
-        # 广播清理历史后的事件
+        # 非关键流程：广播清理历史后的事件（用于日志、监控等）
         try:
             self.event_bus.emit(AFTER_HISTORY_CLEAR, agent=self)
         except Exception:
@@ -316,19 +330,14 @@ class Agent:
         use_tools: Optional[List[str]] = None,
         execute_tool_confirm: Optional[bool] = None,
         need_summary: bool = True,
-        auto_summary_rounds: Optional[int] = None,
         multiline_inputer: Optional[Callable[[str], str]] = None,
         use_methodology: Optional[bool] = None,
         use_analysis: Optional[bool] = None,
         force_save_memory: Optional[bool] = None,
-        disable_file_edit: bool = False,
         files: Optional[List[str]] = None,
         confirm_callback: Optional[Callable[[str, bool], bool]] = None,
         non_interactive: Optional[bool] = None,
         in_multi_agent: Optional[bool] = None,
-        plan: Optional[bool] = None,
-        plan_max_depth: Optional[int] = None,
-        plan_depth: int = 0,
         agent_type: str = "normal",
         **kwargs,
     ):
@@ -349,9 +358,6 @@ class Agent:
             force_save_memory: 是否强制保存记忆
             confirm_callback: 用户确认回调函数，签名为 (tip: str, default: bool) -> bool；默认使用CLI的user_confirm
             non_interactive: 是否以非交互模式运行（优先级最高，覆盖环境变量与配置）
-            plan: 是否启用任务规划与子任务拆分（默认从配置加载；启用后在进入主循环前评估是否需要将任务拆分为 <SUB_TASK> 列表，逐一由子Agent执行并汇总结果）
-            plan_max_depth: 任务规划的最大层数（默认3，可通过配置 JARVIS_PLAN_MAX_DEPTH 或入参覆盖）
-            plan_depth: 当前规划层数（内部用于递归控制，子Agent会在父基础上+1）
         """
         # 基础属性初始化（仅根据入参设置原始值；实际生效的默认回退在 _init_config 中统一解析）
         # 标识与描述
@@ -361,14 +367,11 @@ class Agent:
         # 行为控制开关（原始入参值）
         self.auto_complete = bool(auto_complete)
         self.need_summary = bool(need_summary)
-        # 自动摘要轮次：None 表示使用配置文件中的默认值，由 AgentRunLoop 决定最终取值
-        self.auto_summary_rounds = auto_summary_rounds
         self.use_methodology = use_methodology
         self.use_analysis = use_analysis
         self.execute_tool_confirm = execute_tool_confirm
         self.summary_prompt = summary_prompt
         self.force_save_memory = force_save_memory
-        self.disable_file_edit = bool(disable_file_edit)
         # 资源与环境
         self.model_group = model_group
         self.files = files or []
@@ -376,25 +379,16 @@ class Agent:
         self.non_interactive = non_interactive
         # 多智能体运行标志：用于控制非交互模式下的自动完成行为
         self.in_multi_agent = bool(in_multi_agent)
-        # 任务规划：优先使用入参，否则回退到配置
-        self.plan = bool(plan) if plan is not None else is_plan_enabled()
-        # 规划深度与上限
-        try:
-            self.plan_max_depth = (
-                int(plan_max_depth) if plan_max_depth is not None else int(get_plan_max_depth())
-            )
-        except Exception:
-            self.plan_max_depth = 2
-        try:
-            self.plan_depth = int(plan_depth)
-        except Exception:
-            self.plan_depth = 0
         # 运行时状态
         self.first = True
         self.run_input_handlers_next_turn = False
         self.user_data: Dict[str, Any] = {}
         # 记录连续未添加 addon_prompt 的轮数
         self._addon_prompt_skip_rounds: int = 0
+        # 记录连续没有工具调用的次数（用于非交互模式下的工具使用提示）
+        self._no_tool_call_count: int = 0
+        
+        self._agent_type = "normal"
 
 
         # 用户确认回调：默认使用 CLI 的 user_confirm，可由外部注入以支持 TUI/GUI
@@ -472,8 +466,14 @@ class Agent:
         self.task_analyzer = TaskAnalyzer(self)
         self.file_methodology_manager = FileMethodologyManager(self)
         self.prompt_manager = PromptManager(self)
-        # 任务规划器：封装规划与子任务调度逻辑
-        self.task_planner = TaskPlanner(self, plan_depth=self.plan_depth, plan_max_depth=self.plan_max_depth)
+
+        # 如果配置了强制保存记忆，确保 save_memory 工具可用
+        if self.force_save_memory:
+            self._ensure_save_memory_tool()
+
+        # 如果启用了分析，确保 methodology 工具可用
+        if self.use_analysis:
+            self._ensure_methodology_tool()
 
         # 设置系统提示词
         self._setup_system_prompt()
@@ -485,6 +485,7 @@ class Agent:
             self.get_tool_registry(),  # type: ignore
             platform_name=self.model.platform_name(),  # type: ignore
         )
+        
         # 动态加载工具调用后回调
         self._load_after_tool_callbacks()
 
@@ -495,9 +496,7 @@ class Agent:
 
         maybe_model = PlatformRegistry().create_platform(platform_name)
         if maybe_model is None:
-            PrettyOutput.print(
-                f"平台 {platform_name} 不存在，将使用普通模型", OutputType.WARNING
-            )
+            print(f"⚠️ 平台 {platform_name} 不存在，将使用普通模型")
             maybe_model = PlatformRegistry().get_normal_platform()
 
         # 在此处收敛为非可选类型，确保后续赋值满足类型检查
@@ -521,11 +520,7 @@ class Agent:
     ):
         """初始化各种处理器"""
         default_handlers: List[Any] = [ToolRegistry()]
-        if not getattr(self, "disable_file_edit", False):
-            default_handlers.extend([EditFileHandler(), RewriteFileHandler()])
         handlers = output_handler or default_handlers
-        if getattr(self, "disable_file_edit", False):
-            handlers = [h for h in handlers if not isinstance(h, (EditFileHandler, RewriteFileHandler))]
         self.output_handler = handlers
         self.set_use_tools(use_tools)
         self.input_handler = [
@@ -538,15 +533,7 @@ class Agent:
     def _setup_system_prompt(self):
         """设置系统提示词"""
         try:
-            if hasattr(self, "prompt_manager"):
-                prompt_text = self.prompt_manager.build_system_prompt()
-            else:
-                action_prompt = self.get_tool_usage_prompt()
-                prompt_text = f"""
-{self.system_prompt}
-
-{action_prompt}
-"""
+            prompt_text = self.prompt_manager.build_system_prompt()
             self.model.set_system_prompt(prompt_text)  # type: ignore
         except Exception:
             # 回退到原始行为，确保兼容性
@@ -567,6 +554,19 @@ class Agent:
         """Gets user data from the session."""
         return self.session.get_user_data(key)
 
+    def get_remaining_token_count(self) -> int:
+        """获取剩余可用的token数量
+        
+        返回:
+            int: 剩余可用的token数量，如果无法获取则返回0
+        """
+        if not self.model:
+            return 0
+        try:
+            return self.model.get_remaining_token_count()
+        except Exception:
+            return 0
+
     def set_use_tools(self, use_tools):
         """设置要使用的工具列表"""
         for handler in self.output_handler:
@@ -590,8 +590,10 @@ class Agent:
         otherwise, fall back to calling with a single argument for compatibility.
         """
         # 优先通过用户交互封装，便于未来替换 UI
-        if hasattr(self, "user_interaction"):
+        try:
             return self.user_interaction.multiline_input(tip, print_on_empty)
+        except Exception:
+            pass
         try:
             # Try to pass the keyword for enhanced input handler
             return self.multiline_inputer(tip, print_on_empty=print_on_empty)  # type: ignore
@@ -679,7 +681,7 @@ class Agent:
                                 pass
 
                     except Exception as e:
-                        PrettyOutput.print(f"从 {file_path} 加载回调失败: {e}", OutputType.WARNING)
+                        print(f"⚠️ 从 {file_path} 加载回调失败: {e}")
                     finally:
                         if added_path:
                             try:
@@ -687,7 +689,7 @@ class Agent:
                             except ValueError:
                                 pass
         except Exception as e:
-            PrettyOutput.print(f"加载回调目录时发生错误: {e}", OutputType.WARNING)
+            print(f"⚠️ 加载回调目录时发生错误: {e}")
 
     def save_session(self) -> bool:
         """Saves the current session state by delegating to the session manager."""
@@ -707,6 +709,58 @@ class Agent:
                 return handler
         return None
 
+    def _ensure_save_memory_tool(self) -> None:
+        """如果配置了强制保存记忆，确保 save_memory 工具在 use_tools 列表中"""
+        try:
+            tool_registry = self.get_tool_registry()
+            if not tool_registry:
+                return
+
+            # 检查 save_memory 工具是否已注册（工具默认都会注册）
+            if not tool_registry.get_tool("save_memory"):
+                # 如果工具本身不存在，则无法使用，直接返回
+                return
+
+            # 检查 save_memory 是否在 use_tools 列表中
+            # 如果 use_tools 为 None，表示使用所有工具，无需添加
+            if self.use_tools is None:
+                return
+
+            # 如果 save_memory 不在 use_tools 列表中，则添加
+            if "save_memory" not in self.use_tools:
+                self.use_tools.append("save_memory")
+                # 更新工具注册表的工具列表
+                self.set_use_tools(self.use_tools)
+        except Exception:
+            # 忽略所有错误，不影响主流程
+            pass
+
+    def _ensure_methodology_tool(self) -> None:
+        """如果启用了分析，确保 methodology 工具在 use_tools 列表中"""
+        try:
+            tool_registry = self.get_tool_registry()
+            if not tool_registry:
+                return
+
+            # 检查 methodology 工具是否已注册（工具默认都会注册）
+            if not tool_registry.get_tool("methodology"):
+                # 如果工具本身不存在，则无法使用，直接返回
+                return
+
+            # 检查 methodology 是否在 use_tools 列表中
+            # 如果 use_tools 为 None，表示使用所有工具，无需添加
+            if self.use_tools is None:
+                return
+
+            # 如果 methodology 不在 use_tools 列表中，则添加
+            if "methodology" not in self.use_tools:
+                self.use_tools.append("methodology")
+                # 更新工具注册表的工具列表
+                self.set_use_tools(self.use_tools)
+        except Exception:
+            # 忽略所有错误，不影响主流程
+            pass
+
     def get_event_bus(self) -> EventBus:
         """获取事件总线实例"""
         return self.event_bus
@@ -819,7 +873,7 @@ class Agent:
         return message
 
     def _manage_conversation_length(self, message: str) -> str:
-        """管理对话长度计数；摘要触发由轮次在 AgentRunLoop 中统一处理。"""
+        """管理对话长度计数；摘要触发由剩余token数量在 AgentRunLoop 中统一处理（剩余token低于20%时触发）。"""
         self.session.conversation_length += get_context_token_count(message)
 
 
@@ -844,7 +898,7 @@ class Agent:
         # 防御: 模型可能返回空响应(None或空字符串)，统一为空字符串并告警
         if not response:
             try:
-                PrettyOutput.print("模型返回空响应，已使用空字符串回退。", OutputType.WARNING)
+                print("⚠️ 模型返回空响应，已使用空字符串回退。")
             except Exception:
                 pass
             response = ""
@@ -864,9 +918,13 @@ class Agent:
 
         return response
 
-    def generate_summary(self) -> str:
+    def generate_summary(self, for_token_limit: bool = False) -> str:
         """生成对话历史摘要
 
+        参数:
+            for_token_limit: 如果为True，表示由于token限制触发的summary，使用SUMMARY_REQUEST_PROMPT
+                            如果为False，表示任务完成时的summary，使用用户传入的summary_prompt
+
         返回:
             str: 包含对话摘要的字符串
 
@@ -877,24 +935,31 @@ class Agent:
         try:
             if not self.model:
                 raise RuntimeError("Model not initialized")
-            # 优先使用外部传入的 summary_prompt；如为空则回退到默认的会话摘要请求
-            safe_summary_prompt = self.summary_prompt or ""
-            if isinstance(safe_summary_prompt, str) and safe_summary_prompt.strip() != "":
-                prompt_to_use = safe_summary_prompt
-            else:
+            
+            print("🔍 开始生成对话历史摘要...")
+            
+            if for_token_limit:
+                # token限制触发的summary：使用SUMMARY_REQUEST_PROMPT进行上下文压缩
                 prompt_to_use = self.session.prompt + "\n" + SUMMARY_REQUEST_PROMPT
+            else:
+                # 任务完成时的summary：使用用户传入的summary_prompt或DEFAULT_SUMMARY_PROMPT
+                safe_summary_prompt = self.summary_prompt or ""
+                if isinstance(safe_summary_prompt, str) and safe_summary_prompt.strip() != "":
+                    prompt_to_use = safe_summary_prompt
+                else:
+                    prompt_to_use = DEFAULT_SUMMARY_PROMPT
 
             summary = self.model.chat_until_success(prompt_to_use)  # type: ignore
             # 防御: 可能返回空响应(None或空字符串)，统一为空字符串并告警
             if not summary:
                 try:
-                    PrettyOutput.print("总结模型返回空响应，已使用空字符串回退。", OutputType.WARNING)
+                    print("⚠️ 总结模型返回空响应，已使用空字符串回退。")
                 except Exception:
                     pass
                 summary = ""
             return summary
         except Exception:
-            PrettyOutput.print("总结对话历史失败", OutputType.ERROR)
+            print("❌ 总结对话历史失败")
             return ""
 
     def _summarize_and_clear_history(self) -> str:
@@ -914,11 +979,6 @@ class Agent:
         注意:
             当上下文长度超过最大值时使用
         """
-        # 在清理历史之前，提示用户保存重要记忆（事件驱动触发实际保存）
-        if self.force_save_memory:
-            PrettyOutput.print(
-                "对话历史即将被总结和清理，请先保存重要信息...", OutputType.INFO
-            )
 
         if self._should_use_file_upload():
             return self._handle_history_with_file_upload()
@@ -931,20 +991,28 @@ class Agent:
 
     def _handle_history_with_summary(self) -> str:
         """使用摘要方式处理历史"""
-        summary = self.generate_summary()
+        # token限制触发的summary，使用SUMMARY_REQUEST_PROMPT
+        summary = self.generate_summary(for_token_limit=True)
 
         # 先获取格式化的摘要消息
         formatted_summary = ""
         if summary:
             formatted_summary = self._format_summary_message(summary)
 
-        # 清理历史（但不清理prompt，因为prompt会在builtin_input_handler中设置）
-        if self.model:
-            # 广播清理历史前事件
+        # 关键流程：直接调用 memory_manager 确保记忆提示
+        try:
+            self.memory_manager._ensure_memory_prompt(agent=self)
+        except Exception:
+            pass
+        
+        # 非关键流程：广播清理历史前事件（用于日志、监控等）
             try:
                 self.event_bus.emit(BEFORE_HISTORY_CLEAR, agent=self)
             except Exception:
                 pass
+
+        # 清理历史（但不清理prompt，因为prompt会在builtin_input_handler中设置）
+        if self.model:
             self.model.reset()
             # 重置后重新设置系统提示词，确保系统约束仍然生效
             self._setup_system_prompt()
@@ -952,7 +1020,10 @@ class Agent:
         self.session.clear_history()
         # 重置 addon_prompt 跳过轮数计数器
         self._addon_prompt_skip_rounds = 0
-        # 广播清理历史后的事件
+        # 重置没有工具调用的计数器
+        self._no_tool_call_count = 0
+        
+        # 非关键流程：广播清理历史后的事件（用于日志、监控等）
         try:
             self.event_bus.emit(AFTER_HISTORY_CLEAR, agent=self)
         except Exception:
@@ -962,15 +1033,25 @@ class Agent:
 
     def _handle_history_with_file_upload(self) -> str:
         """使用文件上传方式处理历史"""
-        # 广播清理历史前事件
+        # 关键流程：直接调用 memory_manager 确保记忆提示
+        try:
+            self.memory_manager._ensure_memory_prompt(agent=self)
+        except Exception:
+            pass
+        
+        # 非关键流程：广播清理历史前事件（用于日志、监控等）
         try:
             self.event_bus.emit(BEFORE_HISTORY_CLEAR, agent=self)
         except Exception:
             pass
+        
         result = self.file_methodology_manager.handle_history_with_file_upload()
         # 重置 addon_prompt 跳过轮数计数器
         self._addon_prompt_skip_rounds = 0
-        # 广播清理历史后的事件
+        # 重置没有工具调用的计数器
+        self._no_tool_call_count = 0
+        
+        # 非关键流程：广播清理历史后的事件（用于日志、监控等）
         try:
             self.event_bus.emit(AFTER_HISTORY_CLEAR, agent=self)
         except Exception:
@@ -1010,7 +1091,9 @@ class Agent:
         # - TaskAnalyzer 通过订阅 before_summary/task_completed 事件执行分析与满意度收集
         # - MemoryManager 通过订阅 before_history_clear/task_completed 事件执行记忆保存（受 force_save_memory 控制）
         # 为减少耦合，这里不再直接调用上述组件，保持行为由事件触发
-        self._check_and_organize_memory()
+        # 仅在启用自动记忆整理时检查并整理记忆
+        if is_enable_memory_organizer():
+            self._check_and_organize_memory()
 
         result = "任务完成"
 
@@ -1020,8 +1103,20 @@ class Agent:
             safe_summary_prompt = self.summary_prompt or ""
             if isinstance(safe_summary_prompt, str) and safe_summary_prompt.strip() == "":
                 safe_summary_prompt = DEFAULT_SUMMARY_PROMPT
-            # 注意：不要写回 session.prompt，避免 BEFORE_SUMMARY 事件回调修改/清空后导致使用空prompt
-            # 广播将要生成总结事件
+            # 注意：不要写回 session.prompt，避免回调修改/清空后导致使用空prompt
+            
+            # 关键流程：直接调用 task_analyzer 执行任务分析
+            try:
+                self.task_analyzer._on_before_summary(
+                    agent=self,
+                    prompt=safe_summary_prompt,
+                    auto_completed=auto_completed,
+                    need_summary=self.need_summary,
+                )
+            except Exception:
+                pass
+            
+            # 非关键流程：广播将要生成总结事件（用于日志、监控等）
             try:
                 self.event_bus.emit(
                     BEFORE_SUMMARY,
@@ -1040,13 +1135,13 @@ class Agent:
             # 防御: 总结阶段模型可能返回空响应(None或空字符串)，统一为空字符串并告警
             if not ret:
                 try:
-                    PrettyOutput.print("总结阶段模型返回空响应，已使用空字符串回退。", OutputType.WARNING)
+                    print("⚠️ 总结阶段模型返回空响应，已使用空字符串回退。")
                 except Exception:
                     pass
                 ret = ""
             result = ret
 
-            # 广播完成总结事件
+            # 非关键流程：广播完成总结事件（用于日志、监控等）
             try:
                 self.event_bus.emit(
                     AFTER_SUMMARY,
@@ -1056,7 +1151,26 @@ class Agent:
             except Exception:
                 pass
 
-        # 广播任务完成事件（不影响主流程）
+            # 关键流程：直接调用 task_analyzer 和 memory_manager
+        try:
+            self.task_analyzer._on_task_completed(
+                agent=self,
+                auto_completed=auto_completed,
+                need_summary=self.need_summary,
+            )
+        except Exception:
+            pass
+        
+        try:
+            self.memory_manager._ensure_memory_prompt(
+                agent=self,
+                auto_completed=auto_completed,
+                need_summary=self.need_summary,
+            )
+        except Exception:
+            pass
+        
+        # 非关键流程：广播任务完成事件（用于日志、监控等）
         try:
             self.event_bus.emit(
                 TASK_COMPLETED,
@@ -1077,10 +1191,12 @@ class Agent:
 
         """
         # 优先使用 PromptManager 以保持逻辑集中
-        if hasattr(self, "prompt_manager"):
+        try:
             return self.prompt_manager.build_default_addon_prompt(need_complete)
+        except Exception:
+            pass
 
-        # 结构化系统指令
+        # 结构化系统指令（回退方案）
         action_handlers = ", ".join([handler.name() for handler in self.output_handler])
 
         # 任务完成提示
@@ -1104,8 +1220,10 @@ class Agent:
     如果没有完成，请进行下一步操作：
     - 仅包含一个操作
     - 如果信息不明确，请请求用户补充
-    - 如果执行过程中连续失败5次，请使用ask_user询问用户操作
+    - 如果执行过程中连续失败5次，请请求用户操作
     - 操作列表：{action_handlers}{memory_prompts}
+    
+    注意：如果当前部分任务已完成，之前的上下文价值不大，可以输出<!!!SUMMARY!!!>标记来触发总结并清空历史，以便开始新的任务阶段。
 </system_prompt>
 
 请继续。
@@ -1131,7 +1249,19 @@ class Agent:
         self.session.prompt = f"{user_input}"
         try:
             set_agent(self.name, self)
-            # 广播任务开始事件（不影响主流程）
+            
+            # 关键流程：直接调用 memory_manager 重置任务状态
+            try:
+                self.memory_manager._on_task_started(
+                    agent=self,
+                    name=self.name,
+                    description=self.description,
+                    user_input=self.session.prompt,
+                )
+            except Exception:
+                pass
+            
+            # 非关键流程：广播任务开始事件（用于日志、监控等）
             try:
                 self.event_bus.emit(
                     TASK_STARTED,
@@ -1142,16 +1272,9 @@ class Agent:
                 )
             except Exception:
                 pass
-            # 如启用规划模式，先判断是否需要拆分并调度子任务
-            if self.plan:
-                try:
-                    self._maybe_plan_and_dispatch(self.session.prompt)
-                except Exception:
-                    # 防御式处理，规划失败不影响主流程
-                    pass
             return self._main_loop()
         except Exception as e:
-            PrettyOutput.print(f"任务失败: {str(e)}", OutputType.ERROR)
+            print(f"❌ 任务失败: {str(e)}")
             return f"Task failed: {str(e)}"
 
     def _main_loop(self) -> Any:
@@ -1277,37 +1400,21 @@ class Agent:
             "use_tools": use_tools_param,
             "execute_tool_confirm": self.execute_tool_confirm,
             "need_summary": self.need_summary,
-            "auto_summary_rounds": self.auto_summary_rounds,
             "multiline_inputer": self.multiline_inputer,
             "use_methodology": self.use_methodology,
             "use_analysis": self.use_analysis,
             "force_save_memory": self.force_save_memory,
-            "disable_file_edit": self.disable_file_edit,
             "files": self.files,
             "confirm_callback": self.confirm_callback,
             "non_interactive": True,
             "in_multi_agent": True,
-            "plan": self.plan,  # 继承父Agent的规划开关
-            "plan_depth": self.plan_depth + 1,  # 子Agent层数+1
-            "plan_max_depth": self.plan_max_depth,  # 继承上限
         }
 
-    def _maybe_plan_and_dispatch(self, task_text: str) -> None:
-        """委托给 TaskPlanner 执行任务规划与子任务调度，保持向后兼容。"""
-        try:
-            if hasattr(self, "task_planner") and self.task_planner:
-                # 优先使用初始化时注入的规划器
-                self.task_planner.maybe_plan_and_dispatch(task_text)  # type: ignore[attr-defined]
-            else:
-                # 防御式回退：临时创建规划器以避免因未初始化导致的崩溃
-                from jarvis.jarvis_agent.task_planner import TaskPlanner
-                TaskPlanner(self, plan_depth=self.plan_depth, plan_max_depth=self.plan_max_depth).maybe_plan_and_dispatch(task_text)
-        except Exception:
-            # 规划失败不影响主流程
-            pass
-
     def _filter_tools_if_needed(self, task: str):
-        """如果工具数量超过阈值，使用大模型筛选相关工具"""
+        """如果工具数量超过阈值，使用大模型筛选相关工具
+        
+        注意：仅筛选用户自定义工具，内置工具不参与筛选（始终保留）
+        """
         tool_registry = self.get_tool_registry()
         if not isinstance(tool_registry, ToolRegistry):
             return
@@ -1317,10 +1424,16 @@ class Agent:
         if len(all_tools) <= threshold:
             return
 
-        # 为工具选择构建提示
+        # 获取用户自定义工具（非内置工具），仅对这些工具进行筛选
+        custom_tools = tool_registry.get_custom_tools()
+        if not custom_tools:
+            # 没有用户自定义工具，无需筛选
+            return
+
+        # 为工具选择构建提示（仅包含用户自定义工具）
         tools_prompt_part = ""
         tool_names = []
-        for i, tool in enumerate(all_tools, 1):
+        for i, tool in enumerate(custom_tools, 1):
             tool_names.append(tool["name"])
             tools_prompt_part += f"{i}. {tool['name']}: {tool['description']}\n"
 
@@ -1338,9 +1451,7 @@ class Agent:
 请根据用户任务，从列表中选择最相关的工具。
 请仅返回所选工具的编号，以逗号分隔。例如：1, 5, 12
 """
-        PrettyOutput.print(
-            f"工具数量超过{threshold}个，正在使用AI筛选相关工具...", OutputType.INFO
-        )
+        print(f"ℹ️ 工具数量超过{threshold}个，正在使用AI筛选相关工具...")
         # 广播工具筛选开始事件
         try:
             self.event_bus.emit(
@@ -1373,13 +1484,13 @@ class Agent:
             if selected_tool_names:
                 # 移除重复项
                 selected_tool_names = sorted(list(set(selected_tool_names)))
-                tool_registry.use_tools(selected_tool_names)
+                # 合并内置工具名称和筛选出的用户自定义工具名称
+                builtin_names = list(tool_registry._builtin_tool_names)
+                final_tool_names = sorted(list(set(builtin_names + selected_tool_names)))
+                tool_registry.use_tools(final_tool_names)
                 # 使用筛选后的工具列表重新设置系统提示
                 self._setup_system_prompt()
-                PrettyOutput.print(
-                    f"已筛选出 {len(selected_tool_names)} 个相关工具: {', '.join(selected_tool_names)}",
-                    OutputType.SUCCESS,
-                )
+                print(f"✅ 已筛选出 {len(selected_tool_names)} 个相关工具: {', '.join(selected_tool_names)}")
                 # 广播工具筛选事件
                 try:
                     self.event_bus.emit(
@@ -1393,9 +1504,7 @@ class Agent:
                 except Exception:
                     pass
             else:
-                PrettyOutput.print(
-                    "AI 未能筛选出任何相关工具，将使用所有工具。", OutputType.WARNING
-                )
+                print("⚠️ AI 未能筛选出任何相关工具，将使用所有工具。")
                 # 广播工具筛选事件（无筛选结果）
                 try:
                     self.event_bus.emit(
@@ -1410,9 +1519,7 @@ class Agent:
                     pass
 
         except Exception as e:
-            PrettyOutput.print(
-                f"工具筛选失败: {e}，将使用所有工具。", OutputType.ERROR
-            )
+            print(f"❌ 工具筛选失败: {e}，将使用所有工具。")
 
     def _check_and_organize_memory(self):
         """
@@ -1429,7 +1536,7 @@ class Agent:
                 "global",
             )
         except Exception as e:
-            PrettyOutput.print(f"检查记忆库时发生意外错误: {e}", OutputType.WARNING)
+            print(f"⚠️ 检查记忆库时发生意外错误: {e}")
 
     def _perform_memory_check(self, memory_type: str, base_path: Path, scope_name: str):
         """执行特定范围的记忆检查和整理"""
@@ -1470,11 +1577,8 @@ class Agent:
             f"并且存在3个以上标签重叠的记忆。\n"
             f"是否立即整理记忆库以优化性能和相关性？"
         )
-        if self.confirm_callback(prompt, True):
-            PrettyOutput.print(
-                f"正在开始整理 '{scope_name}' ({memory_type}) 记忆库...",
-                OutputType.INFO,
-            )
+        if self.confirm_callback(prompt, False):
+            print(f"ℹ️ 正在开始整理 '{scope_name}' ({memory_type}) 记忆库...")
             organizer.organize_memories(memory_type, min_overlap=3)
         else:
-            PrettyOutput.print(f"已取消 '{scope_name}' 记忆库整理。", OutputType.INFO)
+            print(f"ℹ️ 已取消 '{scope_name}' 记忆库整理。")