agent-Specialization/modules/sub_agent/manager.py

"""子智能体任务管理（主进程内协程模式）。

子智能体不再作为独立子进程启动，而是作为 SubAgentManager 所在事件循环中的
asyncio.Task 运行。所有实际工具调用都通过主 WebTerminal 执行，因此自然复用
主进程的宿主机沙箱 / Docker 容器链路。
"""

from __future__ import annotations

import asyncio
import json
import threading
import time
from pathlib import Path, PurePosixPath
from typing import Any, Dict, List, Optional, TYPE_CHECKING

from config import (
    OUTPUT_FORMATS,
    SUB_AGENT_DEFAULT_TIMEOUT,
    SUB_AGENT_MAX_ACTIVE,
    SUB_AGENT_MODELS_CONFIG_FILE,
    SUB_AGENT_STATUS_POLL_INTERVAL,
)
from utils.logger import setup_logger
from modules.sub_agent.task import SubAgentTask
from modules.sub_agent.prompts import build_user_message, build_system_prompt
from modules.sub_agent.tools import handle_search_workspace, handle_read_mediafile
from modules.sub_agent.state import SubAgentStateMixin
from modules.sub_agent.stats import SubAgentStatsMixin
from modules.sub_agent.creation import SubAgentCreationMixin
from modules.multi_agent.debug_logger import ma_debug
from modules.memory_debug import log_memory_event
from server.utils_common import debug_log

if TYPE_CHECKING:
    from core.web_terminal import WebTerminal
    from modules.user_container_manager import ContainerHandle

logger = setup_logger(__name__)
TERMINAL_STATUSES = {"completed", "failed", "timeout"}


class SubAgentManager(SubAgentStateMixin, SubAgentStatsMixin, SubAgentCreationMixin):
    """负责主智能体与子智能体的任务调度（协程模式）。"""

    def __init__(
        self,
        project_path: str,
        data_dir: str,
        container_session: Optional["ContainerHandle"] = None,
    ):
        self.project_path = Path(project_path).resolve()
        self.data_dir = Path(data_dir).resolve()
        # 子智能体任务和状态按 data_dir 隔离（web 模式下按用户/工作区自动隔离）
        self.base_dir = self.data_dir / "sub_agent_tasks"
        self.state_file = self.data_dir / "sub_agents.json"
        self.models_config_file = SUB_AGENT_MODELS_CONFIG_FILE
        self.container_session: Optional["ContainerHandle"] = container_session
        self.host_execution_mode: str = "sandbox"
        self.terminal: Optional["WebTerminal"] = None
        # 多智能体模式：为每个启用 multi_agent_mode 的会话维护一个 MultiAgentState
        # key = conversation_id, value = MultiAgentState
        self.multi_agent_states: Dict[str, Any] = {}

        self.base_dir.mkdir(parents=True, exist_ok=True)
        self.state_file.parent.mkdir(parents=True, exist_ok=True)

        self.tasks: Dict[str, Dict[str, Any]] = {}
        self.conversation_agents: Dict[str, List[int]] = {}
        self._running_tasks: Dict[str, asyncio.Task] = {}
        self._event_loop: Optional[asyncio.AbstractEventLoop] = None
        self._loop_thread: Optional[threading.Thread] = None
        self._state_lock = threading.Lock()
        # agent_id -> SubAgentTask 映射（供多智能体消息注入使用）
        self._sub_agent_instances: Dict[int, Any] = {}

        self._load_state()
        try:
            self.reconcile_task_states()
        except Exception:
            pass
        try:
            self.restore_running_tasks()
        except Exception:
            logger.exception("[SubAgentManager] 恢复运行中子智能体任务失败")
            pass

    # ------------------------------------------------------------------
    # 生命周期与事件循环
    # ------------------------------------------------------------------
    def _ensure_event_loop(self) -> asyncio.AbstractEventLoop:
        """确保有一个独立的后台事件循环供子智能体使用。"""
        if self._event_loop is not None and not self._event_loop.is_closed():
            return self._event_loop

        loop = asyncio.new_event_loop()
        self._event_loop = loop

        def run_loop():
            asyncio.set_event_loop(loop)
            try:
                loop.run_forever()
            finally:
                try:
                    loop.close()
                except Exception:
                    pass

        thread = threading.Thread(target=run_loop, name="sub-agent-loop", daemon=True)
        thread.start()
        self._loop_thread = thread
        return loop

    async def _create_task(self, coro):
        """在事件循环内部把协程包装为 Task。"""
        return asyncio.create_task(coro)

    def _run_coro(self, coro):
        """在后台事件循环中调度一个协程并返回 asyncio.Task。"""
        loop = self._ensure_event_loop()
        # 先提交创建 Task 的协程，阻塞等待拿到 Task 句柄
        future = asyncio.run_coroutine_threadsafe(self._create_task(coro), loop)
        return future.result(timeout=10)

    def set_terminal(self, terminal: "WebTerminal") -> None:
        """注入主终端引用，用于工具执行代理。"""
        self.terminal = terminal

    def set_container_session(self, session: Optional["ContainerHandle"]):
        """更新容器会话信息。"""
        self.container_session = session

    def set_host_execution_mode(self, mode: str) -> None:
        normalized = str(mode or "").strip().lower()
        self.host_execution_mode = "direct" if normalized == "direct" else "sandbox"

    # ------------------------------------------------------------------
    # 公共方法
    # ------------------------------------------------------------------
    def create_sub_agent(
        self,
        *,
        agent_id: int,
        summary: str,
        task: str,
        deliverables_dir: Optional[str] = None,
        timeout_seconds: Optional[int] = None,
        conversation_id: Optional[str] = None,
        run_in_background: bool = False,
        model_key: Optional[str] = None,
        thinking_mode: Optional[str] = None,
        multi_agent_mode: bool = False,
        role_id: Optional[str] = None,
        display_name: Optional[str] = None,
        system_prompt: Optional[str] = None,
        task_message: Optional[str] = None,
        compress_threshold_tokens: Optional[int] = None,
    ) -> Dict:
        """创建子智能体任务并启动协程。
        
        参数 multi_agent_mode: True 时启用多智能体模式。
        参数 role_id: 多智能体模式下的角色标诶。
        参数 display_name: 多智能体模式下的显示名（如 UI Operator_1）。
        """
        validation_error = self._validate_create_params(agent_id, summary, task, deliverables_dir, multi_agent_mode=multi_agent_mode)
        if validation_error:
            return {"success": False, "error": validation_error}

        if not thinking_mode:
            return {"success": False, "error": "缺少 thinking_mode 参数，必须指定 fast 或 thinking"}
        if thinking_mode not in {"fast", "thinking"}:
            return {"success": False, "error": "thinking_mode 仅支持 fast 或 thinking"}

        if not conversation_id:
            return {"success": False, "error": "缺少对话ID，无法创建子智能体"}

        if not self._ensure_agent_slot_available(conversation_id, agent_id):
            return {
                "success": False,
                "error": f"该对话已使用过编号 {agent_id}，请更换新的子智能体代号。"
            }

        if self._active_task_count(conversation_id) >= SUB_AGENT_MAX_ACTIVE:
            return {
                "success": False,
                "error": f"该对话已存在 {SUB_AGENT_MAX_ACTIVE} 个运行中的子智能体，请稍后再试。",
            }

        task_id = self._generate_task_id(agent_id)
        task_root = self.base_dir / task_id
        task_root.mkdir(parents=True, exist_ok=True)

        try:
            deliverables_path = self._resolve_deliverables_dir(deliverables_dir, multi_agent_mode=multi_agent_mode)
        except ValueError as exc:
            return {"success": False, "error": str(exc)}

        task_file = task_root / "task.txt"
        system_prompt_file = task_root / "system_prompt.txt"
        output_file = task_root / "output.json"
        stats_file = task_root / "stats.json"
        progress_file = task_root / "progress.jsonl"
        conversation_file = task_root / "conversation.json"

        prompt_workspace = self._get_runtime_path(self.project_path)
        deliverables_display = self._get_runtime_path(deliverables_path)
        if task_message:
            user_message = task_message
        else:
            display_timeout = timeout_seconds if timeout_seconds is not None else 0
            user_message = build_user_message(agent_id, summary, task, deliverables_display, display_timeout or SUB_AGENT_DEFAULT_TIMEOUT)
        task_file.write_text(user_message, encoding="utf-8")

        if system_prompt:
            final_system_prompt = system_prompt
        else:
            final_system_prompt = build_system_prompt(prompt_workspace)
        system_prompt_file.write_text(final_system_prompt, encoding="utf-8")

        # timeout_seconds 为 None 表示永久子智能体（不会被时间终结）
        task_record = {
            "task_id": task_id,
            "agent_id": agent_id,
            "summary": summary,
            "task": task,
            "status": "running",
            "deliverables_dir": str(deliverables_path),
            "timeout_seconds": timeout_seconds,
            "thinking_mode": thinking_mode,
            "created_at": time.time(),
            "updated_at": time.time(),
            "conversation_id": conversation_id,
            "run_in_background": run_in_background,
            "multi_agent_mode": bool(multi_agent_mode),
            "task_root": str(task_root),
            "output_file": str(output_file),
            "stats_file": str(stats_file),
            "progress_file": str(progress_file),
            "conversation_file": str(conversation_file),
            "model_key": model_key,
            "role_id": role_id,
            "display_name": display_name,
            "execution_mode": "in_process",
            "compress_threshold_tokens": compress_threshold_tokens,
            "container_name": None,
        }
        self.tasks[task_id] = task_record
        self._mark_agent_id_used(conversation_id, agent_id)
        self._save_state()

        # 多智能体模式：为该会话创建或复用 MultiAgentState
        multi_agent_state = None
        if multi_agent_mode:
            multi_agent_state = self.get_or_create_multi_agent_state(conversation_id)
            # 把实例注册到 state
            from modules.multi_agent.state import AgentInstance
            inst = AgentInstance(
                agent_id=agent_id,
                role_id=role_id or "",
                display_name=display_name or f"Agent_{agent_id}",
                task_id=task_id,
                status="running",
                summary=summary,
            )
            try:
                multi_agent_state.register_instance(inst)
            except ValueError:
                return {"success": False, "error": f"agent_id {agent_id} 已在该会话中使用"}

        sub_agent = SubAgentTask(
            manager=self,
            task_record=task_record,
            task_message=user_message,
            system_prompt=final_system_prompt,
            model_key=model_key,
            thinking_mode=thinking_mode,
            multi_agent_mode=multi_agent_mode,
            multi_agent_state=multi_agent_state,
            display_name=display_name,
        )
        ma_debug(
            "manager_create_sub_agent_state",
            task_id=task_id,
            agent_id=agent_id,
            conversation_id=conversation_id,
            state_id=id(multi_agent_state) if multi_agent_state else None,
        )
        log_memory_event(
            "sub_agent_manager_create_sub_agent",
            task_id=task_id,
            agent_id=agent_id,
            conversation_id=conversation_id,
            display_name=display_name,
            multi_agent_mode=multi_agent_mode,
            total_tasks=len(self.tasks),
            running_tasks=len(self._running_tasks),
        )
        task_coro = sub_agent.run()
        asyncio_task = self._run_coro(task_coro)
        sub_agent._task = asyncio_task
        self._running_tasks[task_id] = asyncio_task
        # 缓存 sub_agent 实例供给多智能体模式 Poli注入使用
        self._sub_agent_instances[agent_id] = sub_agent

        def _on_done(fut):
            try:
                log_memory_event(
                    "sub_agent_task_done_callback",
                    task_id=task_id,
                    agent_id=agent_id,
                    conversation_id=conversation_id,
                    multi_agent_mode=multi_agent_mode,
                )
                self._running_tasks.pop(task_id, None)
                self._sub_agent_instances.pop(agent_id, None)
                self.reconcile_task_states(conversation_id=conversation_id)
                # 多智能体模式：结束时把状态写回 MultiAgentState
                if multi_agent_mode and multi_agent_state:
                    self._on_multi_agent_task_done(task_id, agent_id, multi_agent_state, sub_agent)
            except Exception as exc:
                logger.exception(f"[SubAgent] task {task_id} 完成回调异常: {exc}")
                ma_debug("manager_on_done_exception", task_id=task_id, agent_id=agent_id, error=str(exc))

        asyncio_task.add_done_callback(_on_done)

        message = f"子智能体{agent_id} 已创建，任务ID: {task_id}"
        if multi_agent_mode and display_name:
            message = f"{display_name} 已创建，任务ID: {task_id}"
        print(f"{OUTPUT_FORMATS['info']} {message}")
        ma_debug(
            "manager_create_sub_agent",
            task_id=task_id,
            agent_id=agent_id,
            display_name=display_name,
            multi_agent_mode=multi_agent_mode,
            run_in_background=task_record.get("run_in_background"),
            timeout_seconds=timeout_seconds,
        )

        return {
            "success": True,
            "task_id": task_id,
            "agent_id": agent_id,
            "status": "running",
            "message": message,
            "deliverables_dir": str(deliverables_path),
            "run_in_background": run_in_background,
            "display_name": display_name,
        }

    def wait_for_completion(
        self,
        *,
        task_id: Optional[str] = None,
        agent_id: Optional[int] = None,
        timeout_seconds: Optional[int] = None,
    ) -> Dict:
        """阻塞等待子智能体完成或超时。"""
        task = self._select_task(task_id, agent_id)
        if not task:
            return {"success": False, "error": "未找到对应的子智能体任务"}

        if task.get("status") in TERMINAL_STATUSES or task.get("status") == "terminated":
            if task.get("final_result"):
                return task["final_result"]
            return {"success": False, "status": task.get("status"), "message": "子智能体已结束。"}

        real_task_id = task["task_id"]
        deadline = time.time() + (timeout_seconds or task.get("timeout_seconds") or SUB_AGENT_DEFAULT_TIMEOUT)

        while time.time() < deadline:
            self.reconcile_task_states()
            # 关键：其他线程（如前端轮询 /api/sub_agents）可能调用 _load_state()
            # 并替换 self.tasks 字典，导致旧 task 引用失效。每次循环重新获取引用。
            task = self.tasks.get(real_task_id)
            if not task:
                return {"success": False, "error": "未找到对应的子智能体任务"}
            running_task = self._running_tasks.get(real_task_id)
            status = task.get("status")

            # 已到达终态：返回最终结果（持续 reconcile 直到 final_result 就绪）
            if status in TERMINAL_STATUSES or status == "terminated":
                if task.get("final_result"):
                    return task["final_result"]
                # 终态但 final_result 尚未写入，短暂等待后重试
                time.sleep(SUB_AGENT_STATUS_POLL_INTERVAL)
                self.reconcile_task_states()
                task = self.tasks.get(real_task_id) or task
                if task.get("final_result"):
                    return task["final_result"]
                return {"success": False, "status": status, "message": "子智能体已结束，但未获取到结果。"}

            # asyncio Task 已结束但状态可能还没同步：等待 final_result 就绪
            if running_task and running_task.done():
                self.reconcile_task_states()
                task = self.tasks.get(real_task_id) or task
                if task.get("final_result"):
                    return task["final_result"]
                # 结果尚未落盘，继续轮询，避免把「已创建」误判为失败
                time.sleep(SUB_AGENT_STATUS_POLL_INTERVAL)
                continue

            time.sleep(SUB_AGENT_STATUS_POLL_INTERVAL)

        return self._handle_timeout(task)

    def soft_stop_all_agents(self, conversation_id: str) -> int:
        """软停止指定会话的所有运行中子智能体。

        与 terminate_sub_agent 的区别：不取消 asyncio.Task 而是设 _soft_stop 标志，
        让子智能体在当前工具完成后进入 idle 状态，保留上下文。
        返回实际发出软停止信号的子智能体数量。
        """
        ma_debug("soft_stop_all_agents_enter", conversation_id=conversation_id)
        count = 0
        matched = 0
        skipped_terminal = 0
        skipped_no_instance = 0
        for task_id, task_info in list(self.tasks.items()):
            if task_info.get("conversation_id") != conversation_id:
                continue
            matched += 1
            status = task_info.get("status")
            ma_debug(
                "soft_stop_iter",
                task_id=task_id,
                status=status,
            )
            if status in TERMINAL_STATUSES.union({"terminated", "idle"}):
                skipped_terminal += 1
                continue
            agent_id = task_info.get("agent_id")
            if agent_id is None:
                continue
            # 從 _sub_agent_instances 查找 SubAgentTask 实例
            sub_agent_task = self._sub_agent_instances.get(agent_id)
            if sub_agent_task and hasattr(sub_agent_task, "request_soft_stop"):
                try:
                    sub_agent_task.request_soft_stop()
                    count += 1
                except Exception as exc:
                    ma_debug("soft_stop_failed", task_id=task_id, error=str(exc))
            else:
                skipped_no_instance += 1
        ma_debug(
            "soft_stop_all_agents_done",
            conversation_id=conversation_id,
            matched=matched,
            count=count,
            skipped_terminal=skipped_terminal,
            skipped_no_instance=skipped_no_instance,
        )
        return count

    def terminate_sub_agent(
        self,
        *,
        task_id: Optional[str] = None,
        agent_id: Optional[int] = None,
    ) -> Dict:
        """强制关闭指定子智能体。"""
        task = self._select_task(task_id, agent_id)
        if not task:
            return {"success": False, "error": "未找到对应的子智能体任务"}

        task_id = task["task_id"]
        running_task = self._running_tasks.pop(task_id, None)
        if running_task and not running_task.done():
            # 子智能体运行在独立事件循环线程中，取消操作必须投递到该循环
            try:
                loop = running_task.get_loop()
                loop.call_soon_threadsafe(running_task.cancel)
            except Exception:
                running_task.cancel()
            deadline = time.time() + 5
            while not running_task.done() and time.time() < deadline:
                time.sleep(0.05)

        self._mark_task_terminated(
            task,
            message="子智能体已被强制关闭。",
            system_message=f"🛑 子智能体{task.get('agent_id')} 已被手动关闭。",
            notified=True,
        )
        self._save_state()

        return {
            "success": True,
            "task_id": task_id,
            "message": "子智能体已被强制关闭。",
            "system_message": f"🛑 子智能体{task.get('agent_id')} 已被手动关闭。",
        }

    def get_sub_agent_status(
        self,
        *,
        agent_ids: Optional[List[int]] = None,
    ) -> Dict:
        """获取指定子智能体的详细状态。

        对于已结束（completed/failed/timeout/terminated）的子智能体，同样返回其
        最终状态，而不是返回「不存在」。
        """
        if not agent_ids:
            return {"success": False, "error": "必须指定至少一个agent_id"}

        def _find_task_by_agent_id(aid: int):
            # 先查运行中/待运行的任务
            task = self._select_task(None, aid)
            if task:
                return task
            # 再查已结束的任务（按创建时间取最新一条）
            candidates = [
                t for t in self.tasks.values()
                if t.get("agent_id") == aid
            ]
            if not candidates:
                return None
            candidates.sort(key=lambda item: item.get("created_at", 0), reverse=True)
            return candidates[0]

        results = []
        for agent_id in agent_ids:
            task = _find_task_by_agent_id(agent_id)
            if not task:
                results.append({
                    "agent_id": agent_id,
                    "found": False,
                    "error": "子智能体不存在",
                })
                continue

            status = task.get("status")
            if status not in TERMINAL_STATUSES.union({"terminated"}):
                self._check_task_status(task)
                status = task.get("status")

            stats = {}
            stats_file = Path(task.get("stats_file", ""))
            if stats_file.exists():
                try:
                    stats = json.loads(stats_file.read_text(encoding="utf-8"))
                except Exception:
                    pass
            stats_summary = self._build_stats_summary(stats)

            results.append({
                "agent_id": agent_id,
                "found": True,
                "task_id": task["task_id"],
                "status": status,
                "summary": task.get("summary"),
                "created_at": task.get("created_at"),
                "updated_at": task.get("updated_at"),
                "deliverables_dir": task.get("deliverables_dir"),
                "stats": stats,
                "stats_summary": stats_summary,
                "final_result": task.get("final_result"),
            })

        return {"success": True, "results": results}

    def poll_updates(self) -> List[Dict]:
        """检查运行中的子智能体任务，返回新完成的结果。"""
        updates: List[Dict] = []
        self.reconcile_task_states()
        pending_tasks = [
            task for task in self.tasks.values()
            if task.get("status") not in TERMINAL_STATUSES.union({"terminated"})
        ]
        if not pending_tasks:
            return updates

        state_changed = False
        for task in pending_tasks:
            result = self._check_task_status(task)
            if result["status"] in TERMINAL_STATUSES:
                updates.append(result)
                state_changed = True

        if state_changed:
            self._save_state()
        return updates

    def lookup_task(self, *, task_id: Optional[str] = None, agent_id: Optional[int] = None) -> Optional[Dict]:
        """只读查询任务信息。"""
        task = self._select_task(task_id, agent_id)
        if not task:
            return None
        return {
            "task_id": task.get("task_id"),
            "agent_id": task.get("agent_id"),
            "status": task.get("status"),
            "timeout_seconds": task.get("timeout_seconds"),
            "conversation_id": task.get("conversation_id"),
        }

    def get_overview(self, conversation_id: Optional[str] = None) -> List[Dict[str, Any]]:
        """返回子智能体任务概览，用于前端展示。"""
        self.reconcile_task_states(conversation_id=conversation_id)
        overview: List[Dict[str, Any]] = []
        for task_id, task in self.tasks.items():
            if conversation_id and task.get("conversation_id") != conversation_id:
                continue

            snapshot = {
                "task_id": task_id,
                "agent_id": task.get("agent_id"),
                "summary": task.get("summary"),
                "status": task.get("status"),
                "display_name": task.get("display_name") or "",
                "created_at": task.get("created_at"),
                "updated_at": task.get("updated_at"),
                "target_dir": task.get("target_project_dir"),
                "last_tool": task.get("last_tool"),
                "deliverables_dir": task.get("deliverables_dir"),
                "copied_path": task.get("copied_path"),
                "conversation_id": task.get("conversation_id"),
                "sub_conversation_id": task.get("sub_conversation_id"),
            }

            # 读取 stats 文件获取当前上下文 token
            stats_file = Path(task.get("stats_file", ""))
            if stats_file.exists():
                try:
                    stats = json.loads(stats_file.read_text(encoding="utf-8"))
                    snapshot["current_context_tokens"] = stats.get("current_context_tokens", 0)
                    snapshot["stats_summary"] = self._build_stats_summary(stats)
                except Exception:
                    snapshot["current_context_tokens"] = 0
            else:
                snapshot["current_context_tokens"] = 0

            if snapshot["status"] in TERMINAL_STATUSES or snapshot["status"] == "terminated":
                final_result = task.get("final_result") or {}
                snapshot["final_message"] = final_result.get("system_message") or final_result.get("message")
                snapshot["success"] = final_result.get("success")

            overview.append(snapshot)

        overview.sort(key=lambda item: item.get("created_at") or 0, reverse=True)
        return overview

    # ------------------------------------------------------------------
    # 工具执行代理
    # ------------------------------------------------------------------
    async def execute_tool_for_sub_agent(self, tool_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
        """代表子智能体在主进程中执行工具。"""
        if not self.terminal:
            return {"success": False, "error": "子智能体管理器未绑定终端，无法执行工具"}

        try:
            # 多智能体模式常见问答工具已在 SubAgentTask._execute_multi_agent_tool 中处理
            # 这里只处理实际通过主进程执行的工具
            if tool_name == "search_workspace":
                return await handle_search_workspace(self.project_path, self.terminal, arguments)
            if tool_name == "read_mediafile":
                return await handle_read_mediafile(self.project_path, arguments)

            # 其余工具直接走主进程 handle_tool_call，自然经过沙箱/容器/权限链路
            result_text = await self.terminal.handle_tool_call(tool_name, arguments)
            try:
                return json.loads(result_text)
            except Exception:
                return {"success": True, "output": result_text}
        except Exception as exc:
            logger.exception(f"[SubAgent] 工具执行异常: {tool_name}")
            return {"success": False, "error": f"工具执行异常: {exc}"}

    # ------------------------------------------------------------------
    # 重启后恢复运行中任务
    # ------------------------------------------------------------------
    def restore_running_tasks(self) -> int:
        """程序重启后，从 conversation.json 恢复非终态子智能体任务并重新运行。

        返回成功恢复的任务数。
        """
        from modules.sub_agent.task import SubAgentTask

        restored = 0
        terminal_statuses = TERMINAL_STATUSES.union({"terminated"})
        for task_id, task in list(self.tasks.items()):
            if not isinstance(task, dict):
                continue
            # 仅恢复多智能体模式任务；传统子智能体保持原有清理逻辑
            if not task.get("multi_agent_mode"):
                continue
            status = task.get("status", "running")
            if status in terminal_statuses:
                continue
            # 已在内存中运行，无需恢复
            if task_id in self._running_tasks:
                continue

            task_root = Path(task.get("task_root", ""))
            conversation_file = Path(task.get("conversation_file", ""))
            system_prompt_file = task_root / "system_prompt.txt"
            task_message_file = task_root / "task.txt"

            if not conversation_file.exists():
                logger.warning(f"[restore] 任务 {task_id} 的对话文件缺失，无法恢复")
                continue

            try:
                conversation_data = json.loads(conversation_file.read_text(encoding="utf-8"))
                messages = list(conversation_data.get("messages") or [])
            except Exception as exc:
                logger.warning(f"[restore] 读取任务 {task_id} 对话文件失败: {exc}")
                continue

            system_prompt = ""
            if system_prompt_file.exists():
                try:
                    system_prompt = system_prompt_file.read_text(encoding="utf-8")
                except Exception:
                    pass

            task_message = ""
            if task_message_file.exists():
                try:
                    task_message = task_message_file.read_text(encoding="utf-8")
                except Exception:
                    pass

            # 如果对话历史为空，用 task_message 兜底
            if not messages:
                messages = [
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": task_message},
                ]

            agent_id = int(task.get("agent_id", 0))
            conversation_id = task.get("conversation_id")
            multi_agent_mode = bool(task.get("multi_agent_mode"))
            thinking_mode = task.get("thinking_mode") or "fast"
            model_key = task.get("model_key")
            display_name = task.get("display_name")
            role_id = task.get("role_id")

            multi_agent_state = None
            if multi_agent_mode and conversation_id:
                multi_agent_state = self.get_or_create_multi_agent_state(conversation_id)
                # 如果 snapshot 里没有该实例，根据 task_record 重建一个
                if multi_agent_state and not multi_agent_state.get_instance(agent_id):
                    from modules.multi_agent.state import AgentInstance
                    inst = AgentInstance(
                        agent_id=agent_id,
                        role_id=role_id or "",
                        display_name=display_name or f"Agent_{agent_id}",
                        task_id=task_id,
                        status=status if status in ("running", "idle") else "running",
                        summary=task.get("summary", ""),
                    )
                    try:
                        multi_agent_state.register_instance(inst)
                    except ValueError:
                        pass

            sub_agent = SubAgentTask(
                manager=self,
                task_record=task,
                task_message=task_message,
                system_prompt=system_prompt,
                model_key=model_key,
                thinking_mode=thinking_mode,
                multi_agent_mode=multi_agent_mode,
                multi_agent_state=multi_agent_state,
                display_name=display_name,
            )
            sub_agent.messages = messages
            # 重启后统一置为 idle，等待主智能体再次发消息才继续
            if multi_agent_mode:
                sub_agent._idle = True
                task["status"] = "idle"
                task["updated_at"] = time.time()
                if multi_agent_state:
                    multi_agent_state.mark_status(agent_id, "idle")
                # 同步落盘 output.json，保证前端状态一致
                try:
                    output_file = Path(task.get("output_file", ""))
                    if output_file.exists():
                        output_data = json.loads(output_file.read_text(encoding="utf-8"))
                    else:
                        output_data = {}
                    output_data["status"] = "idle"
                    output_data["success"] = None
                    output_file.parent.mkdir(parents=True, exist_ok=True)
                    output_file.write_text(json.dumps(output_data, ensure_ascii=False), encoding="utf-8")
                except Exception as exc:
                    logger.warning(f"[restore] 更新任务 {task_id} output 文件失败: {exc}")

            task_coro = sub_agent.run()
            asyncio_task = self._run_coro(task_coro)
            sub_agent._task = asyncio_task
            self._running_tasks[task_id] = asyncio_task
            self._sub_agent_instances[agent_id] = sub_agent

            def _on_done(fut, tid=task_id, aid=agent_id, state=multi_agent_state, sa=sub_agent):
                try:
                    self._running_tasks.pop(tid, None)
                    self._sub_agent_instances.pop(aid, None)
                    self.reconcile_task_states(conversation_id=conversation_id)
                    if multi_agent_mode and state:
                        self._on_multi_agent_task_done(tid, aid, state, sa)
                except Exception as exc:
                    logger.exception(f"[SubAgent] restored task {tid} 完成回调异常: {exc}")
                    ma_debug("manager_restore_on_done_exception", task_id=tid, agent_id=aid, error=str(exc))

            asyncio_task.add_done_callback(_on_done)
            restored += 1
            ma_debug(
                "manager_restore_sub_agent",
                task_id=task_id,
                agent_id=agent_id,
                display_name=display_name,
                multi_agent_mode=multi_agent_mode,
                status=status,
                message_count=len(messages),
            )

        if restored:
            self._save_state()
        return restored

    # ------------------------------------------------------------------
    # 多智能体模式：状态管理、外部接口、消息注入
    # ------------------------------------------------------------------
    def get_or_create_multi_agent_state(self, conversation_id: str):
        """获取或为该会话创建 MultiAgentState。"""
        from modules.multi_agent.state import MultiAgentState
        state = self.multi_agent_states.get(conversation_id)
        if state:
            ma_debug(
                "manager_get_or_create_ma_state_reuse",
                conversation_id=conversation_id,
                state_id=id(state),
                manager_id=id(self),
            )
            return state
        state = MultiAgentState(conversation_id=conversation_id)
        self.multi_agent_states[conversation_id] = state
        ma_debug(
            "manager_get_or_create_ma_state_create",
            conversation_id=conversation_id,
            state_id=id(state),
            manager_id=id(self),
        )
        return state

    def get_multi_agent_state(self, conversation_id: str):
        """获取该会话的多智能体状态。"""
        state = self.multi_agent_states.get(conversation_id)
        ma_debug(
            "manager_get_multi_agent_state",
            conversation_id=conversation_id,
            found=bool(state),
            state_id=id(state) if state else None,
            manager_id=id(self),
        )
        return state

    def drop_multi_agent_state(self, conversation_id: str) -> None:
        """删除会话状态（会话结束时调用）。"""
        self.multi_agent_states.pop(conversation_id, None)

    def reconcile_task_states(self, conversation_id: Optional[str] = None) -> int:
        """修正运行态任务状态。

        在父类实现前先根据内存中的 MultiAgentState 给旧任务补上 multi_agent_mode
        标记，避免任务记录缺字段导致被当成普通子智能体误判为 failed。
        """
        if conversation_id and conversation_id in self.multi_agent_states:
            state = self.multi_agent_states[conversation_id]
            agent_ids = {a.agent_id for a in state.list_all()}
            for task in self.tasks.values():
                if (
                    isinstance(task, dict)
                    and task.get("conversation_id") == conversation_id
                    and task.get("agent_id") in agent_ids
                    and task.get("multi_agent_mode") is None
                ):
                    task["multi_agent_mode"] = True
                    task["updated_at"] = time.time()
        changed = super().reconcile_task_states(conversation_id=conversation_id)

        # 多智能体模式下，子智能体进入 idle 后底层 asyncio.Task 仍在等待唤醒，
        # 父类 reconcile 会据此把任务标回 running。这里根据内存中的 SubAgentTask
        # 实例重新把 idle 状态写回任务记录，使运行态与 MultiAgentState 保持一致。
        extra_changed = 0
        for task in self.tasks.values():
            if not isinstance(task, dict):
                continue
            if conversation_id and task.get("conversation_id") != conversation_id:
                continue
            if not task.get("multi_agent_mode"):
                continue
            agent_id = task.get("agent_id")
            inst = self._sub_agent_instances.get(agent_id) if agent_id else None
            if inst:
                if getattr(inst, "_idle", False):
                    if task.get("status") != "idle":
                        task["status"] = "idle"
                        task["updated_at"] = time.time()
                        ma_debug(
                            "reconcile_task_runtime_state_idle_fix",
                            task_id=task.get("task_id"),
                            agent_id=agent_id,
                        )
                        extra_changed += 1
                elif task.get("status") == "idle":
                    # 子智能体已被唤醒且 _idle=false，但 output 文件或父类 reconcile
                    # 可能仍把任务标为 idle。这里强制同步回 running。
                    task["status"] = "running"
                    task["updated_at"] = time.time()
                    ma_debug(
                        "reconcile_task_runtime_state_running_fix",
                        task_id=task.get("task_id"),
                        agent_id=agent_id,
                    )
                    extra_changed += 1
        if extra_changed:
            self._save_state()
            changed += extra_changed
        return changed

    def inject_message_to_sub_agent(self, agent_id: int, message_text: str) -> bool:
        """同事件循环中向子智能体上下文插入 user 消息。
        
        适用于 ask_other_agent / send_message_to_sub_agent / answer_sub_agent_question_
        （非阻塞到工具结果的路径）。返回 True 表示成功注入。
        """
        # 查找该 agent_id 对应的 running SubAgentTask
        sub_agent = self._find_sub_agent_task_by_agent_id(agent_id)
        ma_debug(
            "manager_inject_message_to_sub_agent",
            agent_id=agent_id,
            message_preview=str(message_text)[:500],
            found=bool(sub_agent),
            task_id=sub_agent.task_id if sub_agent else None,
        )
        if not sub_agent:
            return False
        sub_agent.inject_message(message_text)
        return True

    def _find_sub_agent_task_by_agent_id(self, agent_id: int) -> Optional[Any]:
        """通过遍历创建中的 task 查找活 SubAgentTask 实例。
        
        这是个 helper：在主实现中我们需要保留从 agent_id 到 SubAgentTask 的引用。
        理论上可以在 create_sub_agent 时把 sub_agent 存起来，这里使用 rs safer贪心法：
        遊历 _running_tasks 不为可行，因为 asyncio.Task 不抽不包含 SubAgentTask引用。
        我们改为 `SubAgentTask` 对象列表供查询。
        """
        # 优先查缓存：create_sub_agent 时的字段
        for inst in self._sub_agent_instances.values():
            if inst.agent_id == agent_id:
                return inst
        return None

    def _on_multi_agent_task_done(self, task_id: str, agent_id: int, state: Any, sub_agent: Any) -> None:
        """SubAgentTask 结束回调会调这个更新 MultiAgentState 实例状态。"""
        final_task = self.tasks.get(task_id) or {}
        final_status_before = final_task.get("status")
        ma_debug(
            "manager_on_multi_agent_task_done",
            task_id=task_id,
            agent_id=agent_id,
            sub_agent_idle=getattr(sub_agent, "_idle", False),
            sub_agent_cancelled=getattr(sub_agent, "_cancelled", False),
            task_status_before=final_status_before,
        )
        # 多智能体模式下，子智能体自然进入 idle 后 Task 可能被外部事件循环取消，
        # 或者 reconcile 把 idle 误判为 failed。优先以 SubAgentTask 自身状态为准：
        # - 被手动取消 -> terminated
        # - 自然进入 idle -> idle（可继续接收消息）
        # - 真正异常/超时/finish_task 失败 -> failed/timeout
        if getattr(sub_agent, "_cancelled", False):
            state.mark_status(agent_id, "terminated")
            ma_debug("manager_ma_state_set", agent_id=agent_id, status="terminated", reason="sub_agent_cancelled")
            return
        if getattr(sub_agent, "_idle", False):
            state.mark_status(agent_id, "idle")
            ma_debug("manager_ma_state_set", agent_id=agent_id, status="idle", reason="sub_agent_idle")
            return

        # 兜底：取出当前 task status（由 _finalize_task 设置）
        final_status = final_task.get("status")
        if final_status in TERMINAL_STATUSES:
            state.mark_status(agent_id, final_status, last_output=str(final_task.get("final_result") or ""))
            ma_debug("manager_ma_state_set", agent_id=agent_id, status=final_status, reason="task_terminal_status")
        elif final_status == "terminated":
            state.mark_status(agent_id, "terminated")
            ma_debug("manager_ma_state_set", agent_id=agent_id, status="terminated", reason="task_terminated_status")
        else:
            state.mark_status(agent_id, "idle")
            ma_debug("manager_ma_state_set", agent_id=agent_id, status="idle", reason="fallback_idle")

    def _get_runtime_path(self, host_path: Path) -> str:
        """将宿主机路径映射为容器内路径（仅用于提示展示）。"""
        if not self.container_session or getattr(self.container_session, "mode", None) != "docker":
            return str(host_path)
        mount_path = (getattr(self.container_session, "mount_path", None) or "/workspace").rstrip("/") or "/workspace"
        try:
            relative = host_path.resolve().relative_to(self.project_path)
        except Exception:
            return mount_path
        if str(relative) in {"", "."}:
            return mount_path
        return str(PurePosixPath(mount_path) / PurePosixPath(relative.as_posix()))