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

jarvis/jarvis_agent/__init__.py

@@ -5,10 +5,15 @@ import os
 import platform
 import re
 import sys
-from pathlib import Path
 from enum import Enum
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
-
+from pathlib import Path
+from typing import Any
+from typing import Callable
+from typing import Dict
+from typing import List
+from typing import Optional
+from typing import Tuple
+from typing import Union
 
 # 第三方库导入
 from rich.align import Align
@@ -16,76 +21,73 @@ from rich.console import Console
 from rich.panel import Panel
 from rich.text import Text
 
+from jarvis.jarvis_agent.builtin_input_handler import builtin_input_handler
+from jarvis.jarvis_agent.event_bus import EventBus
+from jarvis.jarvis_agent.events import AFTER_ADDON_PROMPT
+from jarvis.jarvis_agent.events import AFTER_HISTORY_CLEAR
+from jarvis.jarvis_agent.events import AFTER_MODEL_CALL
+from jarvis.jarvis_agent.events import AFTER_SUMMARY
+from jarvis.jarvis_agent.events import AFTER_TOOL_CALL
+from jarvis.jarvis_agent.events import BEFORE_ADDON_PROMPT
+from jarvis.jarvis_agent.events import BEFORE_HISTORY_CLEAR
+from jarvis.jarvis_agent.events import BEFORE_MODEL_CALL
+from jarvis.jarvis_agent.events import BEFORE_SUMMARY
+from jarvis.jarvis_agent.events import BEFORE_TOOL_FILTER
+from jarvis.jarvis_agent.events import INTERRUPT_TRIGGERED
+from jarvis.jarvis_agent.events import TASK_COMPLETED
+from jarvis.jarvis_agent.events import TASK_STARTED
+from jarvis.jarvis_agent.events import TOOL_FILTERED
+from jarvis.jarvis_agent.file_context_handler import file_context_handler
+from jarvis.jarvis_agent.file_methodology_manager import FileMethodologyManager
+from jarvis.jarvis_agent.memory_manager import MemoryManager
+
 # 本地库导入
 # jarvis_agent 相关
 from jarvis.jarvis_agent.prompt_builder import build_action_prompt
+from jarvis.jarvis_agent.prompt_manager import PromptManager
+from jarvis.jarvis_agent.prompts import DEFAULT_SUMMARY_PROMPT
+from jarvis.jarvis_agent.prompts import SUMMARY_REQUEST_PROMPT
 from jarvis.jarvis_agent.protocols import OutputHandlerProtocol
+from jarvis.jarvis_agent.run_loop import AgentRunLoop
 from jarvis.jarvis_agent.session_manager import SessionManager
-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.shell_input_handler import shell_input_handler
 from jarvis.jarvis_agent.task_analyzer import TaskAnalyzer
-from jarvis.jarvis_agent.file_methodology_manager import FileMethodologyManager
-from jarvis.jarvis_agent.prompts import (
-    DEFAULT_SUMMARY_PROMPT,
-    SUMMARY_REQUEST_PROMPT,
-    TASK_ANALYSIS_PROMPT,  # noqa: F401
-)
-from jarvis.jarvis_tools.registry import ToolRegistry
-from jarvis.jarvis_agent.prompt_manager import PromptManager
-from jarvis.jarvis_agent.event_bus import EventBus
-from jarvis.jarvis_agent.run_loop import AgentRunLoop
-from jarvis.jarvis_agent.events import (
-    BEFORE_SUMMARY,
-    AFTER_SUMMARY,
-    TASK_COMPLETED,
-    TASK_STARTED,
-    BEFORE_ADDON_PROMPT,
-    AFTER_ADDON_PROMPT,
-    BEFORE_HISTORY_CLEAR,
-    AFTER_HISTORY_CLEAR,
-    BEFORE_MODEL_CALL,
-    AFTER_MODEL_CALL,
-    INTERRUPT_TRIGGERED,
-    BEFORE_TOOL_FILTER,
-    TOOL_FILTERED,
-    AFTER_TOOL_CALL,
-)
+from jarvis.jarvis_agent.task_list import TaskListManager
+from jarvis.jarvis_agent.tool_executor import execute_tool_call
 from jarvis.jarvis_agent.user_interaction import UserInteractionHandler
 from jarvis.jarvis_agent.utils import join_prompts
-from jarvis.jarvis_utils.methodology import _load_all_methodologies
-from jarvis.jarvis_agent.shell_input_handler import shell_input_handler
-from jarvis.jarvis_agent.file_context_handler import file_context_handler
-from jarvis.jarvis_agent.builtin_input_handler import builtin_input_handler
+from jarvis.jarvis_memory_organizer.memory_organizer import MemoryOrganizer
 
 # jarvis_platform 相关
 from jarvis.jarvis_platform.base import BasePlatform
 from jarvis.jarvis_platform.registry import PlatformRegistry
+from jarvis.jarvis_tools.registry import ToolRegistry
 
 # jarvis_utils 相关
-from jarvis.jarvis_utils.config import (
-    get_data_dir,
-    get_normal_model_name,
-    get_normal_platform_name,
-    is_execute_tool_confirm,
-    is_force_save_memory,
-    is_use_analysis,
-    is_use_methodology,
-    get_tool_filter_threshold,
-    get_after_tool_call_cb_dirs,
-    get_addon_prompt_threshold,
-    is_enable_memory_organizer,
-)
+from jarvis.jarvis_utils.config import get_addon_prompt_threshold
+from jarvis.jarvis_utils.config import get_after_tool_call_cb_dirs
+from jarvis.jarvis_utils.config import get_data_dir
+from jarvis.jarvis_utils.config import get_normal_model_name
+from jarvis.jarvis_utils.config import get_normal_platform_name
+from jarvis.jarvis_utils.config import get_tool_filter_threshold
+from jarvis.jarvis_utils.config import is_enable_memory_organizer
+from jarvis.jarvis_utils.config import is_execute_tool_confirm
+from jarvis.jarvis_utils.config import is_force_save_memory
+from jarvis.jarvis_utils.config import is_use_analysis
+from jarvis.jarvis_utils.config import is_use_methodology
 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.globals import clear_current_agent
+from jarvis.jarvis_utils.globals import get_interrupt
+from jarvis.jarvis_utils.globals import get_short_term_memories
+from jarvis.jarvis_utils.globals import make_agent_name
+from jarvis.jarvis_utils.globals import set_global_model_group
+from jarvis.jarvis_utils.globals import set_interrupt
+from jarvis.jarvis_utils.globals import set_current_agent
+from jarvis.jarvis_utils.input import get_multiline_input
+from jarvis.jarvis_utils.input import user_confirm
+from jarvis.jarvis_utils.methodology import _load_all_methodologies
+from jarvis.jarvis_utils.output import PrettyOutput
+from jarvis.jarvis_utils.tag import ct
 from jarvis.jarvis_utils.tag import ot
 
 
@@ -143,7 +145,9 @@ def show_agent_startup_stats(
 
         # 构建欢迎信息
         platform = platform_name or get_normal_platform_name()
-        welcome_message = f"{agent_name} 初始化完成 - 使用 {platform} 平台 {model_name} 模型"
+        welcome_message = (
+            f"{agent_name} 初始化完成 - 使用 {platform} 平台 {model_name} 模型"
+        )
 
         stats_parts = [
             f"📚  本地方法论: [bold cyan]{methodology_count}[/bold cyan]",
@@ -186,54 +190,47 @@ def show_agent_startup_stats(
         console.print(Align.center(panel))
 
     except Exception as e:
-        print(f"⚠️ 加载统计信息失败: {e}")
+        PrettyOutput.auto_print(f"⚠️ 加载统计信息失败: {e}")
 
 
 origin_agent_system_prompt = f"""
 <role>
-# 🤖 角色
-你是一个专业的任务执行助手，根据用户需求制定并执行详细的计划。
+# 🤖 Jarvis Agent
+你是一个专业的任务执行助手，根据用户需求制定并执行详细计划。
 </role>
 
-<rules>
-# ❗ 核心规则
-1.  **单步操作**: 每个响应必须包含且仅包含一个工具调用。
-2.  **任务终结**: 当任务完成时，明确指出任务已完成。这是唯一可以不调用工具的例外。
-3.  **无响应错误**: 空响应或仅有分析无工具调用的响应是致命错误，会导致系统挂起。
-4.  **决策即工具**: 所有的决策和分析都必须通过工具调用来体现。
-5.  **等待结果**: 在继续下一步之前，必须等待当前工具的执行结果。
-6.  **持续推进**: 除非任务完成，否则必须生成可操作的下一步。
-7.  **记录沉淀**: 如果解决方案有普适价值，应记录为方法论。
-8.  **用户语言**: 始终使用用户的语言进行交流。
-</rules>
-
-<workflow>
-# 🔄 工作流程
-1.  **分析**: 理解和分析问题，定义清晰的目标。
-2.  **设计**: 设计解决方案并制定详细的行动计划。
-3.  **执行**: 按照计划，一次一个步骤地执行。
-4.  **完成**: 验证任务是否达成目标，并进行总结。
-</workflow>
-
-<sub_agents_guide>
-# 子任务工具使用建议
-- 使用 sub_code_agent（代码子Agent）当：
-  - 需要在当前任务下并行推进较大且相对独立的代码改造
-  - 涉及多文件/多模块的大范围变更，或需要较长的工具调用链
-  - 需要隔离上下文以避免污染当前对话（如探索性改动、PoC）
-  - 需要专注于单一代码子问题，阶段性产出可复用的结果
-- 使用 sub_agent（通用子Agent）当：
-  - 子任务不是以代码改造为主（如调研、方案撰写、评审总结、用例设计、文档生成等）
-  - 只是需要短期分流一个轻量的辅助性子任务
-说明：
-- 两者仅需参数 task（可选 background 提供上下文），完成后返回结果给父Agent
-- 子Agent将自动完成并生成总结，请在上层根据返回结果继续编排
-</sub_agents_guide>
+## 核心模式
+每个响应必须以[MODE: MODE_NAME]开头：
+- **INTENT**: 理解用户需求
+- **RESEARCH**: 收集信息
+- **INNOVATE**: 探索方案
+- **PLAN**: 制定计划（复杂任务用task_list_manager）
+- **EXECUTE**: 执行操作
+- **REVIEW**: 验证结果
+
+### IIRIPER 工作流强制约束
+- 整体工作流必须严格按照 **INTENT → RESEARCH → INNOVATE → PLAN → EXECUTE → REVIEW** 的顺序推进。
+- **禁止跳步或乱序**：例如，不能在未经过 PLAN 就直接进入 EXECUTE，也不能从 INTENT 直接跳到 REVIEW。
+- 如因用户以非常明确的指令要求跳过某阶段，必须在当前回复中：
+  - 明确指出被跳过的阶段；
+  - 解释为什么认为可以跳过；
+  - 简要提示可能的风险。
+
+## 执行规则
+1. **单次操作**: 每个响应只含一个工具调用
+2. **禁止虚构**: 必须基于实际结果，禁止假设
+3. **任务列表**: 复杂任务用task_list_manager，简单任务直接执行
+4. **必须验证**: 代码需编译通过、功能验证
+5. **模式转换**: 需明确信号"ENTER [MODE]"
+
+## 工具使用
+- 优先用task_list_manager执行复杂任务
+- execute_task必须提供additional_info参数
+- 禁止同时调用多个工具
 
 <system_info>
-# 系统信息
-- OS: {platform.platform()} {platform.version()}
-- Time: {datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
+OS: {platform.platform()} {platform.version()}
+Time: {datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")}
 </system_info>
 """
 
@@ -259,12 +256,18 @@ class Agent:
         Clears the current conversation history by delegating to the session manager.
         直接调用关键流程函数，事件总线仅用于非关键流程（如日志、监控等）。
         """
+        # 获取当前会话文件路径用于提示
+        from jarvis.jarvis_utils.dialogue_recorder import get_global_recorder
+
+        recorder = get_global_recorder()
+        session_file_path = recorder.get_session_file_path()
+
         # 关键流程：直接调用 memory_manager 确保记忆提示
         try:
             self.memory_manager._ensure_memory_prompt(agent=self)
         except Exception:
             pass
-        
+
         # 非关键流程：广播清理历史前事件（用于日志、监控等）
         try:
             self.event_bus.emit(BEFORE_HISTORY_CLEAR, agent=self)
@@ -278,6 +281,11 @@ class Agent:
         # 重置没有工具调用的计数器
         self._no_tool_call_count = 0
 
+        # 提示用户会话文件位置
+        if Path(session_file_path).exists():
+            PrettyOutput.auto_print(f"💾 当前会话记录已保存到: {session_file_path}")
+            PrettyOutput.auto_print("🤖 大模型可以读取此文件了解完整对话历史")
+
         # 重置后重新设置系统提示词，确保系统约束仍然生效
         try:
             self._setup_system_prompt()
@@ -292,16 +300,11 @@ class Agent:
 
     def __del__(self):
         # 只有在记录启动时才停止记录
-        try:
-            name = getattr(self, "name", None)
-            if name:
-                delete_agent(name)
-        except Exception:
-            pass
+        pass
 
     def get_tool_usage_prompt(self) -> str:
         """获取工具使用提示"""
-        return build_action_prompt(self.output_handler)  # type: ignore
+        return build_action_prompt(self.output_handler)
 
     def __new__(cls, *args, **kwargs):
         if kwargs.get("agent_type") == "code":
@@ -325,7 +328,7 @@ class Agent:
         description: str = "",
         model_group: Optional[str] = None,
         summary_prompt: Optional[str] = None,
-        auto_complete: bool = False,
+        auto_complete: bool = True,
         output_handler: Optional[List[OutputHandlerProtocol]] = None,
         use_tools: Optional[List[str]] = None,
         execute_tool_confirm: Optional[bool] = None,
@@ -336,7 +339,7 @@ class Agent:
         force_save_memory: Optional[bool] = None,
         files: Optional[List[str]] = None,
         confirm_callback: Optional[Callable[[str, bool], bool]] = None,
-        non_interactive: Optional[bool] = None,
+        non_interactive: Optional[bool] = True,
         in_multi_agent: Optional[bool] = None,
         agent_type: str = "normal",
         **kwargs,
@@ -383,17 +386,18 @@ class Agent:
         self.first = True
         self.run_input_handlers_next_turn = False
         self.user_data: Dict[str, Any] = {}
+        # 记录固定的内容
+        self.pin_content: str = ""
         # 记录连续未添加 addon_prompt 的轮数
-        self._addon_prompt_skip_rounds: int = 0
+        self._addon_prompt_skip_rounds = 0
         # 记录连续没有工具调用的次数（用于非交互模式下的工具使用提示）
-        self._no_tool_call_count: int = 0
-        
-        self._agent_type = "normal"
+        self._no_tool_call_count = 0
 
+        self._agent_type = "normal"
 
         # 用户确认回调：默认使用 CLI 的 user_confirm，可由外部注入以支持 TUI/GUI
         self.confirm_callback: Callable[[str, bool], bool] = (
-            confirm_callback or user_confirm  # type: ignore[assignment]
+            confirm_callback or user_confirm
         )
 
         # 初始化模型和会话
@@ -407,57 +411,78 @@ class Agent:
             use_tools or [],
         )
         # 初始化用户交互封装，保持向后兼容
-        self.user_interaction = UserInteractionHandler(self.multiline_inputer, self.confirm_callback)
+        self.user_interaction = UserInteractionHandler(
+            self.multiline_inputer, self.confirm_callback
+        )
         # 将确认函数指向封装后的 confirm，保持既有调用不变
-        self.confirm_callback = self.user_interaction.confirm  # type: ignore[assignment]
+        self.confirm_callback = self.user_interaction.confirm
         # 非交互模式参数支持：允许通过构造参数显式控制，便于其他Agent调用时设置
+        # 仅作为 Agent 实例属性，不写入环境变量或全局配置，避免跨 Agent 污染
         try:
-            # 优先使用构造参数，其次回退到环境变量
+            # 优先使用构造参数，若未提供则默认为 False
             self.non_interactive = (
-                bool(non_interactive)
-                if non_interactive is not None
-                else str(os.environ.get("JARVIS_NON_INTERACTIVE", "")).lower() in ("1", "true", "yes")
+                bool(non_interactive) if non_interactive is not None else False
             )
-            # 如果构造参数显式提供，则同步到环境变量与全局配置，供下游组件读取
-            if non_interactive is not None:
-                os.environ["JARVIS_NON_INTERACTIVE"] = "true" if self.non_interactive else "false"
-
         except Exception:
             # 防御式回退
             self.non_interactive = False
 
         # 初始化配置（直接解析，不再依赖 _init_config）
         try:
-            resolved_use_methodology = bool(use_methodology if use_methodology is not None else is_use_methodology())
+            resolved_use_methodology = bool(
+                use_methodology if use_methodology is not None else is_use_methodology()
+            )
         except Exception:
-            resolved_use_methodology = bool(use_methodology) if use_methodology is not None else True
+            resolved_use_methodology = (
+                bool(use_methodology) if use_methodology is not None else True
+            )
 
         try:
-            resolved_use_analysis = bool(use_analysis if use_analysis is not None else is_use_analysis())
+            resolved_use_analysis = bool(
+                use_analysis if use_analysis is not None else is_use_analysis()
+            )
         except Exception:
-            resolved_use_analysis = bool(use_analysis) if use_analysis is not None else True
+            resolved_use_analysis = (
+                bool(use_analysis) if use_analysis is not None else True
+            )
 
         try:
-            resolved_execute_tool_confirm = bool(execute_tool_confirm if execute_tool_confirm is not None else is_execute_tool_confirm())
+            resolved_execute_tool_confirm = bool(
+                execute_tool_confirm
+                if execute_tool_confirm is not None
+                else is_execute_tool_confirm()
+            )
         except Exception:
-            resolved_execute_tool_confirm = bool(execute_tool_confirm) if execute_tool_confirm is not None else False
+            resolved_execute_tool_confirm = (
+                bool(execute_tool_confirm)
+                if execute_tool_confirm is not None
+                else False
+            )
 
         try:
-            resolved_force_save_memory = bool(force_save_memory if force_save_memory is not None else is_force_save_memory())
+            resolved_force_save_memory = bool(
+                force_save_memory
+                if force_save_memory is not None
+                else is_force_save_memory()
+            )
         except Exception:
-            resolved_force_save_memory = bool(force_save_memory) if force_save_memory is not None else False
+            resolved_force_save_memory = (
+                bool(force_save_memory) if force_save_memory is not None else False
+            )
 
         self.use_methodology = resolved_use_methodology
         self.use_analysis = resolved_use_analysis
         self.execute_tool_confirm = resolved_execute_tool_confirm
-        self.summary_prompt = (summary_prompt or DEFAULT_SUMMARY_PROMPT)
+        self.summary_prompt = summary_prompt or DEFAULT_SUMMARY_PROMPT
         self.force_save_memory = resolved_force_save_memory
         # 多智能体模式下，默认不自动完成（即使是非交互），仅在明确传入 auto_complete=True 时开启
         if self.in_multi_agent:
             self.auto_complete = bool(self.auto_complete)
         else:
             # 非交互模式下默认自动完成；否则保持传入的 auto_complete 值
-            self.auto_complete = bool(self.auto_complete or (self.non_interactive or False))
+            self.auto_complete = bool(
+                self.auto_complete or (self.non_interactive or False)
+            )
 
         # 初始化事件总线需先于管理器，以便管理器在构造中安全订阅事件
         self.event_bus = EventBus()
@@ -466,6 +491,9 @@ class Agent:
         self.task_analyzer = TaskAnalyzer(self)
         self.file_methodology_manager = FileMethodologyManager(self)
         self.prompt_manager = PromptManager(self)
+        # 初始化任务列表管理器（使用当前工作目录作为 root_dir，如果子类已设置 root_dir 则使用子类的）
+        root_dir = getattr(self, "root_dir", None) or os.getcwd()
+        self.task_list_manager = TaskListManager(root_dir)
 
         # 如果配置了强制保存记忆，确保 save_memory 工具可用
         if self.force_save_memory:
@@ -482,10 +510,10 @@ class Agent:
         show_agent_startup_stats(
             name,
             self.model.name(),
-            self.get_tool_registry(),  # type: ignore
-            platform_name=self.model.platform_name(),  # type: ignore
+            self.get_tool_registry(),
+            platform_name=self.model.platform_name(),
         )
-        
+
         # 动态加载工具调用后回调
         self._load_after_tool_callbacks()
 
@@ -496,7 +524,7 @@ class Agent:
 
         maybe_model = PlatformRegistry().create_platform(platform_name)
         if maybe_model is None:
-            print(f"⚠️ 平台 {platform_name} 不存在，将使用普通模型")
+            PrettyOutput.auto_print(f"⚠️ 平台 {platform_name} 不存在，将使用普通模型")
             maybe_model = PlatformRegistry().get_normal_platform()
 
         # 在此处收敛为非可选类型，确保后续赋值满足类型检查
@@ -508,9 +536,12 @@ class Agent:
         self.model.set_model_group(model_group)
         self.model.set_suppress_output(False)
 
+        # 设置全局模型组，供工具和其他组件使用
+        set_global_model_group(model_group)
+
     def _init_session(self):
         """初始化会话管理器"""
-        self.session = SessionManager(model=self.model, agent_name=self.name)  # type: ignore
+        self.session = SessionManager(model=self.model, agent_name=self.name)
 
     def _init_handlers(
         self,
@@ -534,15 +565,20 @@ class Agent:
         """设置系统提示词"""
         try:
             prompt_text = self.prompt_manager.build_system_prompt()
-            self.model.set_system_prompt(prompt_text)  # type: ignore
+            self.model.set_system_prompt(prompt_text)
         except Exception:
             # 回退到原始行为，确保兼容性
             action_prompt = self.get_tool_usage_prompt()
-            self.model.set_system_prompt(  # type: ignore
+            rules_prompt = self.rules_manager.load_all_rules(
+                ",".join(self.loaded_rule_names)
+            )
+            self.model.set_system_prompt(
                 f"""
 {self.system_prompt}
 
 {action_prompt}
+
+{rules_prompt}
 """
             )
 
@@ -556,7 +592,7 @@ class Agent:
 
     def get_remaining_token_count(self) -> int:
         """获取剩余可用的token数量
-        
+
         返回:
             int: 剩余可用的token数量，如果无法获取则返回0
         """
@@ -596,14 +632,16 @@ class Agent:
             pass
         try:
             # Try to pass the keyword for enhanced input handler
-            return self.multiline_inputer(tip, print_on_empty=print_on_empty)  # type: ignore
+            return self.multiline_inputer(
+                tip,
+            )
         except TypeError:
             # Fallback for custom handlers that only accept one argument
-            return self.multiline_inputer(tip)  # type: ignore
+            return self.multiline_inputer(tip)
 
     def _load_after_tool_callbacks(self) -> None:
         """
-        扫描 JARVIS_AFTER_TOOL_CALL_CB_DIRS 中的 Python 文件并动态注册回调。
+        扫描 after_tool_call_cb_dirs 中的 Python 文件并动态注册回调。
         约定优先级（任一命中即注册）：
         - 模块级可调用对象: after_tool_call_cb
         - 工厂方法返回单个或多个可调用对象: get_after_tool_call_cb(), register_after_tool_call_cb()
@@ -634,7 +672,7 @@ class Agent:
                         if hasattr(module, "after_tool_call_cb"):
                             obj = getattr(module, "after_tool_call_cb")
                             if callable(obj):
-                                candidates.append(obj)  # type: ignore[arg-type]
+                                candidates.append(obj)
 
                         # 2) 工厂方法：get_after_tool_call_cb()
                         if hasattr(module, "get_after_tool_call_cb"):
@@ -668,6 +706,7 @@ class Agent:
 
                         for cb in candidates:
                             try:
+
                                 def _make_wrapper(callback):
                                     def _wrapper(**kwargs: Any) -> None:
                                         try:
@@ -675,13 +714,17 @@ class Agent:
                                             callback(agent)
                                         except Exception:
                                             pass
+
                                     return _wrapper
-                                self.event_bus.subscribe(AFTER_TOOL_CALL, _make_wrapper(cb))
+
+                                self.event_bus.subscribe(
+                                    AFTER_TOOL_CALL, _make_wrapper(cb)
+                                )
                             except Exception:
                                 pass
 
                     except Exception as e:
-                        print(f"⚠️ 从 {file_path} 加载回调失败: {e}")
+                        PrettyOutput.auto_print(f"⚠️ 从 {file_path} 加载回调失败: {e}")
                     finally:
                         if added_path:
                             try:
@@ -689,7 +732,7 @@ class Agent:
                             except ValueError:
                                 pass
         except Exception as e:
-            print(f"⚠️ 加载回调目录时发生错误: {e}")
+            PrettyOutput.auto_print(f"⚠️ 加载回调目录时发生错误: {e}")
 
     def save_session(self) -> bool:
         """Saves the current session state by delegating to the session manager."""
@@ -813,7 +856,7 @@ class Agent:
 
     def _add_addon_prompt(self, message: str, need_complete: bool) -> str:
         """添加附加提示到消息
-        
+
         规则：
         1. 如果 session.addon_prompt 存在，优先使用它
         2. 如果消息长度超过阈值，添加默认 addon_prompt
@@ -833,7 +876,7 @@ class Agent:
 
         addon_text = ""
         should_add = False
-        
+
         if self.session.addon_prompt:
             # 优先使用 session 中设置的 addon_prompt
             addon_text = self.session.addon_prompt
@@ -852,7 +895,7 @@ class Agent:
                 addon_text = self.make_default_addon_prompt(need_complete)
                 message = join_prompts([message, addon_text])
                 should_add = True
-        
+
         # 更新计数器：如果添加了 addon_prompt，重置计数器；否则递增
         if should_add:
             self._addon_prompt_skip_rounds = 0
@@ -876,7 +919,6 @@ class Agent:
         """管理对话长度计数；摘要触发由剩余token数量在 AgentRunLoop 中统一处理（剩余token低于20%时触发）。"""
         self.session.conversation_length += get_context_token_count(message)
 
-
         return message
 
     def _invoke_model(self, message: str) -> str:
@@ -894,15 +936,15 @@ class Agent:
         except Exception:
             pass
 
-        response = self.model.chat_until_success(message)  # type: ignore
+        response = self.model.chat_until_success(message)
         # 防御: 模型可能返回空响应(None或空字符串)，统一为空字符串并告警
         if not response:
             try:
-                print("⚠️ 模型返回空响应，已使用空字符串回退。")
+                PrettyOutput.auto_print("⚠️ 模型返回空响应，已使用空字符串回退。")
             except Exception:
                 pass
             response = ""
-        
+
         # 事件：模型调用后
         try:
             self.event_bus.emit(
@@ -935,31 +977,36 @@ class Agent:
         try:
             if not self.model:
                 raise RuntimeError("Model not initialized")
-            
-            print("🔍 开始生成对话历史摘要...")
-            
+
+            PrettyOutput.auto_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() != "":
+                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
+            summary = self.model.chat_until_success(prompt_to_use)
             # 防御: 可能返回空响应(None或空字符串)，统一为空字符串并告警
             if not summary:
                 try:
-                    print("⚠️ 总结模型返回空响应，已使用空字符串回退。")
+                    PrettyOutput.auto_print(
+                        "⚠️ 总结模型返回空响应，已使用空字符串回退。"
+                    )
                 except Exception:
                     pass
                 summary = ""
             return summary
         except Exception:
-            print("❌ 总结对话历史失败")
+            PrettyOutput.auto_print("❌ 总结对话历史失败")
             return ""
 
     def _summarize_and_clear_history(self) -> str:
@@ -994,18 +1041,62 @@ class Agent:
         # token限制触发的summary，使用SUMMARY_REQUEST_PROMPT
         summary = self.generate_summary(for_token_limit=True)
 
+        # 获取git diff信息
+        git_diff_info = ""
+        try:
+            # 尝试从 AgentRunLoop 获取已缓存的 git diff
+            from jarvis.jarvis_agent.run_loop import AgentRunLoop
+
+            if hasattr(self, "_agent_run_loop") and isinstance(
+                self._agent_run_loop, AgentRunLoop
+            ):
+                agent_run_loop = self._agent_run_loop
+            else:
+                # 创建临时 AgentRunLoop 实例来获取 git diff
+                agent_run_loop = AgentRunLoop(self)
+
+            if agent_run_loop.has_git_diff():
+                cached_diff = agent_run_loop.get_cached_git_diff()
+                git_diff_info = cached_diff or ""
+            else:
+                # 如果还没有缓存，直接获取
+                git_diff_info = agent_run_loop.get_git_diff()
+        except Exception as e:
+            git_diff_info = f"获取git diff失败: {str(e)}"
+
         # 先获取格式化的摘要消息
         formatted_summary = ""
         if summary:
             formatted_summary = self._format_summary_message(summary)
 
+        # 添加git diff信息到摘要中 - 只显示有效的代码变更
+        is_valid_git_diff = (
+            git_diff_info
+            and git_diff_info.strip()
+            and
+            # 过滤错误信息（获取失败等）
+            not git_diff_info.startswith("获取git diff失败")
+            and not git_diff_info.startswith("Failed to get git diff")
+            and
+            # 过滤无变更提示
+            "没有检测到代码变更" not in git_diff_info
+            and "No code changes detected" not in git_diff_info
+            and
+            # 确保包含实际代码变更（diff格式）
+            "diff --git" in git_diff_info
+        )
+
+        if is_valid_git_diff:
+            diff_section = f"\n\n## 代码变更摘要\n```\n{git_diff_info}\n```"
+            formatted_summary += diff_section
+
         # 关键流程：直接调用 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:
@@ -1022,13 +1113,54 @@ class Agent:
         self._addon_prompt_skip_rounds = 0
         # 重置没有工具调用的计数器
         self._no_tool_call_count = 0
-        
+
+        # 获取任务列表信息（用于历史记录）
+        task_list_info = ""
+        try:
+            # 获取所有任务列表的摘要信息
+            task_lists_summary: List[Dict[str, Any]] = []
+            for task_list_id, task_list in self.task_list_manager.task_lists.items():
+                summary_dict = self.task_list_manager.get_task_list_summary(
+                    task_list_id
+                )
+                if summary_dict and isinstance(summary_dict, dict):
+                    task_lists_summary.append(summary_dict)
+
+            if task_lists_summary:
+                task_list_info = "\\n\\n## 任务列表状态\\n"
+                for summary_dict in task_lists_summary:
+                    task_list_info += (
+                        f"\\n- 目标: {summary_dict.get('main_goal', '未知')}"
+                    )
+                    task_list_info += (
+                        f"\\n- 总任务数: {summary_dict.get('total_tasks', 0)}"
+                    )
+                    task_list_info += f"\\n- 待执行: {summary_dict.get('pending', 0)}"
+                    task_list_info += f"\\n- 执行中: {summary_dict.get('running', 0)}"
+                    task_list_info += f"\\n- 已完成: {summary_dict.get('completed', 0)}"
+                    task_list_info += f"\\n- 失败: {summary_dict.get('failed', 0)}"
+                    task_list_info += (
+                        f"\\n- 已放弃: {summary_dict.get('abandoned', 0)}\\n"
+                    )
+        except Exception:
+            # 非关键流程，失败时不影响主要功能
+            pass
+
         # 非关键流程：广播清理历史后的事件（用于日志、监控等）
         try:
             self.event_bus.emit(AFTER_HISTORY_CLEAR, agent=self)
         except Exception:
             pass
 
+        # 将任务列表信息添加到摘要中
+        if task_list_info:
+            formatted_summary += task_list_info
+
+        # 添加用户固定的重要内容
+        if self.pin_content.strip():
+            pin_section = f"\n\n## 用户的原始需求和要求\n{self.pin_content.strip()}"
+            formatted_summary += pin_section
+
         return formatted_summary
 
     def _handle_history_with_file_upload(self) -> str:
@@ -1038,19 +1170,43 @@ class Agent:
             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
-        
+
+        # 添加系统约束提醒
+        if result:
+            constraint_reminder = """
+
+**⚠️ 重要系统约束提醒（总结后必须严格遵守）：**
+1. **每次只能执行一个工具调用**：每个响应必须包含且仅包含一个工具调用（任务完成时除外）。同时调用多个工具会导致错误。
+2. **禁止虚构结果**：所有操作必须基于实际执行结果，禁止推测、假设或虚构任何执行结果。必须等待工具执行完成并获得实际结果后再进行下一步。
+3. **等待工具结果**：在继续下一步之前，必须等待当前工具的执行结果，不能假设工具执行的结果。
+4. **基于实际验证**：所有结论必须基于实际执行结果和验证证据，禁止基于推测或假设。
+5. **代码任务完成标准（严格执行）**：
+   - **编译/构建必须通过**：代码必须能够成功编译/构建，无编译错误、无语法错误、无链接错误
+   - **功能必须验证**：功能必须经过实际运行验证，不能仅凭代码存在就认为完成
+   - **错误必须修复**：如果存在编译错误、运行时错误、测试失败，任务必须标记为"部分完成"或"进行中"，不能标记为"已完成"
+   - **不能因为"代码已编写"就认为任务完成**：必须验证编译通过、功能正常运行、测试通过
+"""
+            result += constraint_reminder
+
+        # 添加用户固定的重要内容
+        if self.pin_content.strip():
+            pin_section = (
+                f"\n\n## 用户强调的任务目标和关键信息\n{self.pin_content.strip()}"
+            )
+            result += pin_section
+
         # 非关键流程：广播清理历史后的事件（用于日志、监控等）
         try:
             self.event_bus.emit(AFTER_HISTORY_CLEAR, agent=self)
@@ -1060,15 +1216,107 @@ class Agent:
 
     def _format_summary_message(self, summary: str) -> str:
         """格式化摘要消息"""
-        return f"""
+        # 获取任务列表信息
+        task_list_info = self._get_task_list_info()
+
+        # 获取会话文件路径信息
+        session_file_info = ""
+        try:
+            from jarvis.jarvis_utils.dialogue_recorder import get_global_recorder
+            from pathlib import Path
+
+            recorder = get_global_recorder()
+            session_file_path = recorder.get_session_file_path()
+            if Path(session_file_path).exists():
+                session_file_info = f"\n\n**📁 完整对话历史文件**：\n完整的对话历史已自动保存到以下文件，如果需要查看详细的历史信息，可以读取此文件：\n`{session_file_path}`\n\n此文件包含之前所有对话的完整记录（JSONL格式），每行一个消息记录，包括时间戳、角色和内容。"
+        except Exception:
+            # 非关键流程，失败时不影响主要功能
+            pass
+
+        # 获取初始 commit 信息（仅对 CodeAgent）
+        initial_commit_info = ""
+        try:
+            if hasattr(self, "start_commit") and self.start_commit:
+                initial_commit_info = f"\n\n**🔖 初始 Git Commit（安全回退点）**：\n本次任务开始时的初始 commit 是：`{self.start_commit}`\n\n**⚠️ 重要提示**：如果文件被破坏得很严重无法恢复，可以使用以下命令重置到这个初始 commit：\n```bash\ngit reset --hard {self.start_commit}\n```\n这将丢弃所有未提交的更改，将工作区恢复到任务开始时的状态。请谨慎使用此命令，确保这是你真正想要的操作。"
+        except Exception:
+            # 非关键流程，失败时不影响主要功能
+            pass
+
+        formatted_message = f"""
 以下是之前对话的关键信息总结：
 
 <content>
 {summary}
 </content>
 
-请基于以上信息继续完成任务。请注意，这是之前对话的摘要，上下文长度已超过限制而被重置。请直接继续任务，无需重复已完成的步骤。如有需要，可以询问用户以获取更多信息。
+**⚠️ 重要系统约束提醒（总结后必须严格遵守）：**
+1. **每次只能执行一个工具调用**：每个响应必须包含且仅包含一个工具调用（任务完成时除外）。同时调用多个工具会导致错误。
+2. **禁止虚构结果**：所有操作必须基于实际执行结果，禁止推测、假设或虚构任何执行结果。必须等待工具执行完成并获得实际结果后再进行下一步。
+3. **等待工具结果**：在继续下一步之前，必须等待当前工具的执行结果，不能假设工具执行的结果。
+4. **基于实际验证**：所有结论必须基于实际执行结果和验证证据，禁止基于推测或假设。
+5. **代码任务完成标准（严格执行）**：
+   - **编译/构建必须通过**：代码必须能够成功编译/构建，无编译错误、无语法错误、无链接错误
+   - **功能必须验证**：功能必须经过实际运行验证，不能仅凭代码存在就认为完成
+   - **错误必须修复**：如果存在编译错误、运行时错误、测试失败，任务必须标记为"部分完成"或"进行中"，不能标记为"已完成"
+   - **不能因为"代码已编写"就认为任务完成**：必须验证编译通过、功能正常运行、测试通过
+
+请基于以上信息继续完成任务。请注意，这是之前对话的摘要，上下文长度已超过限制而被重置。请直接继续任务，无需重复已完成的步骤。如有需要，可以询问用户以获取更多信息。{session_file_info}{initial_commit_info}
+        """
+
+        # 如果有任务列表信息，添加到消息后面
+        if task_list_info:
+            formatted_message += f"\n\n{task_list_info}"
+
+        return formatted_message
+
+    def _get_task_list_info(self) -> str:
+        """获取并格式化当前任务列表信息
+
+        返回:
+            str: 格式化的任务列表信息，如果没有任务列表则返回空字符串
         """
+        try:
+            # 使用当前Agent的任务列表管理器获取所有任务列表信息
+            if (
+                not hasattr(self, "task_list_manager")
+                or not self.task_list_manager.task_lists
+            ):
+                return ""
+
+            all_task_lists_info = []
+
+            # 遍历所有任务列表
+            for task_list_id, task_list in self.task_list_manager.task_lists.items():
+                summary = self.task_list_manager.get_task_list_summary(task_list_id)
+                if not summary:
+                    continue
+
+                # 构建任务列表摘要信息
+                info_parts = []
+                info_parts.append(f"📋 任务列表: {summary['main_goal']}")
+                info_parts.append(
+                    f"   总任务: {summary['total_tasks']} | 待执行: {summary['pending']} | 执行中: {summary['running']} | 已完成: {summary['completed']}"
+                )
+
+                # 如果有失败或放弃的任务，也显示
+                if summary["failed"] > 0 or summary["abandoned"] > 0:
+                    status_parts = []
+                    if summary["failed"] > 0:
+                        status_parts.append(f"失败: {summary['failed']}")
+                    if summary["abandoned"] > 0:
+                        status_parts.append(f"放弃: {summary['abandoned']}")
+                    info_parts[-1] += f" | {' | '.join(status_parts)}"
+
+                all_task_lists_info.append("\n".join(info_parts))
+
+            if not all_task_lists_info:
+                return ""
+
+            return "\n\n".join(all_task_lists_info)
+
+        except Exception:
+            # 静默失败，不干扰主流程
+            return ""
 
     def _call_tools(self, response: str) -> Tuple[bool, Any]:
         """
@@ -1098,13 +1346,15 @@ class Agent:
         result = "任务完成"
 
         if self.need_summary:
-
             # 确保总结提示词非空：若为None或仅空白，则回退到默认提示词
             safe_summary_prompt = self.summary_prompt or ""
-            if isinstance(safe_summary_prompt, str) and safe_summary_prompt.strip() == "":
+            if (
+                isinstance(safe_summary_prompt, str)
+                and safe_summary_prompt.strip() == ""
+            ):
                 safe_summary_prompt = DEFAULT_SUMMARY_PROMPT
             # 注意：不要写回 session.prompt，避免回调修改/清空后导致使用空prompt
-            
+
             # 关键流程：直接调用 task_analyzer 执行任务分析
             try:
                 self.task_analyzer._on_before_summary(
@@ -1115,7 +1365,7 @@ class Agent:
                 )
             except Exception:
                 pass
-            
+
             # 非关键流程：广播将要生成总结事件（用于日志、监控等）
             try:
                 self.event_bus.emit(
@@ -1131,16 +1381,39 @@ class Agent:
             if not self.model:
                 raise RuntimeError("Model not initialized")
             # 直接使用本地变量，避免受事件回调影响
-            ret = self.model.chat_until_success(safe_summary_prompt)  # type: ignore
+            ret = self.model.chat_until_success(safe_summary_prompt)
             # 防御: 总结阶段模型可能返回空响应(None或空字符串)，统一为空字符串并告警
             if not ret:
                 try:
-                    print("⚠️ 总结阶段模型返回空响应，已使用空字符串回退。")
+                    PrettyOutput.auto_print(
+                        "⚠️ 总结阶段模型返回空响应，已使用空字符串回退。"
+                    )
                 except Exception:
                     pass
                 ret = ""
             result = ret
 
+            # 打印任务总结内容给用户查看
+            if ret and ret.strip():
+                try:
+                    import jarvis.jarvis_utils.globals as G
+                    from jarvis.jarvis_utils.globals import console
+                    from rich.panel import Panel
+                    from rich import box
+
+                    agent_name = self.name if hasattr(self, "name") else None
+                    panel = Panel(
+                        ret,
+                        title=f"[bold cyan]{(G.get_current_agent_name() + ' · ') if G.get_current_agent_name() else ''}{agent_name or 'LLM'} 任务总结[/bold cyan]",
+                        border_style="bright_green",
+                        box=box.ROUNDED,
+                        expand=True,
+                    )
+                    console.print(panel)
+                except Exception:
+                    # 如果格式化输出失败，回退到简单打印
+                    PrettyOutput.auto_print(f"📋 任务总结:\n{ret}")
+
             # 非关键流程：广播完成总结事件（用于日志、监控等）
             try:
                 self.event_bus.emit(
@@ -1160,7 +1433,7 @@ class Agent:
             )
         except Exception:
             pass
-        
+
         try:
             self.memory_manager._ensure_memory_prompt(
                 agent=self,
@@ -1169,7 +1442,7 @@ class Agent:
             )
         except Exception:
             pass
-        
+
         # 非关键流程：广播任务完成事件（用于日志、监控等）
         try:
             self.event_bus.emit(
@@ -1201,7 +1474,7 @@ class Agent:
 
         # 任务完成提示
         complete_prompt = (
-            f"- 输出{ot('!!!COMPLETE!!!')}"
+            f"- 如果任务已完成，只输出 {ot('!!!COMPLETE!!!')}，不要输出其他任何内容。任务总结将会在后面的交互中被询问。"
             if need_complete and self.auto_complete
             else ""
         )
@@ -1215,15 +1488,15 @@ class Agent:
         addon_prompt = f"""
 <system_prompt>
     请判断是否已经完成任务，如果已经完成：
-    - 直接输出完成原因，不需要再有新的操作，不要输出{ot("TOOL_CALL")}标签
-    {complete_prompt}
+    {complete_prompt if complete_prompt else f"- 直接输出完成原因，不需要再有新的操作，不要输出{ot('TOOL_CALL')}标签"}
     如果没有完成，请进行下一步操作：
     - 仅包含一个操作
     - 如果信息不明确，请请求用户补充
     - 如果执行过程中连续失败5次，请请求用户操作
+    - 工具调用必须使用{ot("TOOL_CALL")}和{ct("TOOL_CALL")}标签
     - 操作列表：{action_handlers}{memory_prompts}
     
-    注意：如果当前部分任务已完成，之前的上下文价值不大，可以输出<!!!SUMMARY!!!>标记来触发总结并清空历史，以便开始新的任务阶段。
+    注意：如果当前部分任务已完成，之前的上下文价值不大，可以输出{ot("!!!SUMMARY!!!")}标记来触发总结并清空历史，以便开始新的任务阶段。
 </system_prompt>
 
 请继续。
@@ -1246,10 +1519,31 @@ class Agent:
             3. 包含错误处理和恢复逻辑
             4. 自动加载相关方法论(如果是首次运行)
         """
-        self.session.prompt = f"{user_input}"
+        # 根据当前模式生成额外说明，供 LLM 感知执行策略
         try:
-            set_agent(self.name, self)
-            
+            # 延迟导入CodeAgent以避免循环依赖
+            from jarvis.jarvis_code_agent.code_agent import CodeAgent
+
+            # 如果是CodeAgent实例，则跳过注册，由CodeAgent.run自行管理
+            if not isinstance(self, CodeAgent):
+                set_current_agent(self.name, self)  # 标记agent开始运行
+            non_interactive_note = ""
+            if getattr(self, "non_interactive", False):
+                non_interactive_note = (
+                    "\n\n[系统说明]\n"
+                    "本次会话处于**非交互模式**：\n"
+                    "- 在 PLAN 模式中给出清晰、可执行的详细计划后，应**自动进入 EXECUTE 模式执行计划**，不要等待用户额外确认；\n"
+                    "- 在 EXECUTE 模式中，保持一步一步的小步提交和可回退策略，但不需要向用户反复询问“是否继续”；\n"
+                    "- 如遇信息严重不足，可以在 RESEARCH 模式中自行补充必要分析，而不是卡在等待用户输入。\n"
+                )
+
+                # 如果是非交互模式，可以假设用户输入的是完整的需求
+                self.pin_content = user_input
+
+            # 将非交互模式说明添加到用户输入中
+            enhanced_input = user_input + non_interactive_note
+            self.session.prompt = enhanced_input
+
             # 关键流程：直接调用 memory_manager 重置任务状态
             try:
                 self.memory_manager._on_task_started(
@@ -1260,7 +1554,7 @@ class Agent:
                 )
             except Exception:
                 pass
-            
+
             # 非关键流程：广播任务开始事件（用于日志、监控等）
             try:
                 self.event_bus.emit(
@@ -1272,18 +1566,48 @@ class Agent:
                 )
             except Exception:
                 pass
+
             return self._main_loop()
-        except Exception as e:
-            print(f"❌ 任务失败: {str(e)}")
-            return f"Task failed: {str(e)}"
+
+        finally:
+            if not isinstance(self, CodeAgent):
+                clear_current_agent()
 
     def _main_loop(self) -> Any:
         """主运行循环"""
         # 委派至独立的运行循环类，保持行为一致
         loop = AgentRunLoop(self)
+        self._agent_run_loop = loop  # 存储引用以便其他方法访问
         return loop.run()
 
-    def _handle_run_interrupt(self, current_response: str) -> Optional[Union[Any, "LoopAction"]]:
+    def set_non_interactive(self, value: bool) -> None:
+        """设置非交互模式并管理自动完成状态。
+
+        当进入非交互模式时，自动启用自动完成；
+        当退出非交互模式时，恢复自动完成的原始值。
+
+        参数:
+            value: 是否启用非交互模式
+        """
+        # 保存auto_complete的原始值（如果是首次设置）
+        if not hasattr(self, "_auto_complete_backup"):
+            self._auto_complete_backup = self.auto_complete
+
+        # 设置非交互模式（仅作为 Agent 实例属性，不写入环境变量或全局配置）
+        self.non_interactive = value
+
+        # 根据non_interactive的值调整auto_complete
+        if value:  # 进入非交互模式
+            self.auto_complete = True
+        else:  # 退出非交互模式
+            # 恢复auto_complete的原始值
+            self.auto_complete = self._auto_complete_backup
+            # 清理备份，避免状态污染
+            delattr(self, "_auto_complete_backup")
+
+    def _handle_run_interrupt(
+        self, current_response: str
+    ) -> Optional[Union[Any, "LoopAction"]]:
         """处理运行中的中断
 
         返回:
@@ -1295,6 +1619,11 @@ class Agent:
             return None
 
         set_interrupt(False)
+
+        # 被中断时，如果当前是非交互模式，立即切换到交互模式（在获取用户输入前）
+        if self.non_interactive:
+            self.set_non_interactive(False)
+
         user_input = self._multiline_input(
             "模型交互期间被中断，请输入用户干预信息：", False
         )
@@ -1316,17 +1645,21 @@ class Agent:
             return self._complete_task(auto_completed=False)
 
         if any(handler.can_handle(current_response) for handler in self.output_handler):
-            if self.confirm_callback("检测到有工具调用，是否继续处理工具调用？", True):
-                self.session.prompt = join_prompts([
-                    f"被用户中断，用户补充信息为：{user_input}",
-                    "用户同意继续工具调用。"
-                ])
+            if self.confirm_callback("检测到有工具调用，是否继续处理工具调用？", False):
+                self.session.prompt = join_prompts(
+                    [
+                        f"被用户中断，用户补充信息为：{user_input}",
+                        "用户同意继续工具调用。",
+                    ]
+                )
                 return None  # 继续执行工具调用
             else:
-                self.session.prompt = join_prompts([
-                    f"被用户中断，用户补充信息为：{user_input}",
-                    "检测到有工具调用，但被用户拒绝执行。请根据用户的补充信息重新考虑下一步操作。"
-                ])
+                self.session.prompt = join_prompts(
+                    [
+                        f"被用户中断，用户补充信息为：{user_input}",
+                        "检测到有工具调用，但被用户拒绝执行。请根据用户的补充信息重新考虑下一步操作。",
+                    ]
+                )
                 return LoopAction.SKIP_TURN  # 请求主循环 continue
         else:
             self.session.prompt = f"被用户中断，用户补充信息为：{user_input}"
@@ -1345,9 +1678,9 @@ class Agent:
         if user_input:
             self.session.prompt = user_input
             # 使用显式动作信号，保留返回类型注释以保持兼容
-            return LoopAction.CONTINUE  # type: ignore[return-value]
+            return LoopAction.CONTINUE
         else:
-            return LoopAction.COMPLETE  # type: ignore[return-value]
+            return LoopAction.COMPLETE
 
     def _first_run(self):
         """首次运行初始化"""
@@ -1368,14 +1701,22 @@ class Agent:
         self.first = False
 
     def _create_temp_model(self, system_prompt: str) -> BasePlatform:
-        """创建一个用于执行一次性任务的临时模型实例，以避免污染主会话。"""
-        temp_model = PlatformRegistry().create_platform(
-            self.model.platform_name()  # type: ignore
-        )
+        """创建一个用于执行一次性任务的临时模型实例，以避免污染主会话。
+
+        筛选操作使用cheap模型以降低成本。
+        """
+        from jarvis.jarvis_utils.config import get_cheap_model_name
+        from jarvis.jarvis_utils.config import get_cheap_platform_name
+
+        # 筛选操作使用cheap模型
+        platform_name = get_cheap_platform_name(None)
+        model_name = get_cheap_model_name(None)
+
+        temp_model = PlatformRegistry().create_platform(platform_name)
         if not temp_model:
             raise RuntimeError("创建临时模型失败。")
 
-        temp_model.set_model_name(self.model.name())  # type: ignore
+        temp_model.set_model_name(model_name)
         temp_model.set_system_prompt(system_prompt)
         return temp_model
 
@@ -1412,7 +1753,7 @@ class Agent:
 
     def _filter_tools_if_needed(self, task: str):
         """如果工具数量超过阈值，使用大模型筛选相关工具
-        
+
         注意：仅筛选用户自定义工具，内置工具不参与筛选（始终保留）
         """
         tool_registry = self.get_tool_registry()
@@ -1451,7 +1792,9 @@ class Agent:
 请根据用户任务，从列表中选择最相关的工具。
 请仅返回所选工具的编号，以逗号分隔。例如：1, 5, 12
 """
-        print(f"ℹ️ 工具数量超过{threshold}个，正在使用AI筛选相关工具...")
+        PrettyOutput.auto_print(
+            f"ℹ️ 工具数量超过{threshold}个，正在使用AI筛选相关工具..."
+        )
         # 广播工具筛选开始事件
         try:
             self.event_bus.emit(
@@ -1467,18 +1810,14 @@ class Agent:
         # 使用临时模型实例调用模型，以避免污染历史记录
         try:
             temp_model = self._create_temp_model("你是一个帮助筛选工具的助手。")
-            selected_tools_str = temp_model.chat_until_success(
-                selection_prompt
-            )  # type: ignore
+            selected_tools_str = temp_model.chat_until_success(selection_prompt)
 
             # 解析响应并筛选工具
             selected_indices = [
                 int(i.strip()) for i in re.findall(r"\d+", selected_tools_str)
             ]
             selected_tool_names = [
-                tool_names[i - 1]
-                for i in selected_indices
-                if 0 < i <= len(tool_names)
+                tool_names[i - 1] for i in selected_indices if 0 < i <= len(tool_names)
             ]
 
             if selected_tool_names:
@@ -1486,11 +1825,15 @@ class Agent:
                 selected_tool_names = sorted(list(set(selected_tool_names)))
                 # 合并内置工具名称和筛选出的用户自定义工具名称
                 builtin_names = list(tool_registry._builtin_tool_names)
-                final_tool_names = sorted(list(set(builtin_names + selected_tool_names)))
+                final_tool_names = sorted(
+                    list(set(builtin_names + selected_tool_names))
+                )
                 tool_registry.use_tools(final_tool_names)
                 # 使用筛选后的工具列表重新设置系统提示
                 self._setup_system_prompt()
-                print(f"✅ 已筛选出 {len(selected_tool_names)} 个相关工具: {', '.join(selected_tool_names)}")
+                PrettyOutput.auto_print(
+                    f"✅ 已筛选出 {len(selected_tool_names)} 个相关工具: {', '.join(selected_tool_names)}"
+                )
                 # 广播工具筛选事件
                 try:
                     self.event_bus.emit(
@@ -1504,7 +1847,7 @@ class Agent:
                 except Exception:
                     pass
             else:
-                print("⚠️ AI 未能筛选出任何相关工具，将使用所有工具。")
+                PrettyOutput.auto_print("⚠️ AI 未能筛选出任何相关工具，将使用所有工具。")
                 # 广播工具筛选事件（无筛选结果）
                 try:
                     self.event_bus.emit(
@@ -1519,7 +1862,7 @@ class Agent:
                     pass
 
         except Exception as e:
-            print(f"❌ 工具筛选失败: {e}，将使用所有工具。")
+            PrettyOutput.auto_print(f"❌ 工具筛选失败: {e}，将使用所有工具。")
 
     def _check_and_organize_memory(self):
         """
@@ -1536,7 +1879,7 @@ class Agent:
                 "global",
             )
         except Exception as e:
-            print(f"⚠️ 检查记忆库时发生意外错误: {e}")
+            PrettyOutput.auto_print(f"⚠️ 检查记忆库时发生意外错误: {e}")
 
     def _perform_memory_check(self, memory_type: str, base_path: Path, scope_name: str):
         """执行特定范围的记忆检查和整理"""
@@ -1578,7 +1921,9 @@ class Agent:
             f"是否立即整理记忆库以优化性能和相关性？"
         )
         if self.confirm_callback(prompt, False):
-            print(f"ℹ️ 正在开始整理 '{scope_name}' ({memory_type}) 记忆库...")
+            PrettyOutput.auto_print(
+                f"ℹ️ 正在开始整理 '{scope_name}' ({memory_type}) 记忆库..."
+            )
             organizer.organize_memories(memory_type, min_overlap=3)
         else:
-            print(f"ℹ️ 已取消 '{scope_name}' 记忆库整理。")
+            PrettyOutput.auto_print(f"ℹ️ 已取消 '{scope_name}' 记忆库整理。")