Skip to content

JiuwenSwarm is an intelligent AI Agent built on openJiuwen. It extends the powerful capabilities of large language models directly to your fingertips through various communication apps you use daily.

Python
133 KB
Raw Blame
import asyncio
import json
import types

import pytest
from openjiuwen.agent_teams.runtime import RunActionKind

from jiuwenswarm.server import agent_ws_server as agent_ws_server_module
from jiuwenswarm.server.runtime.agent_manager import ACP_DEFAULT_CAPABILITIES
from jiuwenswarm.agents.harness.common.tools import acp_output_tools
from jiuwenswarm.agents.harness.common.tools.acp_output_tools import AcpOutputRequest, get_acp_output_manager
from jiuwenswarm.server.runtime.agent_adapter import interface_deep as interface_deep_module
from jiuwenswarm.server.runtime.agent_adapter import team_helpers as team_helpers_module
from jiuwenswarm.server.utils.stream_utils import parse_stream_chunk
from jiuwenswarm.server.runtime.agent_adapter.interface_deep import (
    _build_context_assemble_rail,
    _build_context_processor_rail,
)
from jiuwenswarm.common.e2a.gateway_normalize import e2a_from_agent_fields
from jiuwenswarm.common.schema.agent import AgentRequest
from jiuwenswarm.common.schema.message import ReqMethod


import importlib as _importlib
import pkgutil as _pkgutil

from jiuwenswarm.server import handlers as _handlers_pkg
from jiuwenswarm.server.handlers import bootstrap as bootstrap_module  # noqa: F401
from jiuwenswarm.server.handlers import team as team_module
from jiuwenswarm.server.handlers import session as session_handlers
from jiuwenswarm.server.handlers import team as team_handlers
from jiuwenswarm.server.runtime.agent_adapter.deep.stream_parse import _parse_stream_chunk


def _all_patch_targets():
    mods = [agent_ws_server_module]
    for info in _pkgutil.iter_modules(_handlers_pkg.__path__):
        mods.append(_importlib.import_module(f"{_handlers_pkg.__name__}.{info.name}"))
    return tuple(mods)


_PATCH_TARGET_MODULES = _all_patch_targets()


def patch_shared_name(monkeypatch, name, value):
    hit = False
    for mod in _PATCH_TARGET_MODULES:
        if hasattr(mod, name):
            monkeypatch.setattr(mod, name, value)
            hit = True
    assert hit, f"没有任何目标模块绑定了 {name!r},patch 会静默失效"


def patch_find_team_session_ids(monkeypatch, override):
    patch_shared_name(monkeypatch, "_find_team_session_ids", override)


class FakeWebSocket:
    def __init__(self):
        self.sent = []

    async def send(self, payload):
        self.sent.append(json.loads(payload))


class FakeAgentManager:
    def __init__(self, *, capabilities=None, session_id="sess-created", client_capabilities=None):
        self.capabilities = capabilities
        self.session_id = session_id
        self.client_capabilities = client_capabilities or {}
        self.initialize_calls = []
        self.claim_session_calls = []
        self.activated_sessions = []
        self.released_sessions = []

    async def initialize(self, channel_id="", extra_config=None):
        self.initialize_calls.append(
            {"channel_id": channel_id, "extra_config": extra_config}
        )
        return self.capabilities

    async def claim_prewarmed_session(self, **kwargs):
        self.claim_session_calls.append(kwargs)
        eligible = bool(kwargs.get("prewarm_eligible")) and not bool(
            kwargs.get("is_swarm")
        )
        return types.SimpleNamespace(
            session_id=self.session_id,
            prewarm_hit=eligible,
            prewarm_status="ready" if eligible else "bypassed",
        )

    def activate_session_prewarm(self, session_id):
        self.activated_sessions.append(session_id)

    async def release_session_prewarm_claim(self, session_id):
        self.released_sessions.append(session_id)

    def get_client_capabilities(self, channel_id=""):
        return dict(self.client_capabilities)

    def get_agent_nowait(self, channel_id=""):
        return None


class FakeTeamManager:
    def __init__(self):
        self.prepare_session_switch_calls = []
        self.cleared_active_sessions = []
        self.cleared_pending_sessions = []
        self.popped_stream_tasks = []
        self.active_session_id = None
        self.active_team_name = None
        self.pending_session_id = None
        self.pending_team_name = None

    async def prepare_session_switch(
        self,
        session_id: str,
        reason: str = "",
        previous_session_id: str | None = None,
    ) -> None:
        self.prepare_session_switch_calls.append(
            {"session_id": session_id, "reason": reason}
        )

    def pop_stream_task(self, session_id: str):
        self.popped_stream_tasks.append(session_id)
        return None

    def clear_active_runtime(self, session_id: str) -> None:
        self.cleared_active_sessions.append(session_id)

    def clear_pending_runtime(self, session_id: str) -> None:
        self.cleared_pending_sessions.append(session_id)


class FakeContextProcessorRail:
    def __init__(self, *, processors=None, preset=None, session_memory=None):
        self.processors = processors
        self.preset = preset
        self.session_memory = session_memory


class FakeContextAssembleRail:
    def __init__(self):
        pass


class AgentWebSocketServerHarness(agent_ws_server_module.AgentWebSocketServer):
    def __init__(self):
        super().__init__()

    def set_agent_manager_for_test(self, agent_manager):
        self._agent_manager = agent_manager

    def _ctx_for_test(self, ws, request, send_lock):
        from jiuwenswarm.server.context import AgentServerServices, RequestContext
        from jiuwenswarm.server.transports.sink import WSSink

        return RequestContext(
            request=request,
            sink=WSSink(ws, send_lock),
            connection_id=str(id(ws)),
            services=AgentServerServices(self),
        )

    async def handle_initialize_for_test(self, ws, request, send_lock):
        from jiuwenswarm.server.handlers.bootstrap import handle_initialize

        await handle_initialize(self._ctx_for_test(ws, request, send_lock))

    async def handle_session_create_for_test(self, ws, request, send_lock):
        from jiuwenswarm.server.handlers.bootstrap import handle_session_create

        await handle_session_create(self._ctx_for_test(ws, request, send_lock))

    async def handle_session_switch_for_test(self, ws, request, send_lock):
        await session_handlers.handle_session_switch(self._ctx_for_test(ws, request, send_lock))

    async def handle_team_delete_for_test(self, ws, request, send_lock):
        await team_handlers.handle_team_delete(self._ctx_for_test(ws, request, send_lock))

    async def handle_team_bindings_list_for_test(self, ws, request, send_lock):
        await team_handlers.handle_team_bindings_list(self._ctx_for_test(ws, request, send_lock))

    async def handle_team_templates_list_for_test(self, ws, request, send_lock):
        await team_handlers.handle_team_templates_list(
            self._ctx_for_test(ws, request, send_lock)
        )

    async def handle_team_binding_create_for_test(self, ws, request, send_lock):
        await team_handlers.handle_team_binding_create(self._ctx_for_test(ws, request, send_lock))

    async def handle_team_binding_generate_for_test(self, ws, request, send_lock):
        await team_handlers.handle_team_binding_generate(self._ctx_for_test(ws, request, send_lock))

    async def handle_team_session_bind_for_test(self, ws, request, send_lock):
        await team_handlers.handle_team_session_bind(self._ctx_for_test(ws, request, send_lock))

    async def ensure_auto_team_binding_for_chat_for_test(self, request):
        from jiuwenswarm.server.handlers import chat as chat_handlers

        class _NullWs:
            async def send(self, text):  # noqa: ANN001
                return None

        return await chat_handlers._ensure_auto_team_binding_for_chat(
            self._ctx_for_test(_NullWs(), request, asyncio.Lock()), request
        )

    async def handle_session_delete_for_test(self, ws, request, send_lock):
        await session_handlers.handle_session_delete(self._ctx_for_test(ws, request, send_lock))

    async def handle_message_for_test(self, ws, raw, send_lock):
        await self._handle_message(ws, raw, send_lock)

    async def find_team_session_ids_for_test(self, team_name, *, sessions_root=None):
        return await team_module._find_team_session_ids(
            team_name,
            sessions_root=sessions_root,
        )


class DeepAdapterHarness(interface_deep_module.JiuWenSwarmDeepAdapter):
    def build_context_assemble_rail_for_test(self):
        return _build_context_assemble_rail()

    def build_context_processor_rail_for_test(self, config):
        return _build_context_processor_rail(config)


class TeamHelpersHarness:
    @staticmethod
    def sync_team_identity_metadata_for_test(**kwargs) -> None:
        team_helpers_module.sync_team_identity_metadata(**kwargs)


def fake_encode_agent_response_for_wire(resp, response_id):
    return {
        "response_id": response_id,
        "payload": resp.payload,
        "ok": resp.ok,
    }


def patch_session_roots(monkeypatch, sessions_root):
    patch_shared_name(monkeypatch, "get_agent_sessions_dir", lambda: sessions_root)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.session.session_metadata.get_agent_sessions_dir",
        lambda: sessions_root,
    )
    # 进程合一:session.create / team.bind 等经 _sessions_dir_for_request 写租户 sessions。
    patch_shared_name(
        monkeypatch,
        "_sessions_dir_for_request",
        lambda request, *args, **kwargs: sessions_root,
    )
    patch_shared_name(
        monkeypatch, "resolve_tenant_sessions_dir", lambda *args, **kwargs: sessions_root
    )
    monkeypatch.setattr(
        "jiuwenswarm.common.utils.resolve_tenant_sessions_dir",
        lambda *args, **kwargs: sessions_root,
    )


@pytest.fixture(autouse=True)
def _reset_acp_output_manager():
    mgr = get_acp_output_manager()
    mgr.reset_state()
    mgr.set_send_push_callback(None)
    yield
    mgr.reset_state()
    mgr.set_send_push_callback(None)


def test_interface_deep_parse_stream_chunk_preserves_tool_update():
    parsed = parse_stream_chunk(
        types.SimpleNamespace(
            type="tool_update",
            payload={
                "tool_update": {
                    "tool_call_id": "call-1",
                    "tool_name": "read_file",
                    "status": "in_progress",
                }
            },
        )
    )

    assert parsed == {
        "event_type": "chat.tool_update",
        "tool_call_id": "call-1",
        "tool_name": "read_file",
        "status": "in_progress",
    }


def test_interface_deep_parse_stream_chunk_preserves_tool_result_status():
    raw_output = {
        "success": False,
        "direct_display": True,
        "display_format": "markdown",
        "mermaid": "flowchart LR\n  A --> B",
        "graph_status": {"success": True, "exists": False},
        "graph_build": {"success": False, "detail": "failed"},
    }
    parsed = parse_stream_chunk(
        types.SimpleNamespace(
            type="tool_result",
            payload={
                "tool_result": {
                    "tool_call_id": "call-1",
                    "tool_name": "symphony_compose_graph",
                    "result": "failed",
                    "status": "error",
                    "success": False,
                    "is_error": True,
                    "raw_output": raw_output,
                    "direct_display": True,
                    "display_format": "markdown",
                    "mermaid": raw_output["mermaid"],
                    "graph_status": raw_output["graph_status"],
                    "graph_build": raw_output["graph_build"],
                }
            },
        )
    )

    assert parsed == {
        "event_type": "chat.tool_result",
        "result": "failed",
        "tool_name": "symphony_compose_graph",
        "tool_call_id": "call-1",
        "status": "error",
        "success": False,
        "is_error": True,
        "raw_output": raw_output,
        "direct_display": True,
        "display_format": "markdown",
        "mermaid": raw_output["mermaid"],
        "graph_status": raw_output["graph_status"],
        "graph_build": raw_output["graph_build"],
    }


@pytest.mark.parametrize(
    "parser",
    [
        parse_stream_chunk,
        _parse_stream_chunk,
    ],
    ids=["shared_stream_parser", "deep_adapter_parser"],
)
def test_tool_result_without_result_uses_valid_json_fallback(parser):
    raw_output = {
        "kind": "error",
        "status": "error",
        "error_code": "workflow_error",
        "returncode": 1,
    }
    parsed = parser(
        types.SimpleNamespace(
            type="tool_result",
            payload={
                "tool_result": {
                    "tool_call_id": "deepresearch-1",
                    "tool_name": "deepresearch_execute",
                    "status": "error",
                    "success": False,
                    "is_error": True,
                    "error": "section generation failed",
                    "raw_output": raw_output,
                }
            },
        )
    )

    decoded_result = json.loads(parsed["result"])
    assert decoded_result["status"] == "error"
    assert decoded_result["success"] is False
    assert decoded_result["is_error"] is True
    assert decoded_result["raw_output"]["kind"] == "error"
    assert parsed["status"] == "error"
    assert parsed["is_error"] is True
    assert parsed["error"] == "section generation failed"
    assert parsed["raw_output"] == raw_output


def test_parse_stream_chunk_uses_raw_output_skill_tree_for_frontend():
    raw_output = {
        "success": True,
        "result": "# Skill Branch Explore",
        "skill_tree": {
            "query": "skill_branch_explore: SoftwareEngineering",
            "steps": [{"order": 0, "node_id": "SoftwareEngineering"}],
            "candidates": [],
        },
    }
    parsed = parse_stream_chunk(
        types.SimpleNamespace(
            type="tool_result",
            payload={
                "tool_result": {
                    "tool_call_id": "call-1",
                    "tool_name": "skill_branch_explore",
                    "result": "# Skill Branch Explore",
                    "raw_output": raw_output,
                }
            },
        )
    )

    assert parsed["event_type"] == "chat.tool_result"
    assert parsed["tool_name"] == "skill_branch_explore"
    assert parsed["tool_call_id"] == "call-1"
    assert parsed["raw_output"] == raw_output


def test_interface_deep_parse_stream_chunk_uses_raw_output_skill_tree_for_frontend():
    parse_chunk = _parse_stream_chunk
    raw_output = {
        "success": True,
        "result": "# Skill Branch Explore",
        "skill_tree": {
            "query": "skill_branch_explore: SoftwareEngineering",
            "steps": [{"order": 0, "node_id": "SoftwareEngineering"}],
            "candidates": [],
        },
    }
    parsed = parse_chunk(
        types.SimpleNamespace(
            type="tool_result",
            payload={
                "tool_result": {
                    "tool_call_id": "call-1",
                    "tool_name": "skill_branch_explore",
                    "result": "# Skill Branch Explore",
                    "raw_output": raw_output,
                }
            },
        )
    )

    assert parsed["event_type"] == "chat.tool_result"
    assert parsed["tool_name"] == "skill_branch_explore"
    assert parsed["tool_call_id"] == "call-1"
    assert parsed["raw_output"] == raw_output


def test_parse_stream_chunk_does_not_lift_top_level_skill_tree_to_raw_output():
    parsed = parse_stream_chunk(
        types.SimpleNamespace(
            type="tool_result",
            payload={
                "tool_result": {
                    "tool_call_id": "call-1",
                    "tool_name": "skill_branch_explore",
                    "result": "# Skill Branch Explore",
                    "skill_tree": {"steps": [{"node_id": "SoftwareEngineering"}]},
                }
            },
        )
    )

    assert parsed["event_type"] == "chat.tool_result"
    assert "raw_output" not in parsed


def test_interface_deep_parse_stream_chunk_does_not_lift_top_level_skill_tree_to_raw_output():
    parse_chunk = _parse_stream_chunk
    parsed = parse_chunk(
        types.SimpleNamespace(
            type="tool_result",
            payload={
                "tool_result": {
                    "tool_call_id": "call-1",
                    "tool_name": "skill_branch_explore",
                    "result": "# Skill Branch Explore",
                    "skill_tree": {"steps": [{"node_id": "SoftwareEngineering"}]},
                }
            },
        )
    )

    assert parsed["event_type"] == "chat.tool_result"
    assert "raw_output" not in parsed


def test_parse_stream_chunk_preserves_symphony_status_payload():
    parsed = parse_stream_chunk(
        types.SimpleNamespace(
            type="chat.symphony_status",
            payload={
                "source": "symphony_compose_graph",
                "operation_id": "call-1",
                "phase": "checking_score",
                "content": "Symphony status",
                "status": "in_progress",
            },
        )
    )

    assert parsed == {
        "event_type": "chat.symphony_status",
        "source": "symphony_compose_graph",
        "operation_id": "call-1",
        "phase": "checking_score",
        "content": "Symphony status",
        "status": "in_progress",
    }


def test_interface_deep_parse_stream_chunk_preserves_symphony_status_payload():
    parse_chunk = _parse_stream_chunk
    parsed = parse_chunk(
        types.SimpleNamespace(
            type="chat.symphony_status",
            payload={
                "source": "symphony_compose_graph",
                "operation_id": "call-1",
                "phase": "planning",
                "content": "Symphony planning status",
                "status": "in_progress",
            },
        )
    )

    assert parsed == {
        "event_type": "chat.symphony_status",
        "source": "symphony_compose_graph",
        "operation_id": "call-1",
        "phase": "planning",
        "content": "Symphony planning status",
        "status": "in_progress",
    }


def test_interface_deep_parse_stream_chunk_preserves_message_metadata():
    """Test that metadata field is preserved in message type for security alerts."""
    parsed = parse_stream_chunk(
        types.SimpleNamespace(
            type="message",
            payload={
                "role": "system",
                "content": "[WARNING] API key/secret detected in read_file result.",
                "metadata": {
                    "is_security_alert": True,
                    "level": "warning",
                    "alert_type": "api_key_leakage",
                    "display_mode": "popup",
                    "rail": "ApikeyguardalertRail",
                },
            },
        )
    )

    assert parsed["event_type"] == "chat.message"
    assert parsed["content"] == "[WARNING] API key/secret detected in read_file result."
    assert parsed["role"] == "system"
    assert "metadata" in parsed
    assert parsed["metadata"]["is_security_alert"] is True
    assert parsed["metadata"]["level"] == "warning"
    assert parsed["metadata"]["alert_type"] == "api_key_leakage"
    assert parsed["metadata"]["display_mode"] == "popup"
    assert parsed["metadata"]["rail"] == "ApikeyguardalertRail"


def test_parse_stream_chunk_preserves_evolution_meta_for_ask_user_question():
    parsed = parse_stream_chunk(
        types.SimpleNamespace(
            type="chat.ask_user_question",
            payload={
                "request_id": "evolve_simplify_team123",
                "evolution_meta": {
                    "event_kind": "approval",
                    "rail_kind": "team",
                    "request_id": "evolve_simplify_team123",
                },
                "questions": [{"header": "Skill 精简审批", "question": "是否执行?"}],
            },
        )
    )

    assert parsed["event_type"] == "chat.ask_user_question"
    assert parsed["evolution_meta"]["rail_kind"] == "team"
    assert "_evolution_meta" not in parsed


def test_parse_stream_chunk_serializes_team_runtime_enum_kind():
    parsed = parse_stream_chunk(
        {
            "type": "team.runtime_ready",
            "activation_kind": RunActionKind.NEW_TEAM_IN_SESSION,
            "team_name": "demo-team",
        }
    )

    assert parsed == {
        "event_type": "team.runtime_ready",
        "activation_kind": RunActionKind.NEW_TEAM_IN_SESSION.value,
        "team_name": "demo-team",
    }


def test_parse_stream_chunk_converts_interaction_to_ask_user_question():
    parsed = parse_stream_chunk(
        types.SimpleNamespace(
            type="__interaction__",
            payload={
                "id": "tool-call-1",
                "value": {
                    "questions": [
                        {
                            "question": "Choose UI",
                            "header": "UI",
                            "options": [
                                {"label": "CLI", "description": "Text UI"},
                                {"label": "Web", "description": "Browser UI"},
                            ],
                        }
                    ]
                },
            },
        )
    )

    assert parsed is not None
    assert parsed["event_type"] == "chat.ask_user_question"
    assert parsed["request_id"] == "tool-call-1"
    assert parsed["source"] == "ask_user_interrupt"
    assert parsed["questions"][0]["question"] == "Choose UI"


def test_parse_stream_chunk_unwraps_controller_output_interaction():
    parsed = parse_stream_chunk(
        types.SimpleNamespace(
            type="controller_output",
            payload={
                "type": "task_completion",
                "data": [
                    {
                        "type": "json",
                        "data": {
                            "result_type": "interrupt",
                            "interaction": {
                                "type": "__interaction__",
                                "payload": {
                                    "id": "ask-user-1",
                                    "value": {
                                        "questions": [
                                            {
                                                "question": "Need details?",
                                                "header": "Details",
                                                "options": [],
                                            }
                                        ]
                                    },
                                },
                            },
                        },
                    }
                ],
            },
        )
    )

    assert parsed is not None
    assert parsed["event_type"] == "chat.ask_user_question"
    assert parsed["request_id"] == "ask-user-1"
    assert parsed["source"] == "ask_user_interrupt"
    assert parsed["questions"][0]["question"] == "Need details?"


def test_parse_stream_chunk_prefers_ask_user_when_controller_has_mixed_interactions():
    parsed = parse_stream_chunk(
        types.SimpleNamespace(
            type="controller_output",
            payload={
                "data": [
                    {
                        "type": "__interaction__",
                        "payload": {
                            "id": "",
                            "value": {
                                "message": "工具 `` 需要授权才能执行",
                                "tool_name": "",
                            },
                        },
                    },
                    {
                        "type": "__interaction__",
                        "payload": {
                            "id": "ask-user-2",
                            "value": {
                                "questions": [
                                    {
                                        "question": "Choose algorithm details",
                                        "header": "Details",
                                        "options": [],
                                    }
                                ]
                            },
                        },
                    },
                ],
            },
        )
    )

    assert parsed is not None
    assert parsed["event_type"] == "chat.ask_user_question"
    assert parsed["request_id"] == "ask-user-2"
    assert parsed["source"] == "ask_user_interrupt"
    assert parsed["questions"][0]["question"] == "Choose algorithm details"


def test_sync_team_identity_metadata_updates_only_for_create_kinds(monkeypatch):
    updates = []

    monkeypatch.setattr(
        team_helpers_module,
        "get_session_metadata",
        lambda _session_id: {"mode": "team"},
    )
    monkeypatch.setattr(
        team_helpers_module,
        "update_session_metadata",
        lambda **kwargs: updates.append(kwargs),
    )

    TeamHelpersHarness.sync_team_identity_metadata_for_test(
        channel_id="web",
        session_id="team_sess_001",
        mode="team",
        ready_team_name="demo-team",
        activation_kind=RunActionKind.CREATE.value,
    )

    assert updates == [
        {
            "session_id": "team_sess_001",
            "channel_id": "web",
            "mode": "team",
            "team_name": "demo-team",
        }
    ]


def test_sync_team_identity_metadata_skips_recover_kinds(monkeypatch):
    updates = []

    monkeypatch.setattr(
        team_helpers_module,
        "get_session_metadata",
        lambda _session_id: {"mode": "team", "team_name": "existing-team"},
    )
    monkeypatch.setattr(
        team_helpers_module,
        "update_session_metadata",
        lambda **kwargs: updates.append(kwargs),
    )

    TeamHelpersHarness.sync_team_identity_metadata_for_test(
        channel_id="web",
        session_id="team_sess_001",
        mode="team",
        ready_team_name="new-team",
        activation_kind=RunActionKind.NEW_TEAM_IN_SESSION.value,
    )

    assert updates == []


def test_sync_team_identity_metadata_keeps_existing_name_on_mismatch(monkeypatch):
    updates = []

    monkeypatch.setattr(
        team_helpers_module,
        "get_session_metadata",
        lambda _session_id: {"mode": "team", "team_name": "existing-team"},
    )
    monkeypatch.setattr(
        team_helpers_module,
        "update_session_metadata",
        lambda **kwargs: updates.append(kwargs),
    )

    TeamHelpersHarness.sync_team_identity_metadata_for_test(
        channel_id="web",
        session_id="team_sess_001",
        mode="team",
        ready_team_name="new-team",
        activation_kind=RunActionKind.CREATE.value,
    )

    assert updates == []


@pytest.mark.asyncio
async def test_handle_initialize_uses_agent_manager_capabilities(monkeypatch):
    server = AgentWebSocketServerHarness()
    fake_manager = FakeAgentManager(capabilities={"protocolVersion": "9.9.9"})
    server.set_agent_manager_for_test(fake_manager)
    fake_ws = FakeWebSocket()

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)

    request = AgentRequest(
        request_id="req-init",
        channel_id="acp",
        req_method=ReqMethod.INITIALIZE,
        params={
            "protocolVersion": "0.1.0",
            "clientCapabilities": {"fs": {"readTextFile": True}},
        },
    )

    await server.handle_initialize_for_test(fake_ws, request, asyncio.Lock())

    assert fake_manager.initialize_calls == [
        {
            "channel_id": "acp",
            "extra_config": {
                "protocol_version": "0.1.0",
                "client_capabilities": {"fs": {"readTextFile": True}},
            },
        }
    ]
    assert fake_ws.sent == [
        {
            "response_id": "req-init",
            "payload": {"protocolVersion": "9.9.9"},
            "ok": True,
        }
    ]
@pytest.mark.asyncio
async def test_handle_initialize_falls_back_to_default_capabilities(monkeypatch):
    server = AgentWebSocketServerHarness()
    fake_manager = FakeAgentManager(capabilities=None)
    server.set_agent_manager_for_test(fake_manager)
    fake_ws = FakeWebSocket()

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)

    request = AgentRequest(
        request_id="req-init-default",
        channel_id="acp",
        req_method=ReqMethod.INITIALIZE,
        params={},
    )

    await server.handle_initialize_for_test(fake_ws, request, asyncio.Lock())

    assert fake_ws.sent == [
        {
            "response_id": "req-init-default",
            "payload": ACP_DEFAULT_CAPABILITIES,
            "ok": True,
        }
    ]


@pytest.mark.asyncio
async def test_handle_session_create_returns_session_id(monkeypatch, tmp_path):
    server = AgentWebSocketServerHarness()
    fake_manager = FakeAgentManager(session_id="acp_session_001")
    server.set_agent_manager_for_test(fake_manager)
    fake_ws = FakeWebSocket()
    sessions_root = tmp_path / "sessions"

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    patch_session_roots(monkeypatch, sessions_root)

    request = AgentRequest(
        request_id="req-session-create",
        channel_id="acp",
        req_method=ReqMethod.SESSION_CREATE,
        params={"create_token": "create-acp-001"},
    )

    await server.handle_session_create_for_test(fake_ws, request, asyncio.Lock())

    assert len(fake_manager.claim_session_calls) == 1
    assert fake_manager.claim_session_calls[0]["channel_id"] == "acp"
    assert fake_manager.claim_session_calls[0]["create_token"] == "create-acp-001"
    metadata = json.loads((sessions_root / "acp_session_001" / "metadata.json").read_text(encoding="utf-8"))
    assert metadata["mode"] == "agent"
    assert fake_ws.sent == [
        {
            "response_id": "req-session-create",
            "payload": {
                "sessionId": "acp_session_001",
                "session_id": "acp_session_001",
                "projectId": "default",
                "projectDir": "",
                "workMode": "work",
                "prewarm_hit": True,
                "prewarm_status": "ready",
            },
            "ok": True,
        }
    ]


@pytest.mark.asyncio
@pytest.mark.parametrize(
    "wire_mode,global_enabled,expected",
    [("flash", False, "flash"), ("agent.plan", True, "agent")],
)
async def test_officeclaw_session_create_persists_explicit_adapter(
    monkeypatch, tmp_path, wire_mode, global_enabled, expected,
):
    from unittest.mock import AsyncMock
    from jiuwenswarm.server.handlers import _shared

    monkeypatch.setattr(_shared, "get_config", lambda: {"flash": {"enabled": global_enabled}})
    server = AgentWebSocketServerHarness()
    manager = FakeAgentManager(session_id="officeclaw_explicit_create")
    server.set_agent_manager_for_test(manager)
    prewarm = AsyncMock()
    monkeypatch.setattr(server, "_tenant_pool", lambda: types.SimpleNamespace(
        prewarm_session_in_background=prewarm,
    ))
    fake_ws = FakeWebSocket()
    sessions_root = tmp_path / "sessions"
    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    patch_session_roots(monkeypatch, sessions_root)
    incoming = AgentRequest(
        request_id="officeclaw-explicit-create",
        channel_id="officeclaw",
        req_method=ReqMethod.SESSION_CREATE,
        params={"create_token": "explicit-create", "mode": wire_mode},
    )

    await server.handle_session_create_for_test(fake_ws, incoming, asyncio.Lock())
    await asyncio.sleep(0)

    assert fake_ws.sent[0]["ok"] is True
    assert manager.claim_session_calls[0]["adapter_mode"] == expected
    assert manager.claim_session_calls[0]["prewarm_eligible"] is True
    metadata = json.loads(
        (sessions_root / manager.session_id / "metadata.json").read_text(encoding="utf-8"),
    )
    assert metadata["mode"] == metadata["adapter_mode"] == expected
    assert metadata.get("todo_initialized") is (False if expected == "flash" else None)
    assert prewarm.await_args.kwargs["mode"] == expected
    assert prewarm.await_args.kwargs["adapter_mode"] == expected


@pytest.mark.asyncio
async def test_direct_channel_flash_session_create_records_todo_origin(monkeypatch, tmp_path):
    from unittest.mock import AsyncMock

    from jiuwenswarm.server.handlers import _shared
    from jiuwenswarm.server.runtime.session.session_metadata import (
        check_todo_initialization,
    )

    monkeypatch.setattr(_shared, "get_config", lambda: {"flash": {"enabled": False}})
    server = AgentWebSocketServerHarness()
    manager = FakeAgentManager(session_id="direct_flash_create")
    server.set_agent_manager_for_test(manager)
    monkeypatch.setattr(server, "_tenant_pool", lambda: types.SimpleNamespace(
        prewarm_session_in_background=AsyncMock(),
    ))
    fake_ws = FakeWebSocket()
    sessions_root = tmp_path / "sessions"
    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    patch_session_roots(monkeypatch, sessions_root)
    request = AgentRequest(
        request_id="direct-flash-create", channel_id="chat-service", req_method=ReqMethod.SESSION_CREATE,
        params={"create_token": "direct-flash", "mode": "flash"},
    )
    await server.handle_session_create_for_test(fake_ws, request, asyncio.Lock())
    assert fake_ws.sent[0]["ok"] is True
    path = sessions_root / manager.session_id / "metadata.json"
    assert json.loads(path.read_text())["todo_initialized"] is False
    check_todo_initialization(manager.session_id, file_exists=False, committing=True, sessions_root=sessions_root)
    assert json.loads(path.read_text())["todo_initialized"] is True


@pytest.mark.asyncio
async def test_handle_session_create_rejects_explicit_session_id(monkeypatch, tmp_path):
    server = AgentWebSocketServerHarness()
    fake_manager = FakeAgentManager(session_id="unused-default")
    server.set_agent_manager_for_test(fake_manager)
    fake_ws = FakeWebSocket()
    sessions_root = tmp_path / "sessions"

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    patch_session_roots(monkeypatch, sessions_root)

    request = AgentRequest(
        request_id="req-session-create-explicit",
        channel_id="acp",
        req_method=ReqMethod.SESSION_CREATE,
        params={
            "session_id": "sess_explicit_001",
            "create_token": "create-explicit-001",
        },
    )

    await server.handle_session_create_for_test(fake_ws, request, asyncio.Lock())

    assert fake_manager.claim_session_calls == []
    assert fake_ws.sent == [
        {
            "response_id": "req-session-create-explicit",
            "payload": {
                "error": (
                    "session.create no longer accepts session_id; "
                    "use session.switch to restore"
                ),
            },
            "ok": False,
        }
    ]


@pytest.mark.asyncio
async def test_handle_session_create_injected_default_work_mode_does_not_mismatch_code_project(
    monkeypatch, tmp_path
):
    server = AgentWebSocketServerHarness()
    fake_manager = FakeAgentManager(session_id="sess_code_project")
    server.set_agent_manager_for_test(fake_manager)
    fake_ws = FakeWebSocket()

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    patch_session_roots(monkeypatch, tmp_path / "sessions")

    from jiuwenswarm.server.runtime.session import project_store

    code_project = types.SimpleNamespace(
        project_id="proj_code",
        project_dir=str(tmp_path / "code_proj"),
        work_mode="code",
        hidden=False,
    )
    monkeypatch.setattr(
        project_store,
        "resolve_session_project_binding",
        lambda project_id, project_dir: (
            "proj_code",
            code_project.project_dir,
            None,
            None,
        ),
    )
    monkeypatch.setattr(
        project_store,
        "get_project_by_id",
        lambda project_id, cache_bust=False: code_project if project_id == "proj_code" else None,
    )

    request = AgentRequest(
        request_id="req-session-create-code-project",
        channel_id="web",
        req_method=ReqMethod.SESSION_CREATE,
        params={
            "project_id": "proj_code",
            "work_mode": "work",
            "_work_mode_explicit": False,
            "create_token": "create-code-project",
        },
    )

    await server.handle_session_create_for_test(fake_ws, request, asyncio.Lock())

    assert fake_ws.sent == [
        {
            "response_id": "req-session-create-code-project",
            "payload": {
                "sessionId": "sess_code_project",
                "session_id": "sess_code_project",
                "projectId": "proj_code",
                "projectDir": code_project.project_dir,
                "workMode": "code",
                "prewarm_hit": True,
                "prewarm_status": "ready",
            },
            "ok": True,
        }
    ]
    assert request.params["mode"] == "code.normal"
    from jiuwenswarm.server.runtime.session.session_metadata import get_session_metadata

    metadata = get_session_metadata("sess_code_project", cache_bust=True)
    assert metadata["mode"] == "code.normal"
    assert metadata["work_mode"] == "code"


@pytest.mark.asyncio
async def test_handle_session_create_acks_before_async_kvc(monkeypatch, tmp_path):
    """session.create 在 team prepare 后回包;可选 KVC 异步,避免拖慢前端超时窗口。"""
    server = AgentWebSocketServerHarness()
    fake_manager = FakeAgentManager(session_id="sess_async_kvc_001")
    server.set_agent_manager_for_test(fake_manager)
    fake_ws = FakeWebSocket()
    prepare_calls = []
    kvc_started = asyncio.Event()
    kvc_release = asyncio.Event()
    kvc_calls = []

    async def _prepare(**kwargs):
        prepare_calls.append(kwargs)
        return False, "agent", object(), None, object()

    async def _slow_kvc(**kwargs):
        kvc_calls.append(kwargs)
        kvc_started.set()
        await kvc_release.wait()

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    patch_session_roots(monkeypatch, tmp_path)
    monkeypatch.setattr(server, "_prepare_session_switch_owner", _prepare)
    monkeypatch.setattr(server, "_dispatch_session_switch_kvc", _slow_kvc)

    request = AgentRequest(
        request_id="req-session-create-async-kvc",
        channel_id="web",
        req_method=ReqMethod.SESSION_CREATE,
        params={"mode": "agent", "create_token": "create-async-kvc"},
    )

    create_task = asyncio.create_task(
        server.handle_session_create_for_test(fake_ws, request, asyncio.Lock())
    )
    await asyncio.wait_for(kvc_started.wait(), timeout=1.0)
    # prepare 已完成且成功响应已发出时,KVC 仍可在后台继续
    assert len(prepare_calls) == 1
    assert prepare_calls[0]["target_session_id"] == "sess_async_kvc_001"
    assert fake_ws.sent == [
        {
            "response_id": "req-session-create-async-kvc",
            "payload": {
                "sessionId": "sess_async_kvc_001",
                "session_id": "sess_async_kvc_001",
                "projectId": "default",
                "projectDir": "",
                "workMode": "work",
                "prewarm_hit": True,
                "prewarm_status": "ready",
            },
            "ok": True,
        }
    ]
    assert create_task.done()
    kvc_release.set()
    await create_task
    assert len(kvc_calls) == 1
    assert kvc_calls[0]["target_session_id"] == "sess_async_kvc_001"
    assert kvc_calls[0]["reason"] == "session.create switch: "


@pytest.mark.asyncio
async def test_handle_session_create_prepares_team_before_ack(monkeypatch, tmp_path):
    """team prepare 必须在 create 成功回包前完成,避免与首条 chat.send 竞态。"""
    server = AgentWebSocketServerHarness()
    fake_manager = FakeAgentManager(session_id="team_sess_001")
    fake_team_manager = FakeTeamManager()
    server.set_agent_manager_for_test(fake_manager)
    fake_ws = FakeWebSocket()
    sessions_root = tmp_path / "sessions"
    prepare_released = asyncio.Event()
    saw_prepare_before_ack = asyncio.Event()

    async def _slow_prepare(session_id, reason="", previous_session_id=None):
        fake_team_manager.prepare_session_switch_calls.append(
            {"session_id": session_id, "reason": reason}
        )
        saw_prepare_before_ack.set()
        await prepare_released.wait()

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    patch_session_roots(monkeypatch, sessions_root)
    monkeypatch.setattr(
        "jiuwenswarm.agents.harness.team.get_team_manager",
        lambda channel_id: fake_team_manager,
    )
    monkeypatch.setattr(fake_team_manager, "prepare_session_switch", _slow_prepare)

    request = AgentRequest(
        request_id="req-session-create-team",
        channel_id="web",
        req_method=ReqMethod.SESSION_CREATE,
        params={"mode": "team", "create_token": "create-team-001"},
    )

    create_task = asyncio.create_task(
        server.handle_session_create_for_test(fake_ws, request, asyncio.Lock())
    )
    await asyncio.wait_for(saw_prepare_before_ack.wait(), timeout=1.0)
    assert fake_ws.sent == []
    prepare_released.set()
    await create_task

    assert fake_ws.sent == [
        {
            "response_id": "req-session-create-team",
            "payload": {
                "sessionId": "team_sess_001",
                "session_id": "team_sess_001",
                "projectId": "default",
                "projectDir": "",
                "workMode": "work",
                "prewarm_hit": False,
                "prewarm_status": "bypassed",
            },
            "ok": True,
        }
    ]
    assert len(fake_manager.claim_session_calls) == 1
    assert fake_manager.claim_session_calls[0]["channel_id"] == "web"
    assert fake_manager.claim_session_calls[0]["prewarm_eligible"] is False
    assert fake_team_manager.prepare_session_switch_calls == [
        {"session_id": "team_sess_001", "reason": "session.create switch: "}
    ]


@pytest.mark.asyncio
async def test_handle_team_binding_create_persists_team_entity(monkeypatch, tmp_path):
    from jiuwenswarm.server.runtime.team_binding_store import TeamBindingStore
    from jiuwenswarm.server.runtime.team_entity_store import TeamEntityStore

    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    binding_store = TeamBindingStore(tmp_path / "teams" / "bindings.json")
    entity_store = TeamEntityStore(tmp_path / ".agent_teams")
    config = {
        "modes": {
            "team": {
                "research": {
                    "team_name": "template_team",
                    "leader": {"member_name": "lead_1"},
                }
            }
        }
    }

    patch_shared_name(monkeypatch, "get_config", lambda: config)
    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: binding_store,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_entity_store.get_team_entity_store",
        lambda: entity_store,
    )

    request = AgentRequest(
        request_id="req-team-binding-create",
        channel_id="web",
        req_method=ReqMethod.TEAM_BINDING_CREATE,
        params={"team_name": "research_team", "template_id": "research"},
    )

    await server.handle_team_binding_create_for_test(fake_ws, request, asyncio.Lock())

    binding = binding_store.get("research_team")
    entity = entity_store.get("research_team")
    assert fake_ws.sent[0]["ok"] is True
    assert binding is not None
    assert binding.template_id == "research"
    assert entity is not None
    assert entity.template_id == "research"
    assert entity.template_snapshot["leader"]["member_name"] == "lead_1"


@pytest.mark.asyncio
async def test_handle_team_binding_create_heals_entity_without_binding(monkeypatch, tmp_path):
    from jiuwenswarm.server.runtime.team_binding_store import TeamBindingStore
    from jiuwenswarm.server.runtime.team_entity_store import TeamEntityStore

    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    binding_store = TeamBindingStore(tmp_path / "teams" / "bindings.json")
    entity_store = TeamEntityStore(tmp_path / ".agent_teams")
    entity_store.write(
        team_name="oc_team_legacy",
        template_id="oc_team_legacy",
        template_snapshot={
            "team_name": "oc_team_legacy",
            "leader": {"member_name": "lead"},
        },
        created_at=42.0,
    )

    patch_shared_name(monkeypatch, "get_config", lambda: {"modes": {"team": {}}})
    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: binding_store,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_entity_store.get_team_entity_store",
        lambda: entity_store,
    )

    request = AgentRequest(
        request_id="req-team-binding-heal",
        channel_id="officeclaw",
        req_method=ReqMethod.TEAM_BINDING_CREATE,
        params={"team_name": "oc_team_legacy", "template_id": "oc_team_legacy"},
    )

    await server.handle_team_binding_create_for_test(fake_ws, request, asyncio.Lock())

    binding = binding_store.get("oc_team_legacy")
    assert fake_ws.sent[0]["ok"] is True
    assert binding is not None
    assert binding.template_id == "oc_team_legacy"
    assert binding.created_at == 42.0
    assert binding.legacy is False
    assert binding.session_ids == ()
    # Entity must stay intact; heal only backfills binding.
    entity = entity_store.get("oc_team_legacy")
    assert entity is not None
    assert entity.created_at == 42.0


def test_create_team_binding_without_heal_conflicts_on_entity_only(monkeypatch, tmp_path):
    """Generate/auto-create must not adopt a dead-state entity (heal defaults off)."""
    from jiuwenswarm.server.handlers import team as team_handlers
    from jiuwenswarm.server.runtime.team_binding_store import (
        TeamBindingStore,
        TeamBindingStoreError,
    )
    from jiuwenswarm.server.runtime.team_entity_store import TeamEntityStore

    binding_store = TeamBindingStore(tmp_path / "teams" / "bindings.json")
    entity_store = TeamEntityStore(tmp_path / ".agent_teams")
    entity_store.write(
        team_name="semantic_name",
        template_id="semantic_name",
        template_snapshot={
            "team_name": "semantic_name",
            "leader": {"member_name": "lead"},
        },
        created_at=42.0,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: binding_store,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_entity_store.get_team_entity_store",
        lambda: entity_store,
    )

    with pytest.raises(TeamBindingStoreError) as exc_info:
        team_handlers._create_team_binding_from_template(
            team_name="semantic_name",
            template_id="research",
            config_base={"modes": {"team": {"research": {"team_name": "t"}}}},
            heal=False,
        )

    assert exc_info.value.code == "CONFLICT"
    assert binding_store.get("semantic_name") is None


@pytest.mark.asyncio
async def test_handle_team_binding_create_still_conflicts_when_binding_exists(monkeypatch, tmp_path):
    from jiuwenswarm.server.runtime.team_binding_store import TeamBindingStore
    from jiuwenswarm.server.runtime.team_entity_store import TeamEntityStore

    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    binding_store = TeamBindingStore(tmp_path / "teams" / "bindings.json")
    entity_store = TeamEntityStore(tmp_path / ".agent_teams")
    entity_store.write(
        team_name="research_team",
        template_id="research",
        template_snapshot={"team_name": "research_team", "leader": {"member_name": "lead"}},
        created_at=42.0,
    )
    binding_store.create(team_name="research_team", template_id="research", created_at=42.0)

    patch_shared_name(monkeypatch, "get_config", lambda: {"modes": {"team": {}}})
    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: binding_store,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_entity_store.get_team_entity_store",
        lambda: entity_store,
    )

    request = AgentRequest(
        request_id="req-team-binding-conflict",
        channel_id="web",
        req_method=ReqMethod.TEAM_BINDING_CREATE,
        params={"team_name": "research_team", "template_id": "research"},
    )

    await server.handle_team_binding_create_for_test(fake_ws, request, asyncio.Lock())

    assert fake_ws.sent[0]["ok"] is False
    assert fake_ws.sent[0]["payload"]["code"] == "CONFLICT"


@pytest.mark.asyncio
async def test_handle_team_binding_create_uses_officeclaw_tenant_catalog(monkeypatch, tmp_path):
    from jiuwenswarm.server.runtime.team_binding_store import TeamBindingStore
    from jiuwenswarm.server.runtime.team_entity_store import TeamEntityStore
    from jiuwenswarm.server.runtime.tenant_catalog_registry import (
        TenantAgentSpec,
        TenantCatalogRegistry,
    )

    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    binding_store = TeamBindingStore(tmp_path / "teams" / "bindings.json")
    entity_store = TeamEntityStore(tmp_path / ".agent_teams")
    tenant_config = {
        "models": {
            "defaults": [
                {
                    "model_client_config": {
                        "model_name": "shared-model",
                        "api_base": "https://second.test/v1",
                        "api_key": "second-secret",
                        "client_provider": "OpenAI",
                    }
                }
            ]
        },
        "modes": {
            "team": {
                "relay_team": {
                    "team_name": "relay_team",
                    "leader": {"member_name": "relay_lead"},
                    "agents": {
                        "leader": {
                            "model": {
                                "model_client_config": {
                                    "api_base": "https://second.test/v1",
                                    "api_key": "second-secret",
                                    "client_provider": "OpenAI",
                                },
                                "model_request_config": {"model": "shared-model"},
                            }
                        }
                    },
                }
            }
        }
    }
    registry = TenantCatalogRegistry.get_instance()
    registry.upsert(
        TenantAgentSpec(
            service_id="officeclaw_service_owner",
            agent_id="agentteam",
            config=tenant_config,
        )
    )

    patch_shared_name(monkeypatch, "get_config", lambda: {"modes": {"team": {}}})
    patch_shared_name(
        monkeypatch,
        "encode_agent_response_for_wire",
        fake_encode_agent_response_for_wire,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: binding_store,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_entity_store.get_team_entity_store",
        lambda: entity_store,
    )

    request = AgentRequest(
        request_id="req-officeclaw-team-binding-create",
        channel_id="officeclaw",
        service_id="officeclaw_service_owner",
        agent_id="agentteam",
        req_method=ReqMethod.TEAM_BINDING_CREATE,
        params={"team_name": "relay_team", "template_id": "relay_team"},
    )

    try:
        await server.handle_team_binding_create_for_test(fake_ws, request, asyncio.Lock())
    finally:
        TenantCatalogRegistry.reset_for_tests()

    assert fake_ws.sent[0]["ok"] is True
    entity = entity_store.get("relay_team")
    assert entity.template_snapshot["leader"]["member_name"] == "relay_lead"
    model_ref = entity.template_snapshot["agents"]["leader"]["model"]["ref"]
    assert model_ref.startswith("model-identity-v1:")
    persisted = entity_store.entity_path("relay_team").read_text(encoding="utf-8")
    assert "api_key" not in persisted
    assert "api_base" not in persisted


@pytest.mark.asyncio
async def test_handle_team_binding_create_does_not_fallback_to_disk_config_for_missing_officeclaw_tenant(
    monkeypatch,
    tmp_path,
):
    from jiuwenswarm.server.runtime.team_binding_store import TeamBindingStore
    from jiuwenswarm.server.runtime.team_entity_store import TeamEntityStore
    from jiuwenswarm.server.runtime.tenant_catalog_registry import TenantCatalogRegistry

    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    binding_store = TeamBindingStore(tmp_path / "teams" / "bindings.json")
    entity_store = TeamEntityStore(tmp_path / ".agent_teams")
    disk_config = {
        "modes": {
            "team": {
                "relay_team": {
                    "team_name": "relay_team",
                    "leader": {"member_name": "disk_lead"},
                }
            }
        }
    }

    TenantCatalogRegistry.reset_for_tests()
    patch_shared_name(monkeypatch, "get_config", lambda: disk_config)
    patch_shared_name(
        monkeypatch,
        "encode_agent_response_for_wire",
        fake_encode_agent_response_for_wire,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: binding_store,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_entity_store.get_team_entity_store",
        lambda: entity_store,
    )
    request = AgentRequest(
        request_id="req-officeclaw-team-binding-without-catalog",
        channel_id="officeclaw",
        service_id="officeclaw_service_owner",
        agent_id="agentteam",
        req_method=ReqMethod.TEAM_BINDING_CREATE,
        params={"team_name": "relay_team", "template_id": "relay_team"},
    )

    try:
        await server.handle_team_binding_create_for_test(fake_ws, request, asyncio.Lock())
    finally:
        TenantCatalogRegistry.reset_for_tests()

    assert fake_ws.sent[0]["ok"] is False
    assert fake_ws.sent[0]["payload"]["code"] == "NOT_FOUND"
    assert binding_store.get("relay_team") is None
    assert entity_store.get("relay_team") is None


@pytest.mark.asyncio
async def test_handle_team_templates_list_uses_officeclaw_tenant_catalog(monkeypatch):
    from jiuwenswarm.server.runtime.tenant_catalog_registry import (
        TenantAgentSpec,
        TenantCatalogRegistry,
    )

    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    tenant_config = {
        "modes": {
            "team": {
                "tenant_template": {
                    "team_name": "tenant_template",
                    "leader": {"member_name": "tenant_lead"},
                }
            }
        }
    }
    registry = TenantCatalogRegistry.get_instance()
    registry.upsert(
        TenantAgentSpec(
            service_id="officeclaw_service_owner",
            agent_id="agentteam",
            config=tenant_config,
        )
    )
    patch_shared_name(
        monkeypatch,
        "get_config",
        lambda: {"modes": {"team": {"disk_template": {"team_name": "disk_template"}}}},
    )
    patch_shared_name(
        monkeypatch,
        "encode_agent_response_for_wire",
        fake_encode_agent_response_for_wire,
    )
    request = AgentRequest(
        request_id="req-officeclaw-team-templates-list",
        channel_id="officeclaw",
        service_id="officeclaw_service_owner",
        agent_id="agentteam",
        req_method=ReqMethod.TEAM_TEMPLATES_LIST,
        params={},
    )

    try:
        await server.handle_team_templates_list_for_test(fake_ws, request, asyncio.Lock())
    finally:
        TenantCatalogRegistry.reset_for_tests()

    assert fake_ws.sent[0]["ok"] is True
    assert [item["template_id"] for item in fake_ws.sent[0]["payload"]["templates"]] == [
        "tenant_template"
    ]


@pytest.mark.asyncio
async def test_handle_team_binding_generate_uses_officeclaw_tenant_catalog(monkeypatch, tmp_path):
    from jiuwenswarm.agents.harness import team as team_module
    from jiuwenswarm.server.runtime.team_binding_store import TeamBindingStore
    from jiuwenswarm.server.runtime.team_entity_store import TeamEntityStore
    from jiuwenswarm.server.runtime.tenant_catalog_registry import (
        TenantAgentSpec,
        TenantCatalogRegistry,
    )

    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    binding_store = TeamBindingStore(tmp_path / "teams" / "bindings.json")
    entity_store = TeamEntityStore(tmp_path / ".agent_teams")
    tenant_config = {
        "models": {
            "defaults": [
                {
                    "model_client_config": {
                        "model_name": "${MODEL_NAME}",
                        "client_provider": "${MODEL_PROVIDER}",
                        "api_base": "${API_BASE}",
                        "api_key": "${API_KEY}",
                    }
                }
            ]
        },
        "modes": {
            "team": {
                "tenant_template": {
                    "team_name": "tenant_template",
                    "leader": {"member_name": "tenant_lead"},
                }
            }
        }
    }
    registry = TenantCatalogRegistry.get_instance()
    registry.upsert(
        TenantAgentSpec(
            service_id="officeclaw_service_owner",
            agent_id="agentteam",
            config=tenant_config,
            env={
                "MODEL_NAME": "team-model",
                "MODEL_PROVIDER": "OpenAI",
                "API_BASE": "https://models.example/v1",
                "API_KEY": "secret",
            },
        )
    )

    async def fake_generate_team_name(description, *, config_base, template_id):
        assert description == "build a tenant team"
        assert config_base["models"]["defaults"][0]["model_client_config"] == {
            "model_name": "team-model",
            "client_provider": "OpenAI",
            "api_base": "https://models.example/v1",
            "api_key": "secret",
        }
        assert template_id == "tenant_template"
        return "tenant_generated_team"

    patch_shared_name(
        monkeypatch,
        "get_config",
        lambda: {"modes": {"team": {"disk_template": {"team_name": "disk_template"}}}},
    )
    monkeypatch.setattr(team_module, "generate_team_name", fake_generate_team_name)
    patch_shared_name(
        monkeypatch,
        "encode_agent_response_for_wire",
        fake_encode_agent_response_for_wire,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: binding_store,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_entity_store.get_team_entity_store",
        lambda: entity_store,
    )
    request = AgentRequest(
        request_id="req-officeclaw-team-binding-generate",
        channel_id="officeclaw",
        service_id="officeclaw_service_owner",
        agent_id="agentteam",
        req_method=ReqMethod.TEAM_BINDING_GENERATE,
        params={"description": "build a tenant team"},
    )

    try:
        await server.handle_team_binding_generate_for_test(fake_ws, request, asyncio.Lock())
    finally:
        TenantCatalogRegistry.reset_for_tests()

    assert fake_ws.sent[0]["ok"] is True
    assert fake_ws.sent[0]["payload"]["team"]["template_id"] == "tenant_template"
    assert entity_store.get("tenant_generated_team").template_snapshot["leader"]["member_name"] == "tenant_lead"


@pytest.mark.asyncio
async def test_handle_team_binding_generate_uses_default_template_and_resolves_conflict(monkeypatch, tmp_path):
    from jiuwenswarm.agents.harness import team as team_module
    from jiuwenswarm.server.runtime.team_binding_store import TeamBindingStore
    from jiuwenswarm.server.runtime.team_entity_store import TeamEntityStore

    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    binding_store = TeamBindingStore(tmp_path / "teams" / "bindings.json")
    binding_store.create(team_name="research_team", template_id="research")
    entity_store = TeamEntityStore(tmp_path / ".agent_teams")
    config = {
        "modes": {
            "team": {
                "research": {
                    "team_name": "template_team",
                    "leader": {"member_name": "lead_1"},
                },
                "coding": {
                    "team_name": "coding_template",
                    "leader": {"member_name": "lead_2"},
                },
            }
        }
    }

    async def fake_generate_team_name(description, *, config_base, template_id):
        assert description == "调研多语言模型"
        assert config_base is config
        assert template_id == "research"
        return "research_team"

    patch_shared_name(monkeypatch, "get_config", lambda: config)
    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    monkeypatch.setattr(team_module, "generate_team_name", fake_generate_team_name)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: binding_store,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_entity_store.get_team_entity_store",
        lambda: entity_store,
    )

    request = AgentRequest(
        request_id="req-team-binding-generate",
        channel_id="web",
        req_method=ReqMethod.TEAM_BINDING_GENERATE,
        params={"description": "调研多语言模型"},
    )

    await server.handle_team_binding_generate_for_test(fake_ws, request, asyncio.Lock())

    binding = binding_store.get("research_team_2")
    entity = entity_store.get("research_team_2")
    assert fake_ws.sent[0]["ok"] is True
    assert fake_ws.sent[0]["payload"]["team"]["team_name"] == "research_team_2"
    assert fake_ws.sent[0]["payload"]["template"]["template_id"] == "research"
    assert binding is not None
    assert binding.template_id == "research"
    assert entity is not None
    assert entity.template_snapshot["leader"]["member_name"] == "lead_1"


@pytest.mark.asyncio
async def test_handle_team_binding_generate_uses_tiny_agent_result_for_name(monkeypatch, tmp_path):
    from jiuwenswarm.agents.harness import team as team_module
    from jiuwenswarm.server.runtime.team_binding_store import TeamBindingStore
    from jiuwenswarm.server.runtime.team_entity_store import TeamEntityStore

    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    binding_store = TeamBindingStore(tmp_path / "teams" / "bindings.json")
    entity_store = TeamEntityStore(tmp_path / ".agent_teams")
    config = {
        "modes": {
            "team": {
                "research": {
                    "team_name": "template_team",
                    "leader": {"member_name": "lead_1"},
                }
            }
        }
    }

    patch_shared_name(monkeypatch, "get_config", lambda: config)
    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    generation_prompts: list[str] = []

    async def fake_generate_team_name(description, *, config_base, template_id):
        generation_prompts.append(description)
        assert config_base is config
        assert template_id == "research"
        return "team-setup-task"

    monkeypatch.setattr(team_module, "generate_team_name", fake_generate_team_name)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: binding_store,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_entity_store.get_team_entity_store",
        lambda: entity_store,
    )

    request = AgentRequest(
        request_id="req-team-binding-generate-explicit-conflict",
        channel_id="web",
        req_method=ReqMethod.TEAM_BINDING_GENERATE,
        params={"description": "新建一个team_name为123的team"},
    )

    await server.handle_team_binding_generate_for_test(fake_ws, request, asyncio.Lock())

    assert fake_ws.sent[0]["ok"] is True
    assert fake_ws.sent[0]["payload"]["team"]["team_name"] == "team-setup-task"
    assert binding_store.get("team-setup-task") is not None
    assert generation_prompts == ["新建一个team_name为123的team"]

    duplicate_request = AgentRequest(
        request_id="req-team-binding-generate-explicit-conflict",
        channel_id="web",
        req_method=ReqMethod.TEAM_BINDING_GENERATE,
        params={"description": "新建一个team_name为123的team"},
    )
    await server.handle_team_binding_generate_for_test(fake_ws, duplicate_request, asyncio.Lock())

    assert fake_ws.sent[1]["ok"] is True
    assert fake_ws.sent[1]["payload"]["team"]["team_name"] == "team-setup-task_2"
    assert binding_store.get("team-setup-task_2") is not None


@pytest.mark.asyncio
@pytest.mark.parametrize("mode", ["team", "code.team", "team.plan"])
async def test_first_team_chat_auto_binds_and_preserves_original_query(monkeypatch, tmp_path, mode):
    from jiuwenswarm.agents.harness import team as team_module
    from jiuwenswarm.server.runtime.session.session_metadata import (
        get_session_metadata,
        init_session_metadata,
    )
    from jiuwenswarm.server.runtime.team_binding_store import TeamBindingStore
    from jiuwenswarm.server.runtime.team_entity_store import TeamEntityStore

    sessions_root = tmp_path / "sessions"
    patch_session_roots(monkeypatch, sessions_root)
    binding_store = TeamBindingStore(tmp_path / "teams" / "bindings.json")
    entity_store = TeamEntityStore(tmp_path / ".agent_teams")
    config = {
        "modes": {
            "team": {
                "research": {
                    "team_name": "template_team",
                    "leader": {"member_name": "lead_1"},
                }
            }
        }
    }
    original_query = "建立一个团队,开发一个斗地主游戏"
    generation_prompts: list[str] = []

    async def fake_generate_team_name(description, *, config_base, template_id):
        generation_prompts.append(description)
        assert config_base is config
        assert template_id == "research"
        return "landlord_game_team"

    patch_shared_name(monkeypatch, "get_config", lambda: config)
    monkeypatch.setattr(team_module, "generate_team_name", fake_generate_team_name)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: binding_store,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_entity_store.get_team_entity_store",
        lambda: entity_store,
    )

    init_session_metadata(
        session_id="sess-auto-team",
        channel_id="web",
        mode=mode,
    )
    request = AgentRequest(
        request_id="req-auto-team-chat",
        channel_id="web",
        session_id="sess-auto-team",
        req_method=ReqMethod.CHAT_SEND,
        params={"mode": mode, "query": original_query},
    )

    binding = await AgentWebSocketServerHarness().ensure_auto_team_binding_for_chat_for_test(request)

    assert binding.team_name == "landlord_game_team"
    assert request.params["query"] == original_query
    assert request.params["team_name"] == "landlord_game_team"
    assert generation_prompts == [original_query]
    persisted = get_session_metadata("sess-auto-team", cache_bust=True)
    assert persisted["team_name"] == "landlord_game_team"
    assert persisted["runtime_team_name"] == "landlord_game_team_sess-auto-team"
    assert persisted["team_template_id"] == "research"
    assert binding_store.get("landlord_game_team").session_ids == ("sess-auto-team",)
    assert entity_store.get("landlord_game_team") is not None


@pytest.mark.asyncio
async def test_first_team_chat_reuses_legacy_session_team_without_tiny_agent(monkeypatch, tmp_path):
    from jiuwenswarm.agents.harness import team as team_module
    from jiuwenswarm.server.runtime.session.session_metadata import init_session_metadata

    sessions_root = tmp_path / "sessions"
    patch_session_roots(monkeypatch, sessions_root)
    monkeypatch.setattr(
        team_module,
        "generate_team_name",
        lambda *args, **kwargs: pytest.fail("bound legacy sessions must not invoke TinyAgent"),
    )
    init_session_metadata(
        session_id="sess-legacy-team",
        channel_id="web",
        mode="team",
        team_name="legacy_team",
        team_template_id="legacy_template",
    )
    request = AgentRequest(
        request_id="req-legacy-team-chat",
        channel_id="web",
        session_id="sess-legacy-team",
        req_method=ReqMethod.CHAT_SEND,
        params={"mode": "team", "query": "继续执行之前的任务"},
    )

    result = await AgentWebSocketServerHarness().ensure_auto_team_binding_for_chat_for_test(request)

    assert result == "legacy_team"
    assert request.params["query"] == "继续执行之前的任务"
    assert request.params["team_name"] == "legacy_team"
    assert request.params["team_template_id"] == "legacy_template"


@pytest.mark.asyncio
async def test_officeclaw_team_chat_reads_binding_from_tenant_session_root(monkeypatch, tmp_path):
    from jiuwenswarm.server.runtime.session.session_metadata import init_session_metadata

    global_sessions_root = tmp_path / "global-sessions"
    tenant_sessions_root = tmp_path / "tenant-sessions"
    patch_shared_name(
        monkeypatch,
        "get_agent_sessions_dir",
        lambda: global_sessions_root,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.session.session_metadata.get_agent_sessions_dir",
        lambda: global_sessions_root,
    )
    patch_shared_name(
        monkeypatch,
        "_sessions_dir_for_request",
        lambda request: tenant_sessions_root,
    )
    init_session_metadata(
        session_id="sess-officeclaw-team",
        channel_id="officeclaw",
        mode="team",
        team_name="relay_team",
        team_template_id="relay_template",
        sessions_root=tenant_sessions_root,
    )

    server = AgentWebSocketServerHarness()

    async def fail_auto_generate(**kwargs):
        pytest.fail("an explicitly bound tenant session must not auto-generate a team")

    patch_shared_name(monkeypatch, "_create_generated_team_binding", fail_auto_generate)
    request = AgentRequest(
        request_id="req-officeclaw-bound-team-chat",
        channel_id="officeclaw",
        session_id="sess-officeclaw-team",
        req_method=ReqMethod.CHAT_SEND,
        params={"mode": "team", "query": "continue the existing team session"},
    )

    result = await server.ensure_auto_team_binding_for_chat_for_test(request)

    assert result == "relay_team"
    assert request.params["team_name"] == "relay_team"
    assert request.params["team_template_id"] == "relay_template"


@pytest.mark.asyncio
async def test_handle_team_bindings_list_selects_entity_when_template_deleted(monkeypatch, tmp_path):
    from jiuwenswarm.server.runtime.team_binding_store import TeamBindingStore
    from jiuwenswarm.server.runtime.team_entity_store import TeamEntityStore

    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    binding_store = TeamBindingStore(tmp_path / "teams" / "bindings.json")
    binding = binding_store.create(team_name="research_team", template_id="deleted")
    entity_store = TeamEntityStore(tmp_path / ".agent_teams")
    entity_store.write(
        team_name=binding.team_name,
        template_id=binding.template_id,
        template_snapshot={"team_name": "template_team", "leader": {"member_name": "lead_1"}},
        created_at=binding.created_at,
    )

    patch_shared_name(monkeypatch, "get_config", lambda: {"modes": {"team": {}}})
    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: binding_store,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_entity_store.get_team_entity_store",
        lambda: entity_store,
    )
    monkeypatch.setattr(
        "jiuwenswarm.agents.harness.team.get_all_team_managers",
        lambda: [],
    )

    request = AgentRequest(
        request_id="req-team-bindings-list",
        channel_id="web",
        req_method=ReqMethod.TEAM_BINDINGS_LIST,
        params={},
    )

    await server.handle_team_bindings_list_for_test(fake_ws, request, asyncio.Lock())

    teams = fake_ws.sent[0]["payload"]["teams"]
    assert teams[0]["team_name"] == "research_team"
    assert teams[0]["selectable"] is True
    assert teams[0]["team_config_available"] is True
    assert teams[0]["template_available"] is True
    assert teams[0]["source_template_available"] is False


def test_active_team_session_map_uses_logical_binding_name(monkeypatch, tmp_path):
    class _Manager:
        @staticmethod
        def get_runtime_team_snapshot():
            return {
                "sess-1": {
                    "team_name": "research_team_sess-1",
                    "state": "active",
                }
            }

    monkeypatch.setattr(
        "jiuwenswarm.agents.harness.team.get_all_team_managers",
        lambda: [_Manager()],
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.session.session_metadata.get_session_metadata",
        lambda _session_id, **_kwargs: {
            "team_name": "research_team",
            "runtime_team_name": "research_team_sess-1",
        },
    )

    active = team_module._active_team_session_map(
        sessions_root=tmp_path / "sessions"
    )

    assert active == {"research_team": "sess-1"}


@pytest.mark.asyncio
async def test_handle_team_session_bind_allows_existing_session_dir_without_metadata(monkeypatch, tmp_path):
    from jiuwenswarm.server.runtime.team_binding_store import TeamBindingStore
    from jiuwenswarm.server.runtime.team_entity_store import TeamEntityStore
    from jiuwenswarm.server.runtime.tenant_catalog_registry import (
        TenantAgentSpec,
        TenantCatalogRegistry,
    )

    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    sessions_root = tmp_path / "sessions"
    (sessions_root / "existing_session").mkdir(parents=True)
    store = TeamBindingStore(tmp_path / "teams" / "bindings.json")
    binding = store.create(team_name="research_team", template_id="default")
    entity_store = TeamEntityStore(tmp_path / ".agent_teams")
    entity_store.write(
        team_name=binding.team_name,
        template_id=binding.template_id,
        template_snapshot={"team_name": "template_team", "leader": {"member_name": "lead_1"}},
        created_at=binding.created_at,
    )
    tenant_config = {
        "modes": {
            "team": {
                "default": {
                    "team_name": "template_team",
                    "leader": {"member_name": "lead_1"},
                    "agents": {
                        "lead_1": {},
                        "new_analyst": {
                            "description": "new member",
                            "model": {
                                "model_client_config": {
                                    "model_name": "team-model",
                                    "client_provider": "OpenAI",
                                    "api_base": "https://models.example/v1",
                                    "api_key": "secret",
                                },
                                "model_request_config": {"model": "team-model"},
                            },
                        },
                    },
                }
            }
        },
        "models": {
            "defaults": [
                {
                    "model_client_config": {
                        "model_name": "${MODEL_NAME}",
                        "client_provider": "${MODEL_PROVIDER}",
                        "api_base": "${API_BASE}",
                        "api_key": "${API_KEY}",
                    }
                }
            ]
        },
    }
    registry = TenantCatalogRegistry.get_instance()
    registry.upsert(
        TenantAgentSpec(
            service_id="officeclaw_service_owner",
            agent_id="agentteam",
            config=tenant_config,
            env={
                "MODEL_NAME": "team-model",
                "MODEL_PROVIDER": "OpenAI",
                "API_BASE": "https://models.example/v1",
                "API_KEY": "secret",
            },
        )
    )

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    patch_session_roots(monkeypatch, sessions_root)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: store,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_entity_store.get_team_entity_store",
        lambda: entity_store,
    )
    request = AgentRequest(
        request_id="req-team-session-bind-existing",
        channel_id="officeclaw",
        service_id="officeclaw_service_owner",
        agent_id="agentteam",
        req_method=ReqMethod.TEAM_SESSION_BIND,
        params={
            "session_id": "existing_session",
            "team_name": "research_team",
            "mode": "code.team",
        },
    )

    try:
        await server.handle_team_session_bind_for_test(fake_ws, request, asyncio.Lock())
    finally:
        TenantCatalogRegistry.reset_for_tests()

    metadata = json.loads((sessions_root / "existing_session" / "metadata.json").read_text(encoding="utf-8"))
    assert metadata["mode"] == "code.team"
    assert metadata["team_name"] == "research_team"
    assert metadata["runtime_team_name"] == "research_team_existing_session"
    assert metadata["team_template_id"] == "default"
    snapshot_path = sessions_root / "existing_session" / ".team-template-snapshot.json"
    snapshot = json.loads(snapshot_path.read_text(encoding="utf-8"))
    analyst = snapshot["agents"]["new_analyst"]
    assert analyst["description"] == "new member"
    assert analyst["model"]["ref"].startswith("model-identity-v1:")
    assert "team_template_snapshot" not in metadata
    persisted_snapshot = snapshot_path.read_text(encoding="utf-8")
    assert "api_key" not in persisted_snapshot
    assert "api_base" not in persisted_snapshot
    assert store.get("research_team").session_ids == ("existing_session",)
    assert entity_store.get("research_team") is not None
    assert fake_ws.sent[0]["ok"] is True
    assert fake_ws.sent[0]["payload"]["session_id"] == "existing_session"
    assert fake_ws.sent[0]["payload"]["team_name"] == "research_team"
    assert fake_ws.sent[0]["payload"]["team_template_id"] == "default"


@pytest.mark.asyncio
async def test_handle_team_session_bind_preserves_native_legacy_root_and_refreshes_snapshot(monkeypatch, tmp_path):
    from jiuwenswarm.server.runtime.team_binding_store import TeamBindingStore
    from jiuwenswarm.server.runtime.team_entity_store import TeamEntityStore

    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    tenant_sessions_root = tmp_path / "tenant-sessions"
    legacy_sessions_root = tmp_path / "legacy-sessions"
    (legacy_sessions_root / "native_session").mkdir(parents=True)
    store = TeamBindingStore(tmp_path / "teams" / "bindings.json")
    binding = store.create(team_name="research_team", template_id="default")
    entity_store = TeamEntityStore(tmp_path / ".agent_teams")
    entity_store.write(
        team_name=binding.team_name,
        template_id=binding.template_id,
        template_snapshot={
            "team_name": "entity_fallback",
            "leader": {"member_name": "entity_lead"},
            "agents": {"entity_lead": {}, "entity_analyst": {}},
        },
        created_at=binding.created_at,
    )

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    patch_shared_name(monkeypatch, "_sessions_dir_for_request", lambda _request: tenant_sessions_root)
    patch_shared_name(monkeypatch, "get_agent_sessions_dir", lambda: legacy_sessions_root)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: store,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_entity_store.get_team_entity_store",
        lambda: entity_store,
    )
    effective_config = {
        "modes": {
            "team": {
                "default": {
                    "team_name": "current_template",
                    "leader": {"member_name": "current_lead"},
                    "agents": {"current_lead": {}, "current_analyst": {}},
                }
            }
        }
    }
    patch_shared_name(monkeypatch, "_effective_config_for_request", lambda _request: effective_config)
    request = AgentRequest(
        request_id="req-team-session-bind-native",
        channel_id="web",
        req_method=ReqMethod.TEAM_SESSION_BIND,
        params={"session_id": "native_session", "team_name": "research_team", "mode": "team"},
    )

    await server.handle_team_session_bind_for_test(fake_ws, request, asyncio.Lock())

    metadata = json.loads(
        (tenant_sessions_root / "native_session" / "metadata.json").read_text(encoding="utf-8")
    )
    assert metadata["team_name"] == "research_team"
    assert metadata["runtime_team_name"] == "research_team_native_session"
    assert store.get("research_team").session_ids == ("native_session",)
    snapshot_path = tenant_sessions_root / "native_session" / ".team-template-snapshot.json"
    snapshot = json.loads(snapshot_path.read_text(encoding="utf-8"))
    assert "current_analyst" in snapshot["agents"]
    assert "entity_analyst" not in snapshot["agents"]
    assert fake_ws.sent[0]["ok"] is True

    effective_config["modes"]["team"]["default"]["agents"] = {
        "current_lead": {},
        "refreshed_analyst": {},
    }
    await server.handle_team_session_bind_for_test(fake_ws, request, asyncio.Lock())

    refreshed_snapshot = json.loads(snapshot_path.read_text(encoding="utf-8"))
    assert "refreshed_analyst" in refreshed_snapshot["agents"]
    assert "current_analyst" not in refreshed_snapshot["agents"]

    effective_config["modes"]["team"].clear()
    await server.handle_team_session_bind_for_test(fake_ws, request, asyncio.Lock())

    fallback_snapshot = json.loads(snapshot_path.read_text(encoding="utf-8"))
    assert "entity_analyst" in fallback_snapshot["agents"]
    assert fake_ws.sent[-1]["ok"] is True


@pytest.mark.asyncio
async def test_handle_team_session_bind_rejects_missing_session(monkeypatch, tmp_path):
    from jiuwenswarm.server.runtime.team_binding_store import TeamBindingStore

    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    sessions_root = tmp_path / "sessions"
    sessions_root.mkdir()
    store = TeamBindingStore(tmp_path / "teams" / "bindings.json")
    store.create(team_name="research_team", template_id="default")

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    patch_session_roots(monkeypatch, sessions_root)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: store,
    )

    request = AgentRequest(
        request_id="req-team-session-bind-missing",
        channel_id="web",
        req_method=ReqMethod.TEAM_SESSION_BIND,
        params={
            "session_id": "missing_session",
            "team_name": "research_team",
            "mode": "team",
        },
    )

    await server.handle_team_session_bind_for_test(fake_ws, request, asyncio.Lock())

    assert not (sessions_root / "missing_session").exists()
    assert store.get("research_team").session_ids == ()
    assert fake_ws.sent == [
        {
            "response_id": "req-team-session-bind-missing",
            "payload": {"error": "session not found", "code": "NOT_FOUND"},
            "ok": False,
        }
    ]


@pytest.mark.asyncio
async def test_handle_team_session_bind_rejects_unsafe_session_path_before_binding(monkeypatch, tmp_path):
    from jiuwenswarm.server.runtime.team_binding_store import TeamBindingStore

    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    sessions_root = tmp_path / "sessions"
    sessions_root.mkdir()
    (tmp_path / "outside-session").mkdir()
    store = TeamBindingStore(tmp_path / "teams" / "bindings.json")
    store.create(team_name="research_team", template_id="default")

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    patch_session_roots(monkeypatch, sessions_root)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: store,
    )
    request = AgentRequest(
        request_id="req-team-session-bind-unsafe",
        channel_id="web",
        req_method=ReqMethod.TEAM_SESSION_BIND,
        params={"session_id": "../outside-session", "team_name": "research_team", "mode": "team"},
    )

    await server.handle_team_session_bind_for_test(fake_ws, request, asyncio.Lock())

    assert fake_ws.sent[0]["ok"] is False
    assert store.get("research_team").session_ids == ()


@pytest.mark.asyncio
async def test_handle_team_session_bind_rejects_unsafe_deleted_template_snapshot(monkeypatch, tmp_path):
    from jiuwenswarm.server.runtime.team_binding_store import TeamBindingStore

    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    sessions_root = tmp_path / "sessions"
    (sessions_root / "existing_session").mkdir(parents=True)
    store = TeamBindingStore(tmp_path / "teams" / "bindings.json")
    store.create(team_name="research_team", template_id="deleted")

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    patch_session_roots(monkeypatch, sessions_root)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: store,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_entity_store.ensure_team_entity_for_binding",
        lambda *_args, **_kwargs: types.SimpleNamespace(
            template_snapshot={"team_name": "legacy", "api_key": "plaintext-secret"}
        ),
    )
    patch_shared_name(monkeypatch, "_effective_config_for_request", lambda _request: {})
    request = AgentRequest(
        request_id="req-team-session-bind-unsafe-legacy",
        channel_id="web",
        service_id="officeclaw_service_owner",
        agent_id="agentteam",
        req_method=ReqMethod.TEAM_SESSION_BIND,
        params={"session_id": "existing_session", "team_name": "research_team", "mode": "team"},
    )

    await server.handle_team_session_bind_for_test(fake_ws, request, asyncio.Lock())

    assert fake_ws.sent[0]["ok"] is False
    assert store.get("research_team").session_ids == ()
    assert not (sessions_root / "existing_session" / ".team-template-snapshot.json").exists()


@pytest.mark.asyncio
async def test_handle_team_session_bind_snapshot_write_failure_does_not_change_binding(monkeypatch, tmp_path):
    from jiuwenswarm.server.runtime.team_binding_store import TeamBindingStore

    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    sessions_root = tmp_path / "sessions"
    (sessions_root / "existing_session").mkdir(parents=True)
    store = TeamBindingStore(tmp_path / "teams" / "bindings.json")
    store.create(team_name="research_team", template_id="default")

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    patch_session_roots(monkeypatch, sessions_root)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: store,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_entity_store.ensure_team_entity_for_binding",
        lambda *_args, **_kwargs: types.SimpleNamespace(template_snapshot={"team_name": "template"}),
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.session.session_metadata._write_session_team_template_snapshot",
        lambda *_args, **_kwargs: (_ for _ in ()).throw(OSError("disk full")),
    )
    patch_shared_name(
        monkeypatch,
        "_effective_config_for_request",
        lambda _request: {"modes": {"team": {"default": {"team_name": "template"}}}},
    )
    request = AgentRequest(
        request_id="req-team-session-bind-write-failure",
        channel_id="web",
        service_id="officeclaw_service_owner",
        agent_id="agentteam",
        req_method=ReqMethod.TEAM_SESSION_BIND,
        params={"session_id": "existing_session", "team_name": "research_team", "mode": "team"},
    )

    await server.handle_team_session_bind_for_test(fake_ws, request, asyncio.Lock())

    assert fake_ws.sent[0]["ok"] is False
    assert store.get("research_team").session_ids == ()


@pytest.mark.asyncio
@pytest.mark.parametrize(
    ("mode", "resolved_mode", "is_team"),
    [
        ("team", "team", True),
        ("agent.plan", "agent.plan", False),
    ],
)
async def test_handle_session_switch_delegates_product_lifecycle(
    monkeypatch,
    mode,
    resolved_mode,
    is_team,
):
    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    prepare_calls = []
    kvc_calls = []

    async def _prepare_session_switch(**kwargs):
        prepare_calls.append(kwargs)
        return is_team, resolved_mode, object(), None, object()

    async def _dispatch_kvc(**kwargs):
        kvc_calls.append(kwargs)

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    monkeypatch.setattr(
        server,
        "_prepare_session_switch_owner",
        _prepare_session_switch,
    )
    monkeypatch.setattr(server, "_dispatch_session_switch_kvc", _dispatch_kvc)

    request = AgentRequest(
        request_id="req-session-switch",
        channel_id="web",
        req_method=ReqMethod.SESSION_SWITCH,
        params={
            "mode": mode,
            "session_id": "sess_002",
            "previous_session_id": "sess_001",
        },
    )

    await server.handle_session_switch_for_test(
        fake_ws,
        request,
        asyncio.Lock(),
    )

    assert prepare_calls == [
        {
            "channel_id": "web",
            "target_session_id": "sess_002",
            "previous_session_id": "sess_001",
            "params": request.params,
            "reason": "session.switch: ",
        }
    ]
    assert fake_ws.sent[-1] == {
        "response_id": "req-session-switch",
        "payload": {
            "session_id": "sess_002",
            "mode": resolved_mode,
            "switched": True,
        },
        "ok": True,
    }
    await asyncio.sleep(0)
    assert len(kvc_calls) == 1
    assert kvc_calls[0]["target_session_id"] == "sess_002"
    assert kvc_calls[0]["previous_session_id"] == "sess_001"


@pytest.mark.asyncio
async def test_handle_session_switch_acks_before_async_kvc(monkeypatch):
    """A slow optional affinity signal must not hold the UI switch response."""
    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    kvc_started = asyncio.Event()
    kvc_release = asyncio.Event()

    async def _prepare_session_switch(**_kwargs):
        return False, "agent.plan", object(), None, object()

    async def _slow_kvc(**_kwargs):
        kvc_started.set()
        await kvc_release.wait()

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    monkeypatch.setattr(
        server,
        "_prepare_session_switch_owner",
        _prepare_session_switch,
    )
    monkeypatch.setattr(server, "_dispatch_session_switch_kvc", _slow_kvc)

    request = AgentRequest(
        request_id="req-session-switch-async-kvc",
        channel_id="web",
        req_method=ReqMethod.SESSION_SWITCH,
        params={
            "mode": "agent.plan",
            "session_id": "sess_002",
            "previous_session_id": "sess_001",
        },
    )

    await server.handle_session_switch_for_test(
        fake_ws,
        request,
        asyncio.Lock(),
    )
    await asyncio.wait_for(kvc_started.wait(), timeout=1.0)

    assert fake_ws.sent == [
        {
            "response_id": "req-session-switch-async-kvc",
            "payload": {
                "session_id": "sess_002",
                "mode": "agent.plan",
                "switched": True,
            },
            "ok": True,
        }
    ]

    kvc_release.set()
    await asyncio.sleep(0)


@pytest.mark.asyncio
async def test_handle_session_switch_serializes_reentrant_requests(monkeypatch):
    """Rapid switches on one WebSocket must not overlap owner preparation."""
    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    first_prepare_started = asyncio.Event()
    release_first_prepare = asyncio.Event()
    prepare_order = []
    active_prepares = 0
    max_active_prepares = 0

    async def _prepare_session_switch(**kwargs):
        nonlocal active_prepares, max_active_prepares
        target_session_id = kwargs["target_session_id"]
        prepare_order.append(target_session_id)
        active_prepares += 1
        max_active_prepares = max(max_active_prepares, active_prepares)
        if target_session_id == "sess_002":
            first_prepare_started.set()
            await release_first_prepare.wait()
        active_prepares -= 1
        return False, "agent.plan", None, None, None

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    monkeypatch.setattr(
        server,
        "_prepare_session_switch_owner",
        _prepare_session_switch,
    )

    first_request = AgentRequest(
        request_id="req-session-switch-first",
        channel_id="web",
        req_method=ReqMethod.SESSION_SWITCH,
        params={
            "mode": "agent.plan",
            "session_id": "sess_002",
            "previous_session_id": "sess_001",
        },
    )
    second_request = AgentRequest(
        request_id="req-session-switch-second",
        channel_id="web",
        req_method=ReqMethod.SESSION_SWITCH,
        params={
            "mode": "agent.plan",
            "session_id": "sess_003",
            "previous_session_id": "sess_002",
        },
    )

    first_task = asyncio.create_task(
        server.handle_session_switch_for_test(
            fake_ws,
            first_request,
            asyncio.Lock(),
        )
    )
    await asyncio.wait_for(first_prepare_started.wait(), timeout=1.0)
    second_task = asyncio.create_task(
        server.handle_session_switch_for_test(
            fake_ws,
            second_request,
            asyncio.Lock(),
        )
    )
    await asyncio.sleep(0)

    assert prepare_order == ["sess_002"]
    assert fake_ws.sent == []

    release_first_prepare.set()
    await asyncio.gather(first_task, second_task)

    assert prepare_order == ["sess_002", "sess_003"]
    assert max_active_prepares == 1
    assert [
        response["payload"]["session_id"] for response in fake_ws.sent
    ] == ["sess_002", "sess_003"]


@pytest.mark.asyncio
async def test_handle_team_delete_deletes_all_matching_team_sessions(monkeypatch, tmp_path):
    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    delete_calls = []
    removed_dirs = []
    stop_calls = []
    cleared_metadata_cache = []
    store_calls = []

    class FakeBindingStore:
        @staticmethod
        def delete(team_name: str):
            store_calls.append(("binding", team_name))
            return True

    class FakeEntityStore:
        @staticmethod
        def delete_team_directory(team_name: str):
            store_calls.append(("entity", team_name))
            return True

    async def fake_delete_agent_team(*, team_name, session_ids, force):
        delete_calls.append(
            {"team_name": team_name, "session_ids": session_ids, "force": force}
        )
        return True

    async def fake_find_team_session_ids(team_name: str, **_kwargs):
        assert team_name == "jiuwen_team"
        return ["team_sess_001", "team_sess_002"]

    sessions_root = tmp_path / "sessions"
    (sessions_root / "team_sess_001").mkdir(parents=True)
    (sessions_root / "team_sess_002").mkdir()

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    monkeypatch.setattr(
        "jiuwenswarm.agents.harness.team.stop_team_session_runtime_across_managers",
        lambda session_id, reason="": stop_calls.append(
            {"session_id": session_id, "reason": reason}
        ) or asyncio.sleep(0, result=True),
    )
    patch_find_team_session_ids(monkeypatch, fake_find_team_session_ids)
    monkeypatch.setattr(
        "openjiuwen.core.runner.Runner.delete_agent_team",
        fake_delete_agent_team,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.session.session_metadata.get_session_metadata",
        lambda session_id, **_kwargs: {
            "team_name": "jiuwen_team",
            "runtime_team_name": f"jiuwen_team_{session_id}",
        },
    )
    patch_shared_name(
        monkeypatch, "_sessions_dir_for_request", lambda _request: sessions_root
    )
    patch_shared_name(monkeypatch, "get_agent_sessions_dir", lambda: FakeSessionsRoot())
    monkeypatch.setattr(
        agent_ws_server_module.shutil,
        "rmtree",
        lambda path: removed_dirs.append(path.name),
    )
    patch_shared_name(
        monkeypatch,
        "remove_session_metadata_cache",
        lambda session_id, **_kwargs: cleared_metadata_cache.append(session_id),
    )
    monkeypatch.setattr(
        interface_deep_module,
        "ensure_persistent_checkpointer",
        lambda: asyncio.sleep(0),
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: FakeBindingStore(),
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_entity_store.get_team_entity_store",
        lambda: FakeEntityStore(),
    )

    request = AgentRequest(
        request_id="req-team-delete",
        channel_id="web",
        req_method=ReqMethod.TEAM_DELETE,
        params={"mode": "team", "team_name": "jiuwen_team"},
    )

    await server.handle_team_delete_for_test(fake_ws, request, asyncio.Lock())

    assert delete_calls == [
        {
            "team_name": "jiuwen_team_team_sess_001",
            "session_ids": ["team_sess_001"],
            "force": True,
        },
        {
            "team_name": "jiuwen_team_team_sess_002",
            "session_ids": ["team_sess_002"],
            "force": True,
        }
    ]
    assert stop_calls == [
        {"session_id": "team_sess_001", "reason": "team.delete: "},
        {"session_id": "team_sess_002", "reason": "team.delete: "},
    ]
    assert removed_dirs == ["team_sess_001", "team_sess_002"]
    assert cleared_metadata_cache == ["team_sess_001", "team_sess_002"]
    assert store_calls == [("entity", "jiuwen_team"), ("binding", "jiuwen_team")]
    assert fake_ws.sent == [
        {
            "response_id": "req-team-delete",
            "payload": {
                "team_name": "jiuwen_team",
                "session_ids": ["team_sess_001", "team_sess_002"],
                "deleted": True,
            },
            "ok": True,
        }
    ]


@pytest.mark.asyncio
async def test_handle_team_delete_continues_other_runtimes_after_runner_exception(monkeypatch):
    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    delete_calls = []
    store_calls = []

    class FakeBindingStore:
        @staticmethod
        def delete(team_name: str):
            store_calls.append(("binding", team_name))
            return True

    class FakeEntityStore:
        @staticmethod
        def delete_team_directory(team_name: str):
            store_calls.append(("entity", team_name))
            return True

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    monkeypatch.setattr(
        "jiuwenswarm.agents.harness.team.stop_team_session_runtime_across_managers",
        lambda session_id, reason="": asyncio.sleep(0, result=True),
    )
    async def fake_delete_agent_team(*, team_name, session_ids, force):
        delete_calls.append(
            {"team_name": team_name, "session_ids": session_ids, "force": force}
        )
        if team_name == "jiuwen_team_team_sess_001":
            raise RuntimeError("release info unavailable")
        return True

    monkeypatch.setattr(
        "openjiuwen.core.runner.Runner.delete_agent_team",
        fake_delete_agent_team,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.session.session_metadata.get_session_metadata",
        lambda session_id, **_kwargs: {
            "team_name": "jiuwen_team",
            "runtime_team_name": f"jiuwen_team_{session_id}",
        },
    )
    monkeypatch.setattr(
        interface_deep_module,
        "ensure_persistent_checkpointer",
        lambda: asyncio.sleep(0),
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: FakeBindingStore(),
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_entity_store.get_team_entity_store",
        lambda: FakeEntityStore(),
    )
    patch_find_team_session_ids(
        monkeypatch,
        lambda _team_name, **_kwargs: asyncio.sleep(
            0,
            result=["team_sess_001", "team_sess_002"],
        ),
    )

    request = AgentRequest(
        request_id="req-team-delete-runner-failed",
        channel_id="web",
        req_method=ReqMethod.TEAM_DELETE,
        params={"mode": "team", "team_name": "jiuwen_team"},
    )

    await server.handle_team_delete_for_test(fake_ws, request, asyncio.Lock())

    assert delete_calls == [
        {
            "team_name": "jiuwen_team_team_sess_001",
            "session_ids": ["team_sess_001"],
            "force": True,
        },
        {
            "team_name": "jiuwen_team_team_sess_002",
            "session_ids": ["team_sess_002"],
            "force": True,
        },
    ]
    assert store_calls == []
    assert fake_ws.sent[-1] == {
        "response_id": "req-team-delete-runner-failed",
        "payload": {
            "error": "agent team runtime cleanup failed",
            "code": "DELETE_FAILED",
            "team_name": "jiuwen_team",
            "deleted": False,
        },
        "ok": False,
    }


@pytest.mark.asyncio
async def test_handle_team_delete_keeps_catalog_when_session_directory_delete_fails(
    monkeypatch, tmp_path
):
    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    store_calls = []
    cleared_metadata_cache = []
    sessions_root = tmp_path / "sessions"
    (sessions_root / "team_sess_001").mkdir(parents=True)

    class FakeBindingStore:
        @staticmethod
        def delete(team_name: str):
            store_calls.append(("binding", team_name))
            return True

    class FakeEntityStore:
        @staticmethod
        def delete_team_directory(team_name: str):
            store_calls.append(("entity", team_name))
            return True

    class FakeSessionDir:
        @staticmethod
        def exists() -> bool:
            return True

    class FakeSessionsRoot:
        @staticmethod
        def __truediv__(_session_id: str):
            return FakeSessionDir()

    patch_shared_name(
        monkeypatch,
        "encode_agent_response_for_wire",
        fake_encode_agent_response_for_wire,
    )
    monkeypatch.setattr(
        "jiuwenswarm.agents.harness.team.stop_team_session_runtime_across_managers",
        lambda session_id, reason="": asyncio.sleep(0, result=True),
    )
    monkeypatch.setattr(
        "openjiuwen.core.runner.Runner.delete_agent_team",
        lambda **kwargs: asyncio.sleep(0, result=True),
    )
    patch_shared_name(
        monkeypatch, "_sessions_dir_for_request", lambda _request: sessions_root
    )
    patch_shared_name(monkeypatch, "get_agent_sessions_dir", lambda: FakeSessionsRoot())

    def fail_rmtree(_path):
        raise OSError("permission denied")

    monkeypatch.setattr(agent_ws_server_module.shutil, "rmtree", fail_rmtree)
    patch_shared_name(
        monkeypatch,
        "remove_session_metadata_cache",
        lambda session_id, **_kwargs: cleared_metadata_cache.append(session_id),
    )
    monkeypatch.setattr(
        interface_deep_module,
        "ensure_persistent_checkpointer",
        lambda: asyncio.sleep(0),
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: FakeBindingStore(),
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_entity_store.get_team_entity_store",
        lambda: FakeEntityStore(),
    )
    patch_find_team_session_ids(
        monkeypatch,
        lambda _team_name, **_kwargs: asyncio.sleep(0, result=["team_sess_001"])
    )

    request = AgentRequest(
        request_id="req-team-delete-session-dir-failed",
        channel_id="web",
        req_method=ReqMethod.TEAM_DELETE,
        params={"mode": "team", "team_name": "jiuwen_team"},
    )

    await server.handle_team_delete_for_test(fake_ws, request, asyncio.Lock())

    assert store_calls == []
    assert cleared_metadata_cache == []
    assert fake_ws.sent[-1] == {
        "response_id": "req-team-delete-session-dir-failed",
        "payload": {
            "error": "failed to delete local team session directories",
            "code": "DELETE_FAILED",
            "team_name": "jiuwen_team",
            "failed_session_ids": ["team_sess_001"],
            "deleted": False,
        },
        "ok": False,
    }


@pytest.mark.asyncio
async def test_handle_team_delete_without_sessions_skips_checkpointer_and_removes_entity(monkeypatch):
    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    store_calls = []

    class FakeBindingStore:
        @staticmethod
        def get(team_name: str):
            assert team_name == "archived_team"
            return object()

        @staticmethod
        def delete(team_name: str):
            store_calls.append(("binding", team_name))
            return True

    class FakeEntityStore:
        @staticmethod
        def exists(team_name: str):
            assert team_name == "archived_team"
            return True

        @staticmethod
        def delete_team_directory(team_name: str):
            store_calls.append(("entity", team_name))
            return True

    async def fail_ensure_persistent_checkpointer():
        raise AssertionError("team.delete should not require a checkpointer without sessions")

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    monkeypatch.setattr(
        interface_deep_module,
        "ensure_persistent_checkpointer",
        fail_ensure_persistent_checkpointer,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: FakeBindingStore(),
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_entity_store.get_team_entity_store",
        lambda: FakeEntityStore(),
    )
    patch_find_team_session_ids(
        monkeypatch, lambda _team_name, **_kwargs: asyncio.sleep(0, result=[])
    )

    request = AgentRequest(
        request_id="req-team-delete-no-sessions",
        channel_id="web",
        req_method=ReqMethod.TEAM_DELETE,
        params={"mode": "team", "team_name": "archived_team"},
    )

    await server.handle_team_delete_for_test(fake_ws, request, asyncio.Lock())

    assert store_calls == [("entity", "archived_team"), ("binding", "archived_team")]
    assert fake_ws.sent == [
        {
            "response_id": "req-team-delete-no-sessions",
            "payload": {
                "team_name": "archived_team",
                "session_ids": [],
                "deleted": True,
            },
            "ok": True,
        }
    ]


@pytest.mark.asyncio
async def test_handle_team_delete_with_sessions_requires_persistent_checkpointer(monkeypatch):
    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    delete_calls = []

    async def fake_ensure_persistent_checkpointer():
        raise RuntimeError("checkpoint unavailable")

    async def fake_delete_agent_team(*, team_name, session_ids, force):
        delete_calls.append(
            {"team_name": team_name, "session_ids": session_ids, "force": force}
        )
        return True

    async def fake_find_team_session_ids(_team_name: str, **_kwargs):
        return ["team_sess_001"]

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    monkeypatch.setattr(
        interface_deep_module,
        "ensure_persistent_checkpointer",
        fake_ensure_persistent_checkpointer,
    )
    monkeypatch.setattr(
        "openjiuwen.core.runner.Runner.delete_agent_team",
        fake_delete_agent_team,
    )
    patch_find_team_session_ids(monkeypatch, fake_find_team_session_ids)

    request = AgentRequest(
        request_id="req-team-delete-checkpoint",
        channel_id="web",
        req_method=ReqMethod.TEAM_DELETE,
        params={"mode": "team", "team_name": "jiuwen_team"},
    )

    await server.handle_team_delete_for_test(fake_ws, request, asyncio.Lock())

    assert delete_calls == []
    assert fake_ws.sent == [
        {
            "response_id": "req-team-delete-checkpoint",
            "payload": {
                "error": "persistent checkpointer is unavailable",
                "code": "CHECKPOINT_UNAVAILABLE",
            },
            "ok": False,
        }
    ]


@pytest.mark.asyncio
async def test_handle_team_delete_rejects_non_team_mode(monkeypatch):
    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)

    request = AgentRequest(
        request_id="req-team-delete-agent",
        channel_id="web",
        req_method=ReqMethod.TEAM_DELETE,
        params={"mode": "agent.plan", "team_name": "jiuwen_team"},
    )

    await server.handle_team_delete_for_test(fake_ws, request, asyncio.Lock())

    assert fake_ws.sent == [
        {
            "response_id": "req-team-delete-agent",
            "payload": {
                "error": "team.delete is only supported for team mode",
                "code": "UNSUPPORTED_MODE",
            },
            "ok": False,
        }
    ]


@pytest.mark.asyncio
async def test_handle_team_delete_requires_team_name(monkeypatch):
    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)

    request = AgentRequest(
        request_id="req-team-delete-missing-name",
        channel_id="web",
        req_method=ReqMethod.TEAM_DELETE,
        params={"mode": "team"},
    )

    await server.handle_team_delete_for_test(fake_ws, request, asyncio.Lock())

    assert fake_ws.sent == [
        {
            "response_id": "req-team-delete-missing-name",
            "payload": {
                "error": "team_name is required",
                "code": "BAD_REQUEST",
            },
            "ok": False,
        }
    ]


@pytest.mark.asyncio
async def test_handle_session_delete_initializes_persistent_checkpointer(monkeypatch, tmp_path):
    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    sessions_root = tmp_path / "sessions"
    session_dir = sessions_root / "sess-agent-1"
    session_dir.mkdir(parents=True)
    ensure_calls = []
    release_calls = []
    cleared_metadata_cache = []

    async def fake_ensure_persistent_checkpointer():
        ensure_calls.append("called")

    async def fake_release(session_id: str):
        release_calls.append(session_id)

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    patch_shared_name(monkeypatch, "get_agent_sessions_dir", lambda: sessions_root)
    patch_shared_name(
        monkeypatch,
        "_sessions_dir_for_request",
        lambda _request: sessions_root,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.session.session_metadata.get_session_metadata",
        lambda _session_id, **_kwargs: {"mode": "agent.plan"},
    )
    monkeypatch.setattr(
        interface_deep_module,
        "ensure_persistent_checkpointer",
        fake_ensure_persistent_checkpointer,
    )
    monkeypatch.setattr(
        "openjiuwen.core.runner.Runner.release",
        fake_release,
    )
    patch_shared_name(
        monkeypatch,
        "remove_session_metadata_cache",
        lambda session_id, **_kwargs: cleared_metadata_cache.append(session_id),
    )

    request = AgentRequest(
        request_id="req-session-delete",
        channel_id="web",
        req_method=ReqMethod.SESSION_DELETE,
        params={"session_id": "sess-agent-1"},
    )

    await server.handle_session_delete_for_test(fake_ws, request, asyncio.Lock())

    assert ensure_calls == ["called"]
    assert release_calls == ["sess-agent-1"]
    assert cleared_metadata_cache == ["sess-agent-1"]
    assert not session_dir.exists()
    assert fake_ws.sent == [
        {
            "response_id": "req-session-delete",
            "payload": {"session_id": "sess-agent-1"},
            "ok": True,
        }
    ]


@pytest.mark.asyncio
async def test_handle_session_delete_uses_request_tenant_sessions_root(
    monkeypatch,
    tmp_path,
):
    from jiuwenswarm.server.runtime.session.session_metadata import (
        get_session_metadata,
        init_session_metadata,
        update_session_metadata,
    )

    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    global_root = tmp_path / "global-sessions"
    tenant_root = tmp_path / "tenant-sessions"
    global_session = global_root / "same-session-id"
    tenant_session = tenant_root / "same-session-id"
    global_session.mkdir(parents=True)
    tenant_session.mkdir(parents=True)
    init_session_metadata(
        session_id="same-session-id",
        channel_id="officeclaw",
        mode="agent",
        sessions_root=tenant_root,
    )
    update_session_metadata(
        session_id="same-session-id",
        title="cached tenant session",
        sync_write=True,
        sessions_root=tenant_root,
    )
    assert get_session_metadata(
        "same-session-id",
        sessions_root=tenant_root,
    )["title"] == "cached tenant session"

    async def fake_release(_session_id: str):
        return None

    async def fake_evict_plan_session(**_kwargs):
        return None

    async def fake_ensure_persistent_checkpointer():
        return None

    patch_shared_name(
        monkeypatch,
        "encode_agent_response_for_wire",
        fake_encode_agent_response_for_wire,
    )
    patch_shared_name(
        monkeypatch,
        "get_agent_sessions_dir",
        lambda: global_root,
    )
    patch_shared_name(
        monkeypatch,
        "_sessions_dir_for_request",
        lambda _request: tenant_root,
    )
    monkeypatch.setattr("openjiuwen.core.runner.Runner.release", fake_release)
    monkeypatch.setattr(
        interface_deep_module,
        "ensure_persistent_checkpointer",
        fake_ensure_persistent_checkpointer,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.session.kv_cache_product_hooks.evict_plan_session",
        fake_evict_plan_session,
    )

    request = AgentRequest(
        request_id="req-tenant-session-delete",
        channel_id="officeclaw",
        agent_id="office",
        service_id="tenant-a",
        req_method=ReqMethod.SESSION_DELETE,
        params={"session_id": "same-session-id"},
    )

    await server.handle_session_delete_for_test(fake_ws, request, asyncio.Lock())

    assert not tenant_session.exists()
    assert global_session.exists()
    assert get_session_metadata(
        "same-session-id",
        sessions_root=tenant_root,
    ) == {}


@pytest.mark.asyncio
async def test_handle_session_delete_unbinds_team_session(monkeypatch, tmp_path):
    from jiuwenswarm.server.runtime.team_binding_store import TeamBindingStore

    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    sessions_root = tmp_path / "sessions"
    session_dir = sessions_root / "sess-team-1"
    session_dir.mkdir(parents=True)
    binding_store = TeamBindingStore(tmp_path / "teams" / "bindings.json")
    binding_store.create(team_name="research_team", template_id="default")
    binding_store.bind_session(team_name="research_team", session_id="sess-keep")
    binding_store.bind_session(team_name="research_team", session_id="sess-team-1")
    delete_calls = []
    cleared_metadata_cache = []

    class TeamManagerStub:
        async def delete_session_runtime(
            self,
            session_id: str,
            reason: str = "",
            *,
            sessions_root=None,
        ) -> bool:
            delete_calls.append(
                {
                    "session_id": session_id,
                    "reason": reason,
                    "sessions_root": sessions_root,
                }
            )
            return True

    async def fake_ensure_persistent_checkpointer():
        return None

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    patch_shared_name(monkeypatch, "get_agent_sessions_dir", lambda: sessions_root)
    patch_shared_name(
        monkeypatch,
        "_sessions_dir_for_request",
        lambda _request: sessions_root,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.session.session_metadata.get_session_metadata",
        lambda _session_id, **_kwargs: {
            "mode": "code.team",
            "team_name": "research_team",
            "channel_id": "web",
        },
    )
    monkeypatch.setattr(
        interface_deep_module,
        "ensure_persistent_checkpointer",
        fake_ensure_persistent_checkpointer,
    )
    monkeypatch.setattr(
        "jiuwenswarm.agents.harness.team.get_team_manager",
        lambda _channel_id=None: TeamManagerStub(),
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.team_binding_store.get_team_binding_store",
        lambda: binding_store,
    )
    patch_shared_name(
        monkeypatch,
        "remove_session_metadata_cache",
        lambda session_id, **_kwargs: cleared_metadata_cache.append(session_id),
    )

    request = AgentRequest(
        request_id="req-session-delete-team",
        channel_id="web",
        req_method=ReqMethod.SESSION_DELETE,
        params={"session_id": "sess-team-1"},
    )

    await server.handle_session_delete_for_test(fake_ws, request, asyncio.Lock())

    assert delete_calls == [
        {
            "session_id": "sess-team-1",
            "reason": "session.delete: ",
            "sessions_root": sessions_root,
        }
    ]
    assert cleared_metadata_cache == ["sess-team-1"]
    assert not session_dir.exists()
    binding = binding_store.get("research_team")
    assert binding is not None
    assert binding.session_ids == ("sess-keep",)
    assert binding.last_session_id == "sess-keep"
    assert fake_ws.sent == [
        {
            "response_id": "req-session-delete-team",
            "payload": {"session_id": "sess-team-1"},
            "ok": True,
        }
    ]


@pytest.mark.asyncio
async def test_handle_session_delete_rejects_when_checkpointer_unavailable(monkeypatch, tmp_path):
    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    sessions_root = tmp_path / "sessions"
    session_dir = sessions_root / "sess-team-1"
    session_dir.mkdir(parents=True)
    release_calls = []

    async def fake_ensure_persistent_checkpointer():
        raise RuntimeError("checkpoint unavailable")

    async def fake_release(session_id: str):
        release_calls.append(session_id)

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)
    patch_shared_name(monkeypatch, "get_agent_sessions_dir", lambda: sessions_root)
    patch_shared_name(
        monkeypatch,
        "_sessions_dir_for_request",
        lambda _request: sessions_root,
    )
    monkeypatch.setattr(
        interface_deep_module,
        "ensure_persistent_checkpointer",
        fake_ensure_persistent_checkpointer,
    )
    monkeypatch.setattr(
        "openjiuwen.core.runner.Runner.release",
        fake_release,
    )

    request = AgentRequest(
        request_id="req-session-delete-checkpoint",
        channel_id="web",
        req_method=ReqMethod.SESSION_DELETE,
        params={"session_id": "sess-team-1"},
    )

    await server.handle_session_delete_for_test(fake_ws, request, asyncio.Lock())

    assert release_calls == []
    assert session_dir.exists()
    assert fake_ws.sent == [
        {
            "response_id": "req-session-delete-checkpoint",
            "payload": {
                "error": "persistent checkpointer is unavailable",
                "code": "CHECKPOINT_UNAVAILABLE",
            },
            "ok": False,
        }
    ]


@pytest.mark.asyncio
async def test_find_team_session_ids_uses_metadata_team_name(monkeypatch, tmp_path):
    server = AgentWebSocketServerHarness()
    global_sessions_root = tmp_path / "global-sessions"
    sessions_root = tmp_path / "tenant-sessions"
    (global_sessions_root / "global_team_sess").mkdir(parents=True)
    (sessions_root / "team_sess_001").mkdir(parents=True)
    (sessions_root / "team_sess_002").mkdir(parents=True)
    (sessions_root / "agent_sess_003").mkdir(parents=True)

    metadata_map = {
        "team_sess_001": {"mode": "team", "team_name": "jiuwen_team"},
        "team_sess_002": {"mode": "team", "team_name": "other_team"},
        "agent_sess_003": {"mode": "agent.plan", "team_name": "jiuwen_team"},
    }

    patch_shared_name(monkeypatch, "get_agent_sessions_dir", lambda: FakeSessionsRoot())

    def fake_get_session_metadata(session_id, *, sessions_root=None):
        assert sessions_root == tmp_path / "tenant-sessions"
        return metadata_map.get(session_id, {})

    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.session.session_metadata.get_session_metadata",
        fake_get_session_metadata,
    )

    session_ids = await server.find_team_session_ids_for_test(
        "jiuwen_team",
        sessions_root=sessions_root,
    )

    assert session_ids == ["team_sess_001"]


@pytest.mark.asyncio
async def test_handle_acp_tool_response_completes_pending_future(monkeypatch):
    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()
    mgr = get_acp_output_manager()
    future: asyncio.Future[dict] = asyncio.get_running_loop().create_future()
    mgr.add_pending_request(AcpOutputRequest(
        jsonrpc_id="42",
        method="fs/read_text_file",
        params={"path": "workspace/demo.txt"},
        future=future,
        request_id="req-pending",
    ))

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)

    request = AgentRequest(
        request_id="req-acp-tool-response",
        channel_id="acp",
        req_method=ReqMethod.ACP_TOOL_RESPONSE,
        params={
            "jsonrpc_id": "42",
            "response": {
                "jsonrpc": "2.0",
                "id": "42",
                "result": {"content": "hello"},
            },
        },
    )

    await server.handle_acp_tool_response_for_test(fake_ws, request, asyncio.Lock())

    assert future.done() is True
    assert future.result() == {
        "jsonrpc": "2.0",
        "id": "42",
        "result": {"content": "hello"},
    }
    assert fake_ws.sent == [
        {
            "response_id": "req-acp-tool-response",
            "payload": {"accepted": True},
            "ok": True,
        }
    ]


@pytest.mark.asyncio
async def test_handle_acp_tool_response_unknown_id_is_soft_ignored(monkeypatch):
    server = AgentWebSocketServerHarness()
    fake_ws = FakeWebSocket()

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)

    request = AgentRequest(
        request_id="req-acp-tool-response-unknown",
        channel_id="acp",
        req_method=ReqMethod.ACP_TOOL_RESPONSE,
        params={
            "jsonrpc_id": "unknown-42",
            "response": {
                "jsonrpc": "2.0",
                "id": "unknown-42",
                "result": {"content": "late"},
            },
        },
    )

    await server.handle_acp_tool_response_for_test(fake_ws, request, asyncio.Lock())

    assert fake_ws.sent == [
        {
            "response_id": "req-acp-tool-response-unknown",
            "payload": {
                "accepted": False,
                "ignored": True,
                "reason": "unknown_or_late_response",
                "jsonrpc_id": "unknown-42",
            },
            "ok": True,
        }
    ]


@pytest.mark.asyncio
async def test_handle_message_uses_ws_scoped_acp_client_capabilities(monkeypatch):
    ws_a = FakeWebSocket()
    ws_b = FakeWebSocket()
    server = AgentWebSocketServerHarness()
    fake_manager = FakeAgentManager(
        capabilities=ACP_DEFAULT_CAPABILITIES,
        client_capabilities={"fs": {"readTextFile": True}},
    )
    server.set_agent_manager_for_test(fake_manager)

    patch_shared_name(monkeypatch, "encode_agent_response_for_wire", fake_encode_agent_response_for_wire)

    init_request_a = AgentRequest(
        request_id="req-init-a",
        channel_id="acp",
        req_method=ReqMethod.INITIALIZE,
        params={"clientCapabilities": {"fs": {"readTextFile": True}}},
    )
    init_request_b = AgentRequest(
        request_id="req-init-b",
        channel_id="acp",
        req_method=ReqMethod.INITIALIZE,
        params={"clientCapabilities": {"terminal": {"create": True}}},
    )
    await server.handle_initialize_for_test(ws_a, init_request_a, asyncio.Lock())
    await server.handle_initialize_for_test(ws_b, init_request_b, asyncio.Lock())

    captured = {}

    # session.create 已并入分发表并外迁为自由函数,server 上不再有该方法。
    # 因此改为替换**表项**;键也从 id(ws) 换成 ctx.connection_id(即 str(id(ws))),
    from jiuwenswarm.server.dispatch import HANDLERS, HandlerSpec

    async def fake_handle_session_create(ctx):
        captured[ctx.connection_id] = dict(ctx.request.metadata or {})

    monkeypatch.setitem(
        HANDLERS, ReqMethod.SESSION_CREATE, HandlerSpec(fn=fake_handle_session_create)
    )

    env = e2a_from_agent_fields(
        request_id="req-session-create",
        channel_id="acp",
        session_id="sess-b",
        req_method=ReqMethod.SESSION_CREATE,
        params={"session_id": "sess-b"},
        is_stream=False,
        timestamp=0.0,
    )
    await server.handle_message_for_test(ws_b, json.dumps(env.to_dict(), ensure_ascii=False), asyncio.Lock())

    assert captured[str(id(ws_b))]["acp_client_capabilities"] == {"terminal": {"create": True}}


@pytest.mark.asyncio
async def test_wait_for_terminal_exit_returns_soft_timeout(monkeypatch):
    mgr = get_acp_output_manager()
    captured: dict[str, object] = {}

    async def _fake_send_jsonrpc_request(
        method,
        params,
        *,
        channel_id="acp",
        session_id=None,
        timeout=0.0,
    ):
        captured["method"] = method
        captured["params"] = params
        captured["channel_id"] = channel_id
        captured["session_id"] = session_id
        captured["timeout"] = timeout
        raise asyncio.TimeoutError

    monkeypatch.setattr(mgr, "send_jsonrpc_request", _fake_send_jsonrpc_request)
    monkeypatch.setattr(acp_output_tools, "_ACP_WAIT_FOR_EXIT_TIMEOUT_SECONDS", 123.0)

    result = await acp_output_tools.wait_for_terminal_exit("term-soft-timeout", session_id="sess-soft")

    assert captured == {
        "method": "terminal/wait_for_exit",
        "params": {"terminalId": "term-soft-timeout"},
        "channel_id": "acp",
        "session_id": "sess-soft",
        "timeout": 123.0,
    }
    assert result == {
        "exitCode": None,
        "signal": None,
        "timedOut": True,
        "running": True,
        "shouldRetry": True,
    }


@pytest.mark.asyncio
async def test_wait_for_terminal_exit_completed_result_sets_should_retry_false(monkeypatch):
    mgr = get_acp_output_manager()

    async def _fake_send_jsonrpc_request(
        method,
        params,
        *,
        channel_id="acp",
        session_id=None,
        timeout=0.0,
    ):
        return {
            "jsonrpc": "2.0",
            "id": "ok-1",
            "result": {"exitCode": 0, "signal": None},
        }

    monkeypatch.setattr(mgr, "send_jsonrpc_request", _fake_send_jsonrpc_request)

    result = await acp_output_tools.wait_for_terminal_exit("term-done", session_id="sess-done")

    assert result == {
        "exitCode": 0,
        "signal": None,
        "timedOut": False,
        "running": False,
        "shouldRetry": False,
    }


def test_build_context_processor_rail_uses_summary_offloader_config(monkeypatch):
    from jiuwenswarm.server.runtime.agent_adapter.deep import context_assembly

    monkeypatch.setattr(
        context_assembly,
        "ContextProcessorRail",
        FakeContextProcessorRail,
    )
    adapter = DeepAdapterHarness()

    rail = adapter.build_context_processor_rail_for_test(
        {
            "context_engine_config": {
                "message_summary_offloader_config": {
                    "tokens_threshold": 5000,
                    "keep_last_round": False,
                },
                "dialogue_compressor_config": {"tokens_threshold": 100000},
            }
        }
    )

    assert isinstance(rail, FakeContextProcessorRail)
    assert rail.preset is True
    assert rail.processors == [
        (
            "MessageSummaryOffloader",
            {
                "tokens_threshold": 5000,
                "keep_last_round": False,
            },
        ),
        ("DialogueCompressor", {"tokens_threshold": 100000}),
    ]


def test_build_context_processor_rail_prefers_summary_offloader_config(monkeypatch):
    from jiuwenswarm.server.runtime.agent_adapter.deep import context_assembly

    monkeypatch.setattr(
        context_assembly,
        "ContextProcessorRail",
        FakeContextProcessorRail,
    )
    adapter = DeepAdapterHarness()

    rail = adapter.build_context_processor_rail_for_test(
        {
            "context_engine_config": {
                "message_summary_offloader_config": {
                    "tokens_threshold": 6000,
                },
                "message_offloader_config": {
                    "tokens_threshold": 5000,
                },
            }
        }
    )

    assert isinstance(rail, FakeContextProcessorRail)
    assert rail.processors == [
        ("MessageSummaryOffloader", {"tokens_threshold": 6000}),
    ]


def test_build_context_processor_rail_passes_session_memory_config(monkeypatch):
    from jiuwenswarm.server.runtime.agent_adapter.deep import context_assembly

    monkeypatch.setattr(
        context_assembly,
        "ContextProcessorRail",
        FakeContextProcessorRail,
    )
    adapter = DeepAdapterHarness()

    rail = adapter.build_context_processor_rail_for_test(
        {
            "context_engine_config": {
                "session_memory_config": {
                    "trigger_tokens": 12000,
                    "update_mode": "direct_replace",
                },
            }
        }
    )

    assert isinstance(rail, FakeContextProcessorRail)
    assert rail.preset is True
    assert rail.processors is None
    assert rail.session_memory == {
        "trigger_tokens": 12000,
        "update_mode": "direct_replace",
    }


def test_build_context_assemble_rail_returns_context_assemble_rail_instance(monkeypatch):
    from jiuwenswarm.server.runtime.agent_adapter.deep import context_assembly

    monkeypatch.setattr(
        context_assembly,
        "ContextAssembleRail",
        FakeContextAssembleRail,
    )
    adapter = DeepAdapterHarness()

    rail = adapter.build_context_assemble_rail_for_test()

    assert isinstance(rail, FakeContextAssembleRail)


@pytest.mark.parametrize(
    "parser",
    [
        parse_stream_chunk,
        interface_deep_module._parse_stream_chunk,
    ],
    ids=["shared", "deep-adapter"],
)
def test_parse_stream_chunk_emits_empty_final_marker_after_streamed_content(parser):
    chunk = types.SimpleNamespace(
        type="answer",
        payload={
            "output": {
                "output": "final answer",
                "chunked": False,
            }
        },
    )

    if parser is interface_deep_module._parse_stream_chunk:
        # Deep adapter needs the already-streamed text to decide trailer-only
        # vs drain-rescue when has_streamed was set by tiny/blank deltas.
        parsed = parser(
            chunk,
            _has_streamed_content=True,
            _streamed_text="final answer",
        )
    else:
        parsed = parser(chunk, _has_streamed_content=True)

    assert parsed == {"event_type": "chat.final", "content": ""}


def test_deep_parse_keeps_final_body_when_stream_flag_lacks_visible_text():
    """False has_streamed (no visible segment text) must keep answer for drain."""
    chunk = types.SimpleNamespace(
        type="answer",
        payload={
            "output": {
                "output": "final answer",
                "chunked": False,
            }
        },
    )
    parsed = interface_deep_module._parse_stream_chunk(
        chunk,
        _has_streamed_content=True,
        _streamed_text="",
    )
    assert parsed == {"event_type": "chat.final", "content": "final answer"}


def test_parse_stream_chunk_maps_toolcall_progress_to_processing_status():
    """llm_toolcall_progress heartbeat (agent-core) → chat.processing_status
    business frame (relay watchdog counts it; frontend shows 'thinking' silently)."""
    from jiuwenswarm.server.utils.stream_utils import parse_stream_chunk

    class _Chunk:
        type = "llm_toolcall_progress"
        payload = {"elapsed_s": 15.3, "chunk_count": 42, "result_type": "answer"}

    parsed = parse_stream_chunk(_Chunk())

    assert parsed == {
        "event_type": "chat.processing_status",
        "is_processing": True,
        "current_task": "thinking",
    }
    # critical: no is_complete field → relay must NOT treat as close-flow signal
    assert "is_complete" not in parsed
    # payload diagnostics are intentionally dropped (heartbeat is a pure signal)
    assert "elapsed_s" not in parsed