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
196 KB
Raw Blame
# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.

"""Unit tests for team evolution monitor helpers."""

from __future__ import annotations

import asyncio
import json
from pathlib import Path
from types import SimpleNamespace
from typing import Any

import pytest
from openjiuwen.agent_teams.schema.team import TeamRole

from jiuwenswarm.server.runtime.agent_adapter import evolution_helpers
from jiuwenswarm.server.runtime.agent_adapter import team_helpers


def test_persist_team_history_event_keeps_human_spawn_details(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    persisted: list[dict[str, Any]] = []
    monkeypatch.setattr(
        team_helpers,
        "append_history_record",
        lambda **kwargs: persisted.append(kwargs),
    )

    team_helpers._persist_team_history_event(
        "web",
        "sess_werewolf",
        {
            "event_type": "team.member",
            "event": {
                "type": "team.member.spawned",
                "team_id": "werewolf",
                "member_id": "villager-human",
                "name": "人类玩家",
                "mode": "human",
                "status": "idle",
            },
        },
    )

    assert len(persisted) == 1
    assert persisted[0]["event_type"] == "team.member"
    assert persisted[0]["mode"] == "team"
    assert persisted[0]["extra"] == {
        "session_id": "sess_werewolf",
        "event": {
            "type": "team.member.spawned",
            "team_id": "werewolf",
            "member_id": "villager-human",
            "name": "人类玩家",
            "mode": "human",
            "status": "idle",
        },
    }


class _InactiveTeamRuntimeManagerMixin:
    """Provide the session-scoped runtime state API for inactive test managers."""

    def __init__(self) -> None:
        self._seen_team_events: dict[str, bool] = {}
        self._workflow_completed: dict[str, bool] = {}
        self._round_complete_emitted: dict[str, bool] = {}

    @staticmethod
    def owns_stream_task(session_id: str, task: asyncio.Task | None) -> bool:
        return True

    @staticmethod
    def get_session_runtime_epoch(session_id: str) -> int:
        return 0

    def mark_seen_team_events(self, session_id: str) -> None:
        self._seen_team_events[session_id] = True

    def has_seen_team_events(self, session_id: str) -> bool:
        return self._seen_team_events.get(session_id, False)

    def reset_seen_team_events(self, session_id: str) -> None:
        self._seen_team_events.pop(session_id, None)

    def claim_round_complete(self, session_id: str) -> bool:
        # Inactive runtime must never authorize a completion broadcast.
        return False

    def reset_round_complete(self, session_id: str) -> None:
        self._round_complete_emitted.pop(session_id, None)

    def mark_workflow_completed(self, session_id: str) -> None:
        self._workflow_completed[session_id] = True

    def is_workflow_completed(self, session_id: str) -> bool:
        return self._workflow_completed.get(session_id, False)

    def reset_workflow_completed(self, session_id: str) -> None:
        self._workflow_completed.pop(session_id, None)

    @staticmethod
    def get_session_terminal_state(session_id: str) -> str | None:
        # Inactive runtime was never interrupted: no terminal state recorded.
        return None

    @staticmethod
    def is_runtime_active(session_id: str) -> bool:
        _ = session_id
        return False

    @staticmethod
    def is_runtime_pending(session_id: str) -> bool:
        _ = session_id
        return False

    @staticmethod
    def has_waiters(session_id: str) -> bool:
        return False

    @staticmethod
    def get_waiters(session_id: str) -> list[tuple[str, asyncio.Queue]]:
        return []

    @staticmethod
    def add_waiter(session_id: str, request_id: str, queue: asyncio.Queue) -> None:
        pass

    @staticmethod
    def remove_waiter(session_id: str, request_id: str) -> None:
        pass

    @staticmethod
    def broadcast_event(session_id: str, event: dict) -> None:
        pass

    @staticmethod
    def is_session_initialized(session_id: str) -> bool:
        return False

    @staticmethod
    def clear_session_initialized(session_id: str) -> None:
        pass

    @staticmethod
    def setdefault_cron_completion(session_id: str, default: dict) -> dict:
        return default

    @staticmethod
    def pop_cron_completion(session_id: str) -> dict | None:
        return None

    @staticmethod
    def get_cron_completion(session_id: str) -> dict | None:
        return None

    @staticmethod
    def get_team_evolution_watcher(session_id: str) -> asyncio.Task | None:
        return None

    @staticmethod
    def get_team_skill_rail(session_id: str):
        return None

    @staticmethod
    def get_monitor(session_id: str):
        return None

    @staticmethod
    def register_monitor(session_id: str, handler) -> None:
        pass

    @staticmethod
    def get_workflow_handler(session_id: str):
        return None

    @staticmethod
    def pop_workflow_handler(session_id: str):
        return None

    @staticmethod
    def register_workflow_handler(session_id: str, handler) -> None:
        pass

    @staticmethod
    def has_stream_task(session_id: str) -> bool:
        return False

    @staticmethod
    def commit_runtime_ready(session_id: str, team_name: str) -> None:
        pass

    @staticmethod
    async def attach_distributed_hooks_for_runner_runtime(session_id: str, *args, **kwargs) -> None:
        pass

    @staticmethod
    def register_team_evolution_watcher(session_id: str, task) -> None:
        pass

    @staticmethod
    def pop_team_evolution_watcher(session_id: str):
        return None

    @staticmethod
    def pop_stream_task(session_id: str) -> asyncio.Task | None:
        return None


class _CompletingFollowupRuntimeManagerMixin(_InactiveTeamRuntimeManagerMixin):
    """Finish follow-up waiters immediately in input-routing tests."""

    @staticmethod
    def add_waiter(session_id: str, request_id: str, queue: asyncio.Queue) -> None:
        queue.put_nowait({"event_type": "team.completed"})


class _FakeTransport:
    pushes: list[dict] = []

    def __init__(self):
        self.pushes = self.__class__.pushes

    async def send_push(self, payload: dict) -> None:
        self.pushes.append(payload)


class _FakeRail:
    def __init__(self, batches: list[list[object]], *, pending_first: bool = True):
        self._batches = list(batches)
        self._pending_first = pending_first
        self._drain_calls = 0
        self.drain_waits: list[bool] = []
        self.review_trigger = False

    async def drain_pending_approval_events(self, wait: bool = False, timeout: float | None = None):
        self._drain_calls += 1
        self.drain_waits.append(wait)
        if self._batches:
            return self._batches.pop(0)
        return []


class _FakeProgressOnlyRail(_FakeRail):
    def __init__(self):
        super().__init__(
            [
                [
                    SimpleNamespace(
                        type="llm_reasoning",
                        payload={
                            "request_id": "team_skill_evolve_timeout",
                            "content": "[Team Skill Evolution] progress",
                        },
                    )
                ],
            ],
            pending_first=False,
        )
        self.cleanup_calls = 0

    async def cleanup_background_tasks(self) -> None:
        self.cleanup_calls += 1


class _TeamHelpersTestApi:
    @staticmethod
    async def watch_team_evolution_and_push(
            channel_id: str | None,
            session_id: str,
            rail: object,
    ) -> None:
        watcher = getattr(team_helpers, "_watch_team_evolution_and_push")
        await watcher(channel_id, session_id, rail)

    @staticmethod
    def ensure_team_evolution_watcher(
            channel_id: str | None,
            session_id: str,
            *,
            source: str = "unknown",
    ) -> None:
        ensure_watcher = getattr(team_helpers, "ensure_team_evolution_watcher")
        ensure_watcher(channel_id, session_id, source=source)

    @staticmethod
    async def handle_team_slash_command(
            channel_id: str | None,
            session_id: str,
            query: str,
            **kwargs,
    ) -> dict[str, object] | None:
        handler = getattr(team_helpers, "_handle_team_slash_command")
        return await handler(channel_id, session_id, query, **kwargs)

    @staticmethod
    async def consume_stream_with_query(
            channel_id: str | None,
            session_id: str,
            spec: object,
            query: str,
            **kwargs,
    ) -> None:
        consumer = getattr(team_helpers, "_consume_stream_with_query")
        kwargs.setdefault("round_id", 1)
        await consumer(channel_id, session_id, spec, query, **kwargs)

    @staticmethod
    async def team_round_settled(channel_id: str | None, session_id: str) -> bool:
        predicate = getattr(team_helpers, "_team_round_settled")
        return await predicate(channel_id, session_id)

    @staticmethod
    async def consume_monitor_events(
            channel_id: str | None,
            session_id: str,
            monitor_handler: object,
    ) -> None:
        consumer = getattr(team_helpers, "_consume_monitor_events")
        await consumer(channel_id, session_id, monitor_handler)

    @staticmethod
    def extract_query_directives(query: str) -> tuple[str, bool, bool]:
        fn = getattr(team_helpers, "_extract_query_directives")
        return fn(query)

    @staticmethod
    async def consume_workflow_events(
            channel_id: str | None,
            session_id: str,
            workflow_handler: object,
    ) -> None:
        consumer = getattr(team_helpers, "_consume_workflow_events")
        await consumer(channel_id, session_id, workflow_handler)

    @staticmethod
    def seed_cron_team_waiter(
            waiter_key: tuple[str, str],
            request_id: str,
    ) -> None:
        """Seed a cron waiter on the shared _CronFakeManager.

        waiter_key is (channel_id, session_id); the waiter is registered by
        session_id (matching production TeamManager.get_waiters).
        """
        _channel_id, session_id = waiter_key
        _CronFakeManager._waiters[session_id] = [(request_id, asyncio.Queue())]
        _CronFakeManager._completion.clear()

    @staticmethod
    def try_finish_cron_team_stream(
            channel_id: str | None,
            session_id: str,
            event: dict[str, object],
    ) -> None:
        fn = getattr(team_helpers, "_try_finish_cron_team_stream")
        fn(channel_id, session_id, event)

    @staticmethod
    def clear_cron_team_waiter(waiter_key: tuple[str, str]) -> None:
        _channel_id, session_id = waiter_key
        _CronFakeManager._waiters.pop(session_id, None)
        _CronFakeManager._completion.pop(session_id, None)


class _CronFakeManager(_InactiveTeamRuntimeManagerMixin):
    """Fake TeamManager with waiter + completion state for cron team stream tests."""

    _waiters: dict[str, list[tuple[str, asyncio.Queue]]] = {}
    _completion: dict[str, dict] = {}
    _stream_tasks: dict[str, asyncio.Task] = {}

    @classmethod
    def reset(cls) -> None:
        cls._waiters.clear()
        cls._completion.clear()
        cls._stream_tasks.clear()

    @classmethod
    def get_waiters(cls, session_id: str) -> list[tuple[str, asyncio.Queue]]:
        return cls._waiters.get(session_id, [])

    @classmethod
    def setdefault_cron_completion(cls, session_id: str, default: dict) -> dict:
        return cls._completion.setdefault(session_id, default)

    @classmethod
    def pop_cron_completion(cls, session_id: str) -> dict | None:
        return cls._completion.pop(session_id, None)

    @classmethod
    def get_cron_completion(cls, session_id: str) -> dict | None:
        return cls._completion.get(session_id)

    @classmethod
    def pop_stream_task(cls, session_id: str) -> asyncio.Task | None:
        return cls._stream_tasks.pop(session_id, None)


def _write_team_skill(tmp_path, name: str, *, records: list[dict] | None = None) -> str:
    skills_dir = tmp_path / "team-workspace" / "skills"
    skill_dir = skills_dir / name
    skill_dir.mkdir(parents=True)
    skill_dir.joinpath("SKILL.md").write_text(
        "---\n"
        f"name: {name}\n"
        "kind: swarm-skill\n"
        "---\n"
        f"# {name}\n",
        encoding="utf-8",
    )
    skill_dir.joinpath("evolutions.json").write_text(
        json.dumps(
            {
                "skill_id": name,
                "version": "1.0.0",
                "updated_at": "2026-06-11T00:00:00Z",
                "entries": records or [],
            },
            ensure_ascii=False,
        ),
        encoding="utf-8",
    )
    return str(skills_dir)


def _write_regular_skill(tmp_path, name: str, *, records: list[dict] | None = None) -> str:
    skills_dir = tmp_path / "team-workspace" / "skills"
    skill_dir = skills_dir / name
    skill_dir.mkdir(parents=True)
    skill_dir.joinpath("SKILL.md").write_text(f"# {name}\n", encoding="utf-8")
    skill_dir.joinpath("evolutions.json").write_text(
        json.dumps(
            {
                "skill_id": name,
                "version": "1.0.0",
                "updated_at": "2026-06-11T00:00:00Z",
                "entries": records or [],
            },
            ensure_ascii=False,
        ),
        encoding="utf-8",
    )
    return str(skills_dir)


def _evolution_record(content: str, *, score: float = 1.0) -> dict:
    return {
        "id": "ev_test",
        "source": "user_correction",
        "timestamp": "2026-06-11T00:00:00Z",
        "context": "test",
        "change": {
            "section": "Instructions",
            "action": "append",
            "content": content,
            "target": "body",
        },
        "applied": False,
        "score": score,
        "usage_stats": {
            "times_presented": 0,
            "times_used": 0,
            "times_positive": 0,
            "times_negative": 0,
        },
        "summary": content,
    }


@pytest.mark.anyio
async def test_team_evolution_monitor_pushes_status_with_real_request_id(monkeypatch):
    _FakeTransport.pushes = []
    approval_event = SimpleNamespace(
        type="chat.ask_user_question",
        payload={"request_id": "team_skill_evolve_req1", "questions": [{"header": "x"}]},
    )
    reasoning_event = SimpleNamespace(
        type="llm_reasoning",
        payload={"content": "[Team Skill Evolution] started"},
    )
    rail = _FakeRail([[reasoning_event, approval_event]], pending_first=False)

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(
        team_helpers,
        "parse_stream_chunk",
        lambda evt: {"event_type": "chat.reasoning", "content": evt.payload.get("content", "")},
    )

    task = asyncio.create_task(
        _TeamHelpersTestApi.watch_team_evolution_and_push("web", "sess-1", rail)
    )
    await asyncio.sleep(0.05)
    task.cancel()
    with pytest.raises(asyncio.CancelledError):
        await task

    event_types = [push["payload"]["event_type"] for push in _FakeTransport.pushes]
    assert event_types == [
        "chat.evolution_status",
        "chat.ask_user_question",
        "chat.evolution_status",
    ]
    assert _FakeTransport.pushes[0]["request_id"] == "team_skill_evolve_req1"
    assert _FakeTransport.pushes[0]["payload"]["request_id"] == "team_skill_evolve_req1"
    assert _FakeTransport.pushes[2]["payload"]["status"] == "end"
    assert _FakeTransport.pushes[2]["payload"]["stage"] == "approval_required"
    assert rail.drain_waits
    assert set(rail.drain_waits) == {False}


@pytest.mark.anyio
async def test_team_evolution_monitor_waits_for_real_request_id(monkeypatch):
    _FakeTransport.pushes = []
    reasoning_event = SimpleNamespace(
        type="llm_reasoning",
        payload={"content": "[Team Skill Evolution] started"},
    )
    approval_event = SimpleNamespace(
        type="chat.ask_user_question",
        payload={"request_id": "team_skill_evolve_real", "questions": [{"header": "x"}]},
    )
    rail = _FakeRail([[reasoning_event], [approval_event]], pending_first=False)

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(
        team_helpers,
        "parse_stream_chunk",
        lambda evt: {"event_type": "chat.reasoning", "content": evt.payload.get("content", "")},
    )

    task = asyncio.create_task(
        _TeamHelpersTestApi.watch_team_evolution_and_push("web", "sess-1", rail)
    )
    await asyncio.sleep(0.05)
    task.cancel()
    with pytest.raises(asyncio.CancelledError):
        await task

    status_pushes = [
        push for push in _FakeTransport.pushes
        if push["payload"]["event_type"] == "chat.evolution_status"
    ]
    assert [push["payload"]["status"] for push in status_pushes] == ["start", "end"]
    assert [push["request_id"] for push in status_pushes] == [
        "team_skill_evolve_real",
        "team_skill_evolve_real",
    ]


@pytest.mark.anyio
async def test_team_evolution_monitor_starts_cycle_for_started_progress_without_request_id(
        monkeypatch,
):
    _FakeTransport.pushes = []
    progress_event = SimpleNamespace(
        type="llm_reasoning",
        payload={
            "_evolution_meta": {"event_kind": "progress", "stage": "started"},
            "content": "[Team Skill Evolution] started",
        },
    )
    outcome_event = SimpleNamespace(
        type="llm_reasoning",
        payload={
            "_evolution_meta": {"event_kind": "outcome", "status": "failed"},
            "content": "failed before approval",
        },
    )
    rail = _FakeRail([[progress_event], [outcome_event]], pending_first=False)

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(team_helpers, "parse_stream_chunk", lambda evt: None)

    task = asyncio.create_task(
        _TeamHelpersTestApi.watch_team_evolution_and_push("web", "sess-progress", rail)
    )
    await asyncio.sleep(0.05)
    task.cancel()
    with pytest.raises(asyncio.CancelledError):
        await task

    status_pushes = [
        push for push in _FakeTransport.pushes
        if push["payload"]["event_type"] == "chat.evolution_status"
    ]
    assert status_pushes == []


@pytest.mark.anyio
async def test_team_evolution_monitor_maps_sdk_progress_stages(monkeypatch):
    _FakeTransport.pushes = []
    detecting_event = SimpleNamespace(
        type="llm_reasoning",
        payload={
            "_evolution_meta": {
                "event_kind": "progress",
                "stage": "detecting_signals",
                "request_id": "team_skill_evolve_stages",
            },
            "request_id": "team_skill_evolve_stages",
            "content": "[Team Skill Evolution] detecting",
        },
    )
    generating_event = SimpleNamespace(
        type="llm_reasoning",
        payload={
            "_evolution_meta": {
                "event_kind": "progress",
                "stage": "generating_updates",
                "request_id": "team_skill_evolve_stages",
            },
            "request_id": "team_skill_evolve_stages",
            "content": "[Team Skill Evolution] generating",
        },
    )
    outcome_event = SimpleNamespace(
        type="llm_reasoning",
        payload={
            "_evolution_meta": {"event_kind": "outcome", "status": "completed"},
            "request_id": "team_skill_evolve_stages",
            "content": "done",
        },
    )
    rail = _FakeRail([[detecting_event], [generating_event], [outcome_event]], pending_first=False)

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(team_helpers, "parse_stream_chunk", lambda evt: None)

    task = asyncio.create_task(
        _TeamHelpersTestApi.watch_team_evolution_and_push("web", "sess-stages", rail)
    )
    await asyncio.sleep(0.05)
    task.cancel()
    with pytest.raises(asyncio.CancelledError):
        await task

    status_pushes = [
        push for push in _FakeTransport.pushes
        if push["payload"]["event_type"] == "chat.evolution_status"
    ]
    assert [push["payload"]["status"] for push in status_pushes] == [
        "start",
        "end",
    ]
    assert [push["payload"]["stage"] for push in status_pushes] == [
        "generating",
        "completed",
    ]
    assert {push["request_id"] for push in status_pushes} == {"team_skill_evolve_stages"}


@pytest.mark.anyio
async def test_team_evolution_monitor_uses_meta_request_id_and_ends_on_cancelled(monkeypatch):
    _FakeTransport.pushes = []
    detecting_event = SimpleNamespace(
        type="llm_reasoning",
        payload={
            "_evolution_meta": {
                "event_kind": "progress",
                "stage": "detecting_signals",
                "request_id": "team_skill_evolve_meta",
            },
            "content": "[Team Skill Evolution] detecting",
        },
    )
    generating_event = SimpleNamespace(
        type="llm_reasoning",
        payload={
            "_evolution_meta": {
                "event_kind": "progress",
                "stage": "generating_updates",
                "request_id": "team_skill_evolve_meta",
            },
            "content": "[Team Skill Evolution] generating",
        },
    )
    cancelled_event = SimpleNamespace(
        type="llm_reasoning",
        payload={
            "_evolution_meta": {
                "event_kind": "progress",
                "stage": "cancelled",
                "request_id": "team_skill_evolve_meta",
            },
            "content": "no actionable evolution signals detected",
        },
    )
    rail = _FakeRail(
        [[detecting_event], [generating_event], [cancelled_event]],
        pending_first=False,
    )

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(team_helpers, "parse_stream_chunk", lambda evt: None)

    task = asyncio.create_task(
        _TeamHelpersTestApi.watch_team_evolution_and_push("web", "sess-meta", rail)
    )
    await asyncio.sleep(0.05)
    task.cancel()
    with pytest.raises(asyncio.CancelledError):
        await task

    status_pushes = [
        push for push in _FakeTransport.pushes
        if push["payload"]["event_type"] == "chat.evolution_status"
    ]
    assert [push["payload"]["status"] for push in status_pushes] == [
        "start",
        "end",
    ]
    assert [push["payload"]["stage"] for push in status_pushes] == [
        "generating",
        "hidden",
    ]
    assert {push["request_id"] for push in status_pushes} == {"team_skill_evolve_meta"}


@pytest.mark.anyio
async def test_team_evolution_monitor_filters_progress_by_request_id(monkeypatch):
    _FakeTransport.pushes = []
    request_a_detecting = SimpleNamespace(
        type="llm_reasoning",
        payload={
            "_evolution_meta": {
                "event_kind": "progress",
                "stage": "detecting_signals",
                "request_id": "team_skill_evolve_a",
            },
            "content": "[Team Skill Evolution] detecting A",
        },
    )
    request_b_generating = SimpleNamespace(
        type="llm_reasoning",
        payload={
            "_evolution_meta": {
                "event_kind": "progress",
                "stage": "generating_updates",
                "request_id": "team_skill_evolve_b",
            },
            "content": "[Team Skill Evolution] generating B",
        },
    )
    request_a_generating = SimpleNamespace(
        type="llm_reasoning",
        payload={
            "_evolution_meta": {
                "event_kind": "progress",
                "stage": "generating_updates",
                "request_id": "team_skill_evolve_a",
            },
            "content": "[Team Skill Evolution] generating A",
        },
    )
    request_a_completed = SimpleNamespace(
        type="llm_reasoning",
        payload={
            "_evolution_meta": {
                "event_kind": "progress",
                "stage": "completed",
                "request_id": "team_skill_evolve_a",
            },
            "content": "done A",
        },
    )
    rail = _FakeRail(
        [[request_a_detecting], [request_a_generating, request_b_generating], [request_a_completed]],
        pending_first=False,
    )

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(team_helpers, "parse_stream_chunk", lambda evt: None)

    task = asyncio.create_task(
        _TeamHelpersTestApi.watch_team_evolution_and_push("web", "sess-filter", rail)
    )
    await asyncio.sleep(0.05)
    task.cancel()
    with pytest.raises(asyncio.CancelledError):
        await task

    status_pushes = [
        push for push in _FakeTransport.pushes
        if push["payload"]["event_type"] == "chat.evolution_status"
    ]
    assert [(push["request_id"], push["payload"]["status"], push["payload"]["stage"]) for push in status_pushes] == [
        ("team_skill_evolve_a", "start", "generating"),
        ("team_skill_evolve_a", "end", "completed"),
    ]
    assert all("generating B" not in push["payload"].get("message", "") for push in status_pushes)


@pytest.mark.anyio
async def test_team_evolution_monitor_uses_delivery_context_metadata(monkeypatch):
    _FakeTransport.pushes = []
    approval_event = SimpleNamespace(
        type="chat.ask_user_question",
        payload={"request_id": "team_skill_evolve_meta", "questions": [{"header": "x"}]},
    )
    rail = _FakeRail([[approval_event]], pending_first=False)
    recorded_calls: list[dict] = []

    def _fake_build_server_push_message(**kwargs):
        recorded_calls.append(dict(kwargs))
        message = dict(kwargs)
        message["channel_id"] = kwargs["fallback_channel_id"]
        message["metadata"] = {"route": "from-delivery-context"}
        return message

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(
        team_helpers,
        "build_server_push_message",
        _fake_build_server_push_message,
    )
    monkeypatch.setattr(team_helpers, "parse_stream_chunk", lambda evt: None)

    task = asyncio.create_task(
        _TeamHelpersTestApi.watch_team_evolution_and_push("web", "sess-meta", rail)
    )
    await asyncio.sleep(0.05)
    task.cancel()
    with pytest.raises(asyncio.CancelledError):
        await task

    assert recorded_calls
    assert all(call["session_id"] == "sess-meta" for call in recorded_calls)
    assert all(call["fallback_channel_id"] == "web" for call in recorded_calls)
    assert _FakeTransport.pushes
    assert all(push["metadata"] == {"route": "from-delivery-context"} for push in _FakeTransport.pushes)


@pytest.mark.anyio
@pytest.mark.parametrize(
    ("status", "expected_stage"),
    [
        ("completed", "completed"),
        ("failed", "hidden"),
        ("timed_out", "hidden"),
    ],
)
async def test_team_evolution_monitor_reads_terminal_outcome_from_host_events(
        monkeypatch,
        status: str,
        expected_stage: str,
):
    _FakeTransport.pushes = []
    outcome_event = SimpleNamespace(
        type="chat.evolution_status",
        payload={
            "_evolution_meta": {"event_kind": "outcome", "status": status},
            "request_id": "team_skill_evolve_outcome",
            "content": status,
        },
    )
    rail = _FakeRail([[outcome_event]], pending_first=True)

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(team_helpers, "parse_stream_chunk", lambda evt: None)

    task = asyncio.create_task(
        _TeamHelpersTestApi.watch_team_evolution_and_push("web", "sess-outcome", rail)
    )
    await asyncio.sleep(0.05)
    task.cancel()
    with pytest.raises(asyncio.CancelledError):
        await task

    status_pushes = [
        push for push in _FakeTransport.pushes
        if push["payload"]["event_type"] == "chat.evolution_status"
    ]
    assert [push["payload"]["status"] for push in status_pushes] == ["start", "end"]
    assert {push["request_id"] for push in status_pushes} == {"team_skill_evolve_outcome"}
    assert status_pushes[-1]["payload"]["stage"] == expected_stage
    assert status_pushes[-1]["payload"]["message"] == status


@pytest.mark.anyio
async def test_team_evolution_monitor_maps_noop_progress_to_no_evolution_generated(
        monkeypatch,
):
    _FakeTransport.pushes = []
    progress_event = SimpleNamespace(
        type="llm_reasoning",
        payload={
            "_evolution_meta": {"event_kind": "progress", "stage": "completed"},
            "content": "No evolution signals detected",
        },
    )
    rail = _FakeRail([[progress_event]], pending_first=False)

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(team_helpers, "parse_stream_chunk", lambda evt: None)

    task = asyncio.create_task(
        _TeamHelpersTestApi.watch_team_evolution_and_push("web", "sess-noop", rail)
    )
    await asyncio.sleep(0.05)
    task.cancel()
    with pytest.raises(asyncio.CancelledError):
        await task

    status_pushes = [
        push for push in _FakeTransport.pushes
        if push["payload"]["event_type"] == "chat.evolution_status"
    ]
    assert [push["payload"]["status"] for push in status_pushes] == ["start", "end"]
    assert status_pushes[-1]["payload"]["stage"] == "no_evolution_no_signal"


@pytest.mark.anyio
async def test_team_evolution_monitor_uses_approval_request_id_without_provisional_start(monkeypatch):
    _FakeTransport.pushes = []
    approval_event = SimpleNamespace(
        type="chat.ask_user_question",
        payload={"request_id": "team_skill_evolve_real", "questions": [{"header": "x"}]},
    )

    class _PendingThenApprovalRail:
        def __init__(self):
            self._drain_calls = 0
            self.review_trigger = False

        async def drain_pending_approval_events(self, wait: bool = False, timeout: float | None = None):
            assert wait is False
            self._drain_calls += 1
            if self._drain_calls == 1:
                return [approval_event]
            return []

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(team_helpers, "parse_stream_chunk", lambda evt: None)

    task = asyncio.create_task(
        _TeamHelpersTestApi.watch_team_evolution_and_push(
            "web",
            "sess-rebind",
            _PendingThenApprovalRail(),
        )
    )
    await asyncio.sleep(0.05)
    task.cancel()
    with pytest.raises(asyncio.CancelledError):
        await task

    status_starts = []
    approval_pushes = []
    for push in _FakeTransport.pushes:
        event_type = push["payload"]["event_type"]
        if event_type == "chat.ask_user_question":
            approval_pushes.append(push)
        if (
                event_type == "chat.evolution_status"
                and push["payload"]["status"] == "start"
        ):
            status_starts.append(push)
    assert len(status_starts) == 1
    assert status_starts[0]["request_id"] == "team_skill_evolve_real"
    assert approval_pushes[0]["request_id"] == "team_skill_evolve_real"
    assert approval_pushes[0]["payload"]["request_id"] == "team_skill_evolve_real"


@pytest.mark.anyio
async def test_team_evolution_monitor_keeps_idle_listener_after_timeout(monkeypatch):
    _FakeTransport.pushes = []
    rail = _FakeRail([], pending_first=True)

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(team_helpers, "TEAM_EVOLUTION_IDLE_SLEEP_SEC", 0.001)
    monkeypatch.setattr(team_helpers, "TEAM_EVOLUTION_EVENT_TIMEOUT_SEC", 0.01)

    task = asyncio.create_task(
        _TeamHelpersTestApi.watch_team_evolution_and_push(
            "web",
            "sess-idle",
            rail,
        )
    )
    await asyncio.sleep(0.03)

    assert task.done() is False
    assert _FakeTransport.pushes == []
    assert rail.drain_waits
    assert set(rail.drain_waits) == {False}

    task.cancel()
    with pytest.raises(asyncio.CancelledError):
        await task


@pytest.mark.anyio
async def test_team_evolution_monitor_times_out_after_idle_progress(monkeypatch):
    _FakeTransport.pushes = []
    rail = _FakeProgressOnlyRail()

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(team_helpers, "TEAM_EVOLUTION_IDLE_SLEEP_SEC", 0.001)
    monkeypatch.setattr(team_helpers, "TEAM_EVOLUTION_EVENT_TIMEOUT_SEC", 0.01)

    await _TeamHelpersTestApi.watch_team_evolution_and_push("web", "sess-timeout", rail)

    status_pushes = [
        push for push in _FakeTransport.pushes
        if push["payload"]["event_type"] == "chat.evolution_status"
    ]
    assert [push["payload"]["status"] for push in status_pushes] == ["start", "end"]
    assert status_pushes[0]["request_id"] == "team_skill_evolve_timeout"
    assert status_pushes[-1]["payload"]["stage"] == "hidden"
    assert "timed out" in status_pushes[-1]["payload"]["message"]
    assert rail.cleanup_calls == 1


@pytest.mark.anyio
async def test_team_evolution_monitor_uses_sdk_timeout_before_legacy_fallback(monkeypatch):
    class _SdkTimeoutProgressRail(_FakeProgressOnlyRail):
        @property
        def evolution_total_timeout_secs(self) -> float:
            return 0.01

    _FakeTransport.pushes = []
    rail = _SdkTimeoutProgressRail()

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(team_helpers, "TEAM_EVOLUTION_IDLE_SLEEP_SEC", 0.001)
    monkeypatch.setattr(team_helpers, "TEAM_EVOLUTION_EVENT_TIMEOUT_SEC", 100.0)
    monkeypatch.setattr(evolution_helpers, "TEAM_EVOLUTION_EVENT_TIMEOUT_GRACE_SEC", 0.001)

    await asyncio.wait_for(
        _TeamHelpersTestApi.watch_team_evolution_and_push("web", "sess-sdk-timeout", rail),
        timeout=0.2,
    )

    status_pushes = [
        push for push in _FakeTransport.pushes
        if push["payload"]["event_type"] == "chat.evolution_status"
    ]
    assert [push["payload"]["status"] for push in status_pushes] == ["start", "end"]
    assert status_pushes[-1]["payload"]["stage"] == "hidden"
    assert rail.cleanup_calls == 1


@pytest.mark.anyio
async def test_ensure_team_evolution_watcher_starts_without_reasoning_gate(monkeypatch):
    registered: dict[str, asyncio.Task] = {}

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def get_team_evolution_watcher(session_id: str):
            return None

        @staticmethod
        def get_team_skill_rail(session_id: str):
            return SimpleNamespace(review_trigger=False)

        @staticmethod
        def register_team_evolution_watcher(
                session_id: str,
                task: asyncio.Task,
        ) -> None:
            registered[session_id] = task

        @staticmethod
        def pop_team_evolution_watcher(session_id: str):
            return registered.pop(session_id, None)

    async def _fake_watch(channel_id, session_id, rail):
        await asyncio.sleep(3600)

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(team_helpers, "_watch_team_evolution_and_push", _fake_watch)

    _TeamHelpersTestApi.ensure_team_evolution_watcher("web", "sess-2")

    watcher = registered["sess-2"]
    assert isinstance(watcher, asyncio.Task)
    watcher.cancel()
    with pytest.raises(asyncio.CancelledError):
        await watcher


@pytest.mark.anyio
async def test_ensure_team_evolution_watcher_defers_when_rail_missing(monkeypatch):
    deferred: list[str] = []

    class _FakeManager:
        @staticmethod
        def get_team_evolution_watcher(session_id: str):
            return None

        @staticmethod
        def get_team_skill_rail(session_id: str):
            return None

        @staticmethod
        def mark_team_evolution_watcher_deferred(session_id: str) -> None:
            deferred.append(session_id)

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())

    _TeamHelpersTestApi.ensure_team_evolution_watcher("web", "sess-missing", source="runtime_ready")

    assert deferred == ["sess-missing"]


@pytest.mark.anyio
async def test_ensure_team_evolution_watcher_starts_when_rail_mounted(
        monkeypatch,
):
    """Mounted evolution rail enables passive scan; watcher starts regardless of review_trigger."""
    registered: dict[str, asyncio.Task] = {}

    class _Rail:
        review_trigger = False

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def get_team_evolution_watcher(session_id: str):
            return None

        @staticmethod
        def get_team_skill_rail(session_id: str):
            return _Rail()

        @staticmethod
        def register_team_evolution_watcher(
                session_id: str,
                task: asyncio.Task,
        ) -> None:
            registered[session_id] = task

        @staticmethod
        def pop_team_evolution_watcher(session_id: str):
            return registered.pop(session_id, None)

    async def _fake_watch(channel_id, session_id, rail):
        await asyncio.sleep(3600)

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(team_helpers, "_watch_team_evolution_and_push", _fake_watch)

    _TeamHelpersTestApi.ensure_team_evolution_watcher("web", "sess-1")

    watcher = registered["sess-1"]
    watcher.cancel()
    with pytest.raises(asyncio.CancelledError):
        await watcher


@pytest.mark.anyio
async def test_consume_stream_with_query_launches_watcher_after_runtime_ready(monkeypatch):
    calls: list[str] = []

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def commit_runtime_ready(session_id: str, team_name: str) -> None:
            calls.append(f"commit:{session_id}:{team_name}")

        @staticmethod
        async def attach_distributed_hooks_for_runner_runtime(**kwargs) -> None:
            calls.append(
                f"hooks:{kwargs['session_id']}:{kwargs['team_name']}:{kwargs['channel_id']}"
            )

        @staticmethod
        def clear_pending_runtime(session_id: str) -> None:
            calls.append(f"clear:{session_id}")

        @staticmethod
        def clear_active_runtime(session_id: str) -> None:
            calls.append(f"clear_active:{session_id}")

        @staticmethod
        def pop_stream_task(session_id: str):
            calls.append(f"pop:{session_id}")
            return None

        @staticmethod
        def resolve_team_agent(session_id: str):
            return None

        @staticmethod
        def get_workflow_handler(session_id: str):
            return None

        @staticmethod
        def register_workflow_handler(session_id: str, handler: object) -> None:
            calls.append(f"register_workflow_handler:{session_id}")

    async def _fake_stream(**kwargs):
        yield SimpleNamespace(kind="ready")

    monkeypatch.setattr(team_helpers, "_run_agent_team_streaming", _fake_stream)
    monkeypatch.setattr(
        team_helpers,
        "parse_stream_chunk",
        lambda chunk: {
            "event_type": "team.runtime_ready",
            "team_name": "ready-team",
            "activation_kind": "resume",
        },
    )
    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(
        team_helpers,
        "sync_team_identity_metadata",
        lambda **kwargs: calls.append(f"sync:{kwargs['session_id']}:{kwargs['ready_team_name']}"),
    )

    async def _fake_monitor(
            channel_id: str | None,
            session_id: str,
            team_name: str,
            **kwargs: object,
    ) -> None:
        calls.append(f"monitor:{session_id}:{team_name}")

    monkeypatch.setattr(team_helpers, "ensure_monitor_handlers_for_active_runtime", _fake_monitor)
    monkeypatch.setattr(
        team_helpers,
        "ensure_team_evolution_watcher",
        lambda channel_id, session_id, *, source="unknown": calls.append(
            f"watcher:{session_id}:{source}"
        ),
    )

    await _TeamHelpersTestApi.consume_stream_with_query(
        "web",
        "sess-runtime",
        SimpleNamespace(team_name="spec-team"),
        "hello",
    )

    assert calls[:5] == [
        "sync:sess-runtime:ready-team",
        "commit:sess-runtime:ready-team",
        "hooks:sess-runtime:ready-team:web",
        "monitor:sess-runtime:ready-team",
        "watcher:sess-runtime:runtime_ready",
    ]
    assert calls[-3:] == [
        "clear:sess-runtime",
        "clear_active:sess-runtime",
        "pop:sess-runtime",
    ]


@pytest.mark.anyio
async def test_consume_stream_clears_initialized_only_after_aclose_succeeds(monkeypatch):
    """Paused-team follow-up depends on this marker surviving a failed aclose."""
    monkeypatch.setattr(team_helpers, "_await_runner_pool_release", lambda *args: asyncio.sleep(0))
    cleared: list[str] = []

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def clear_pending_runtime(session_id: str) -> None:
            return None

        @staticmethod
        def clear_active_runtime(session_id: str) -> None:
            return None

        @staticmethod
        def pop_stream_task(session_id: str):
            return None

        @staticmethod
        def clear_session_initialized(session_id: str) -> None:
            cleared.append(session_id)

    class _ClosingStream:
        def __init__(self, *, fail: bool) -> None:
            self._fail = fail
            self.aclose_calls = 0

        def __aiter__(self):
            return self

        def __anext__(self):
            raise StopAsyncIteration

        async def aclose(self) -> None:
            self.aclose_calls += 1
            if self._fail:
                raise RuntimeError("aclose failed")

    async def _release(*args, **kwargs):
        return None

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(team_helpers, "_await_runner_pool_release", _release)

    ok_stream = _ClosingStream(fail=False)
    monkeypatch.setattr(team_helpers, "_run_agent_team_streaming", lambda **kwargs: ok_stream)
    await _TeamHelpersTestApi.consume_stream_with_query(
        "web",
        "sess-aclose-ok",
        SimpleNamespace(team_name="spec-team"),
        "hello",
    )
    assert ok_stream.aclose_calls == 1
    assert cleared == ["sess-aclose-ok"]

    cleared.clear()
    bad_stream = _ClosingStream(fail=True)
    monkeypatch.setattr(team_helpers, "_run_agent_team_streaming", lambda **kwargs: bad_stream)
    await _TeamHelpersTestApi.consume_stream_with_query(
        "web",
        "sess-aclose-fail",
        SimpleNamespace(team_name="spec-team"),
        "hello",
    )
    assert bad_stream.aclose_calls == 1
    assert cleared == []


def test_sync_team_identity_metadata_persists_ready_team_for_any_activation(monkeypatch):
    updates: list[dict[str, object]] = []

    monkeypatch.setattr(team_helpers, "get_session_metadata", lambda session_id: {})
    monkeypatch.setattr(team_helpers, "update_session_metadata", lambda **kwargs: updates.append(kwargs))

    team_helpers.sync_team_identity_metadata(
        channel_id="web",
        session_id="sess-runtime",
        mode="team",
        ready_team_name="ready-team",
        activation_kind="resume",
    )

    assert updates == [
        {
            "session_id": "sess-runtime",
            "channel_id": "web",
            "mode": "team",
            "team_name": "ready-team",
        }
    ]


def test_sync_team_identity_metadata_keeps_existing_conflicting_team(monkeypatch):
    updates: list[dict[str, object]] = []

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

    team_helpers.sync_team_identity_metadata(
        channel_id="web",
        session_id="sess-runtime",
        mode="team",
        ready_team_name="ready-team",
        activation_kind="resume",
    )

    assert updates == []


def test_sync_team_identity_metadata_keeps_reconciled_template_team_name(monkeypatch):
    updates: list[dict[str, object]] = []
    runtime_team_name = (
        "oc_team_preset-software-dev_officeclaw_1a08f65aea0_d7bfe3d56f01"
    )

    monkeypatch.setattr(
        team_helpers,
        "get_session_metadata",
        lambda session_id, **kwargs: {
            "team_name": "oc_team_preset-software-dev",
            "runtime_team_name": runtime_team_name,
        },
    )
    monkeypatch.setattr(team_helpers, "update_session_metadata", lambda **kwargs: updates.append(kwargs))

    team_helpers.sync_team_identity_metadata(
        channel_id="officeclaw",
        session_id="officeclaw_1a08f65aea0_d7bfe3d56f01",
        mode="team",
        ready_team_name=runtime_team_name,
        activation_kind="create",
    )

    assert updates == []


def test_sync_team_identity_metadata_honors_explicit_sessions_root(
    tmp_path,
    monkeypatch,
):
    from jiuwenswarm.server.runtime.session.session_metadata import (
        _METADATA_QUEUE,
        init_session_metadata,
    )

    correct_root = tmp_path / "agent_agentteam_sessions"
    wrong_root = tmp_path / "agent_default_sessions"
    correct_root.mkdir(parents=True)
    wrong_root.mkdir(parents=True)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.session.session_metadata.get_agent_sessions_dir",
        lambda: wrong_root,
    )

    init_session_metadata(session_id="sess-sync-root", sessions_root=correct_root)
    _METADATA_QUEUE.join()

    team_helpers.sync_team_identity_metadata(
        channel_id="officeclaw",
        session_id="sess-sync-root",
        mode="team",
        ready_team_name="oc_team_demo_officeclaw_sess-sync-root",
        activation_kind="create",
        sessions_root=correct_root,
    )
    _METADATA_QUEUE.join()

    assert (correct_root / "sess-sync-root" / "metadata.json").is_file()
    assert not (wrong_root / "sess-sync-root" / "metadata.json").exists()


@pytest.mark.anyio
async def test_consume_monitor_events_only_broadcasts_monitor_events(monkeypatch):
    broadcasted: list[dict[str, object]] = []
    event = {"event_type": "team.task", "event": {"type": "team.task.completed", "task_id": "task-1"}}

    class _FakeMonitorEventHandler:
        def __init__(self, events: list[dict[str, object]]):
            self._events = list(events)

        async def events(self):
            for item in self._events:
                yield item

    monkeypatch.setattr(team_helpers, "_broadcast_event", lambda *args: broadcasted.append(args[2]))

    monitor_handler = _FakeMonitorEventHandler([event])
    await _TeamHelpersTestApi.consume_monitor_events("web", "sess-monitor", monitor_handler)

    assert broadcasted == [event]


@pytest.mark.anyio
async def test_handle_team_slash_command_returns_team_evolve_list_summary(tmp_path):
    skills_dir = _write_team_skill(
        tmp_path,
        "demo-skill",
        records=[_evolution_record("Improve retry flow\nSecond line", score=0.88)],
    )

    result = await _TeamHelpersTestApi.handle_team_slash_command(
        "web",
        "sess-team-list",
        "/evolve_list demo-skill",
        skills_dir=skills_dir,
    )

    assert result is not None
    assert result["result_type"] == "answer"
    assert 'Skill "demo-skill"' in result["output"]
    assert "Improve retry flow" in result["output"]


@pytest.mark.anyio
async def test_handle_team_slash_command_allows_evolve_rollback(monkeypatch, tmp_path):
    skills_dir = _write_team_skill(tmp_path, "demo-skill")

    async def _fake_handler(query: str, context: object) -> dict[str, object]:
        assert query == "/evolve_rollback demo-skill latest"
        assert getattr(context, "mode") == "team"
        assert getattr(context, "skills_dir") == skills_dir
        return {"output": "team rollback handled", "result_type": "answer"}

    monkeypatch.setattr(team_helpers, "handle_evolution_slash_command", _fake_handler)

    result = await _TeamHelpersTestApi.handle_team_slash_command(
        "web",
        "sess-team-rollback",
        "/evolve_rollback demo-skill latest",
        skills_dir=skills_dir,
    )

    assert result == {"output": "team rollback handled", "result_type": "answer"}


@pytest.mark.anyio
async def test_process_team_message_stream_handles_team_evolve_list(monkeypatch, tmp_path):
    _write_team_skill(
        tmp_path,
        "demo-skill",
        records=[_evolution_record("First summary line")],
    )
    captured_spec: list[object] = []
    captured_context: list[dict] = []

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def has_stream_task(session_id: str) -> bool:
            return False

        @staticmethod
        async def get_swarm_enriched_team_spec(**kwargs):
            captured_context.append(kwargs)
            spec = SimpleNamespace(
                team_name="unit-team",
                workspace=SimpleNamespace(root_path=str(tmp_path / "team-workspace")),
            )
            captured_spec.append(spec)
            return spec

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())

    request = SimpleNamespace(
        session_id="sess-team-stream",
        request_id="req-team-stream",
        channel_id="web",
        metadata=None,
        params={"bot_id": "cron-resource"},
    )
    inputs = {"query": "/evolve_list demo-skill"}

    chunks = []
    async for chunk in team_helpers.process_team_message_stream(
            request,
            inputs,
            object(),
            config_base={"models": {"defaults": []}},
            sessions_root=tmp_path / "tenant-sessions",
    ):
        chunks.append(chunk)

    assert len(chunks) == 3
    assert chunks[0].payload is not None
    assert chunks[0].payload["event_type"] == "chat.final"
    assert 'Skill "demo-skill"' in chunks[0].payload["content"]
    assert chunks[1].payload == {
        "event_type": "chat.processing_status",
        "session_id": "sess-team-stream",
        "is_processing": False,
        "is_complete": True,
    }
    assert chunks[1].is_complete is False
    assert chunks[2].is_complete is True
    assert captured_spec
    assert captured_context[0]["config_base"] == {"models": {"defaults": []}}
    assert captured_context[0]["sessions_root"] == tmp_path / "tenant-sessions"
    assert captured_context[0]["request_metadata"]["routing"]["bot_id"] == "cron-resource"


@pytest.mark.anyio
async def test_process_team_message_stream_handles_evolve_rebuild(monkeypatch, tmp_path):
    _write_team_skill(tmp_path, "demo-skill")
    rebuild_calls: list[dict] = []

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def has_stream_task(session_id: str) -> bool:
            return False

        @staticmethod
        async def get_swarm_enriched_team_spec(**kwargs):
            return SimpleNamespace(
                team_name="unit-team",
                workspace=SimpleNamespace(root_path=str(tmp_path / "team-workspace")),
            )

    async def _fake_handler(query: str, context: object) -> dict[str, object]:
        assert query == "/evolve_rebuild demo-skill tighten examples"
        assert getattr(context, "mode") == "team"
        return {
            "result_type": "rebuild_request",
            "action": "run_rebuild_inline",
            "skill_name": "demo-skill",
            "user_intent": "tighten examples",
        }

    async def _fake_rebuild(params: dict) -> dict:
        rebuild_calls.append(dict(params))
        return {
            "success": True,
            "name": "demo-skill",
            "new_version": "2.0.0",
            "cleared": True,
        }

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(team_helpers, "handle_evolution_slash_command", _fake_handler)

    request = SimpleNamespace(
        session_id="sess-team-rebuild",
        request_id="req-team-rebuild",
        channel_id="web",
        metadata=None,
    )
    inputs = {"query": "/evolve_rebuild demo-skill tighten examples"}

    chunks = []
    async for chunk in team_helpers.process_team_message_stream(
        request,
        inputs,
        object(),
        rebuild_skill=_fake_rebuild,
    ):
        chunks.append(chunk)

    assert len(chunks) == 3
    assert chunks[0].payload is not None
    assert chunks[0].payload["event_type"] == "chat.final"
    assert "2.0.0" in chunks[0].payload["content"]
    assert chunks[0].payload.get("slash_command") == "evolve_rebuild"
    assert chunks[2].is_complete is True
    assert rebuild_calls == [
        {
            "name": "demo-skill",
            "user_intent": "tighten examples",
            "skills_dirs": [str(tmp_path / "team-workspace" / "skills")],
        }
    ]


@pytest.mark.anyio
async def test_process_team_message_stream_followup_owns_waiter_until_team_completed(monkeypatch):
    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        interact_calls: list[tuple[str, str]] = []

        def __init__(self) -> None:
            super().__init__()
            self.waiters: dict[tuple[str, str], asyncio.Queue] = {}
            self.emitter_tasks: list[asyncio.Task] = []

        def has_waiters(self, session_id: str) -> bool:
            return any(sid == session_id for sid, _rid in self.waiters)

        def add_waiter(
            self,
            session_id: str,
            request_id: str,
            queue: asyncio.Queue,
        ) -> None:
            self.waiters[(session_id, request_id)] = queue

        def remove_waiter(self, session_id: str, request_id: str) -> None:
            self.waiters.pop((session_id, request_id), None)

        @staticmethod
        def has_stream_task(session_id: str) -> bool:
            assert session_id == "sess-team-followup"
            return True

        @staticmethod
        async def get_swarm_enriched_team_spec(**kwargs):
            return SimpleNamespace(team_name="unit-team")

        async def interact(self, session_id: str, query: str):
            type(self).interact_calls.append((session_id, query))
            queue = self.waiters.get((session_id, "req-team-followup"))
            assert queue is not None
            queue.put_nowait(
                {
                    "event_type": "chat.final",
                    "role": "teammate",
                    "member_name": "human-reporter",
                    "content": "follow-up result",
                }
            )
            queue.put_nowait({"event_type": "team.completed"})
            return True, None

    manager = _FakeManager()
    manager.mark_seen_team_events("sess-team-followup")
    manager.mark_workflow_completed("sess-team-followup")
    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: manager)

    request = SimpleNamespace(
        session_id="sess-team-followup",
        request_id="req-team-followup",
        channel_id="web",
        metadata=None,
        params={"mode": "team"},
    )
    inputs = {"query": "$human-reporter claim task"}

    chunks = []
    async for chunk in team_helpers.process_team_message_stream(
        request,
        inputs,
        object(),
    ):
        chunks.append(chunk)
    await asyncio.gather(*manager.emitter_tasks)

    assert _FakeManager.interact_calls == [
        ("sess-team-followup", "$human-reporter claim task"),
    ]
    assert [chunk.payload and chunk.payload.get("event_type") for chunk in chunks] == [
        "chat.final",
        "team.completed",
        None,
    ]
    assert chunks[0].request_id == "req-team-followup"
    assert chunks[0].agent_ref == {"mode": "team", "id": "human-reporter"}
    assert chunks[0].metadata["fan_out_targets"]
    assert chunks[-1].is_complete is True
    assert manager.has_seen_team_events("sess-team-followup") is False
    assert manager.is_workflow_completed("sess-team-followup") is False
    assert manager.waiters == {}


@pytest.mark.anyio
async def test_process_team_message_stream_control_followup_reuses_existing_waiter(monkeypatch):
    from openjiuwen.core.session.interaction.interactive_input import InteractiveInput

    approval_input = InteractiveInput()
    approval_input.update(
        "permission-call-1",
        {"approved": True},
    )

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        def __init__(self) -> None:
            super().__init__()
            self.stream_active = True
            self.waiters = {
                ("sess-team-control-followup", "original-request"): asyncio.Queue(),
            }
            self.added_waiters: list[tuple[str, str]] = []

        def has_waiters(self, session_id: str) -> bool:
            return any(sid == session_id for sid, _rid in self.waiters)

        def add_waiter(
            self,
            session_id: str,
            request_id: str,
            queue: asyncio.Queue,
        ) -> None:
            self.added_waiters.append((session_id, request_id))
            self.waiters[(session_id, request_id)] = queue

        def remove_waiter(self, session_id: str, request_id: str) -> None:
            self.waiters.pop((session_id, request_id), None)

        def has_stream_task(self, session_id: str) -> bool:
            assert session_id == "sess-team-control-followup"
            return self.stream_active

        @staticmethod
        async def get_swarm_enriched_team_spec(**kwargs):
            return SimpleNamespace(team_name="unit-team")

        async def interact(self, session_id: str, query: Any):
            assert query is approval_input
            self.stream_active = False
            return True, None

    manager = _FakeManager()
    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: manager)

    request = SimpleNamespace(
        session_id="sess-team-control-followup",
        request_id="req-team-control-followup",
        channel_id="web",
        metadata=None,
        params={"mode": "team", "source": "permission_interrupt"},
    )

    chunks = []
    async for chunk in team_helpers.process_team_message_stream(
        request,
        {"query": approval_input},
        object(),
    ):
        chunks.append(chunk)

    assert manager.added_waiters == []
    assert set(manager.waiters) == {
        ("sess-team-control-followup", "original-request"),
    }
    assert [chunk.payload and chunk.payload.get("event_type") for chunk in chunks] == [
        "chat.processing_status_deferred",
        None,
    ]
    assert chunks[-1].is_complete is True


def test_note_team_permission_resume_landing_only_tracks_interactive_input() -> None:
    from openjiuwen.core.session.interaction.interactive_input import InteractiveInput
    from jiuwenswarm.server.runtime.session.permission_response_ledger import (
        consume_team_permission_resume_landed,
        reset_team_permission_resume_landed,
    )

    reset_team_permission_resume_landed()
    team_helpers._note_team_permission_resume_landing("继续", True)
    assert consume_team_permission_resume_landed() is None

    approval = InteractiveInput()
    approval.update("call-1", {"approved": True})
    team_helpers._note_team_permission_resume_landing(approval, True)
    assert consume_team_permission_resume_landed() is True
    team_helpers._note_team_permission_resume_landing(approval, False)
    assert consume_team_permission_resume_landed() is False


@pytest.mark.anyio
async def test_process_team_message_stream_retries_followup_while_native_starts(monkeypatch):
    class _FakeManager(_CompletingFollowupRuntimeManagerMixin):
        interact_calls: list[tuple[str, str]] = []

        @staticmethod
        def has_stream_task(session_id: str) -> bool:
            assert session_id == "sess-team-followup-starting"
            return True

        @staticmethod
        async def get_swarm_enriched_team_spec(**kwargs):
            return SimpleNamespace(team_name="unit-team")

        @classmethod
        async def interact(cls, session_id: str, query: str):
            cls.interact_calls.append((session_id, query))
            return (
                False,
                "deliver_to_leader_failed:[123023] deepagent runtime error, "
                "reason: NativeHarness not started.",
            )

    async def _fake_retry(
        team_manager: object,
        session_id: str,
        query: str,
        *,
        initial_reason: str | None = None,
    ):
        assert team_manager is not None
        assert initial_reason == (
            "deliver_to_leader_failed:[123023] deepagent runtime error, "
            "reason: NativeHarness not started."
        )
        _FakeManager.interact_calls.append((session_id, f"retry:{query}"))
        return team_helpers._FollowupInteractBoundaryResult(
            success=True,
            reason=None,
            first_request_ready=False,
        )

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(team_helpers, "_deliver_followup_interact_across_boundary", _fake_retry)

    request = SimpleNamespace(
        session_id="sess-team-followup-starting",
        request_id="req-team-followup-starting",
        channel_id="web",
        metadata=None,
        params={"mode": "team"},
    )

    chunks = []
    async for chunk in team_helpers.process_team_message_stream(
        request,
        {"query": "启动中追问"},
        object(),
    ):
        chunks.append(chunk)

    assert _FakeManager.interact_calls == [
        ("sess-team-followup-starting", "启动中追问"),
        ("sess-team-followup-starting", "retry:启动中追问"),
    ]
    assert chunks[0].payload == {"event_type": "team.completed"}
    assert chunks[-1].is_complete is True


@pytest.mark.anyio
async def test_process_team_message_stream_restarts_round_after_shutdown_race(monkeypatch):
    captured: dict[str, Any] = {}

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        interact_calls: list[tuple[str, str]] = []
        skills_ready_calls: list[tuple[str, str]] = []
        stream_active = True

        @classmethod
        def has_stream_task(cls, session_id: str) -> bool:
            assert session_id == "sess-team-followup-stopped"
            return cls.stream_active

        @staticmethod
        async def get_swarm_enriched_team_spec(**kwargs):
            return SimpleNamespace(team_name="unit-team", enable_swarmflow=False)

        @classmethod
        async def interact(cls, session_id: str, query: str):
            cls.interact_calls.append((session_id, query))
            return (
                False,
                "deliver_to_leader_failed:[123023] deepagent runtime error, "
                "reason: NativeHarness already stopped.",
            )

        @classmethod
        def ensure_team_shared_skills_ready_for_session(cls, session_id: str, team_spec: object):
            cls.skills_ready_calls.append((session_id, team_spec.team_name))

        @staticmethod
        async def prepare_runtime_activation(session_id: str, team_name: str):
            captured["prepared"] = (session_id, team_name)

        @staticmethod
        def register_stream_task(session_id: str, task: object) -> None:
            captured["registered"] = session_id

    async def _fake_retry(
        team_manager: object,
        session_id: str,
        query: str,
        *,
        initial_reason: str | None = None,
    ):
        assert team_manager is not None
        assert session_id == "sess-team-followup-stopped"
        assert query
        assert initial_reason == (
            "deliver_to_leader_failed:[123023] deepagent runtime error, "
            "reason: NativeHarness already stopped."
        )
        _FakeManager.stream_active = False
        return team_helpers._FollowupInteractBoundaryResult(
            success=False,
            reason=initial_reason,
            first_request_ready=True,
        )

    async def _fake_consume_stream_with_query(
        channel_id: str | None,
        session_id: str,
        spec: object,
        query: str,
        *,
        round_id: int,
        envs: dict | None = None,
        sessions_root=None,
    ) -> None:
        _ = channel_id, spec, envs
        captured["consumed"] = (session_id, query, round_id)

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(team_helpers, "_deliver_followup_interact_across_boundary", _fake_retry)
    monkeypatch.setattr(team_helpers, "increment_session_round_count", lambda session_id: 7)
    monkeypatch.setattr(team_helpers, "_consume_stream_with_query", _fake_consume_stream_with_query)

    request = SimpleNamespace(
        session_id="sess-team-followup-stopped",
        request_id="req-team-followup-stopped",
        channel_id="web",
        metadata=None,
        params={"mode": "team"},
    )

    chunks = []
    async for chunk in team_helpers.process_team_message_stream(
        request,
        {"query": "查询杭州天气"},
        object(),
    ):
        chunks.append(chunk)
    await asyncio.sleep(0)

    assert _FakeManager.interact_calls == [
        ("sess-team-followup-stopped", "查询杭州天气"),
    ]
    assert _FakeManager.skills_ready_calls == [
        ("sess-team-followup-stopped", "unit-team"),
    ]
    assert captured["prepared"] == ("sess-team-followup-stopped", "unit-team")
    assert captured["registered"] == "sess-team-followup-stopped"
    assert captured["consumed"] == ("sess-team-followup-stopped", "查询杭州天气", 7)
    assert chunks[-1].is_complete is True
    assert not any(
        chunk.payload
        and chunk.payload.get("error") == "Failed to send message, please try again later"
        for chunk in chunks
    )


@pytest.mark.anyio
async def test_process_team_message_stream_fallback_reuses_first_request_directives(monkeypatch):
    captured: dict[str, Any] = {}

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        interact_calls: list[tuple[str, str]] = []
        stream_active = True

        @classmethod
        def has_stream_task(cls, session_id: str) -> bool:
            assert session_id == "sess-team-followup-directives"
            return cls.stream_active

        @staticmethod
        async def get_swarm_enriched_team_spec(**kwargs):
            return SimpleNamespace(team_name="unit-team", enable_swarmflow=False)

        @classmethod
        async def interact(cls, session_id: str, query: str):
            cls.interact_calls.append((session_id, query))
            return False, "gate_closed"

        @staticmethod
        async def prepare_runtime_activation(session_id: str, team_name: str):
            captured["prepared"] = (session_id, team_name)

        @staticmethod
        def register_stream_task(session_id: str, task: object) -> None:
            captured["registered"] = session_id

    async def _fake_retry(
        team_manager: object,
        session_id: str,
        query: str,
        *,
        initial_reason: str | None = None,
    ):
        assert team_manager is not None
        assert session_id == "sess-team-followup-directives"
        assert query == "/hide_dm /debug weather"
        assert initial_reason == "gate_closed"
        _FakeManager.stream_active = False
        return team_helpers._FollowupInteractBoundaryResult(
            success=False,
            reason=initial_reason,
            first_request_ready=True,
        )

    async def _fake_consume_stream_with_query(
        channel_id: str | None,
        session_id: str,
        spec: object,
        query: str,
        *,
        round_id: int,
        envs: dict | None = None,
        sessions_root=None,
    ) -> None:
        _ = channel_id, spec
        captured["consumed"] = (session_id, query, round_id, envs)

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(team_helpers, "_deliver_followup_interact_across_boundary", _fake_retry)
    monkeypatch.setattr(team_helpers, "increment_session_round_count", lambda session_id: 9)
    monkeypatch.setattr(team_helpers, "_consume_stream_with_query", _fake_consume_stream_with_query)

    request = SimpleNamespace(
        session_id="sess-team-followup-directives",
        request_id="req-team-followup-directives",
        channel_id="web",
        metadata=None,
        params={"mode": "team"},
    )

    chunks = []
    async for chunk in team_helpers.process_team_message_stream(
        request,
        {"query": "/hide_dm /debug weather"},
        object(),
    ):
        chunks.append(chunk)
    await asyncio.sleep(0)

    assert _FakeManager.interact_calls == [
        ("sess-team-followup-directives", "/hide_dm /debug weather"),
    ]
    assert captured["prepared"] == ("sess-team-followup-directives", "unit-team")
    assert captured["registered"] == "sess-team-followup-directives"
    assert captured["consumed"][:3] == ("sess-team-followup-directives", "weather", 9)
    stream_envs = captured["consumed"][3]
    assert stream_envs["hide_dm"] is True
    assert stream_envs["JIUWENSWARM_TEAM_STREAM_TRACE"] == "1"
    assert chunks[-1].is_complete is True


@pytest.mark.anyio
async def test_process_team_message_stream_silences_gate_closed_when_shutdown_race_times_out(monkeypatch):
    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def has_stream_task(session_id: str) -> bool:
            assert session_id == "sess-team-followup-timeout"
            return True

        @staticmethod
        async def get_swarm_enriched_team_spec(**kwargs):
            return SimpleNamespace(team_name="unit-team")

        @staticmethod
        async def interact(session_id: str, query: str):
            assert session_id == "sess-team-followup-timeout"
            assert query == "还在收尾"
            return False, "gate_closed"

        @staticmethod
        async def prepare_runtime_activation(session_id: str, team_name: str):
            raise AssertionError("timed-out shutdown race should not start a new stream")

    async def _fake_retry(
        team_manager: object,
        session_id: str,
        query: str,
        *,
        initial_reason: str | None = None,
    ):
        assert team_manager is not None
        assert session_id == "sess-team-followup-timeout"
        assert query
        assert initial_reason == "gate_closed"
        return team_helpers._FollowupInteractBoundaryResult(
            success=False,
            reason=initial_reason,
            first_request_ready=False,
        )

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(team_helpers, "_deliver_followup_interact_across_boundary", _fake_retry)

    request = SimpleNamespace(
        session_id="sess-team-followup-timeout",
        request_id="req-team-followup-timeout",
        channel_id="web",
        metadata=None,
        params={"mode": "team"},
    )

    chunks = []
    async for chunk in team_helpers.process_team_message_stream(
        request,
        {"query": "还在收尾"},
        object(),
    ):
        chunks.append(chunk)

    # gate_closed 静默处理:不报 chat.error,直接以 is_complete=True 结束流
    assert chunks[-1].is_complete is True
    assert not any(
        chunk.payload and chunk.payload.get("event_type") == "chat.error"
        for chunk in chunks
    )


@pytest.mark.anyio
async def test_process_team_message_stream_passes_interactive_input_to_followup(monkeypatch):
    from openjiuwen.core.session.interaction.interactive_input import InteractiveInput

    approval_input = InteractiveInput()
    approval_input.update(
        "exit_plan_mode_call_1",
        {"approved": True, "auto_confirm": False, "feedback": ""},
    )

    class _FakeManager(_CompletingFollowupRuntimeManagerMixin):
        interact_calls: list[tuple[str, Any]] = []

        @staticmethod
        def has_stream_task(session_id: str) -> bool:
            assert session_id == "sess-team-plan-followup"
            return True

        @staticmethod
        async def get_swarm_enriched_team_spec(**kwargs):
            return SimpleNamespace(team_name="unit-team")

        @classmethod
        async def interact(cls, session_id: str, query: Any):
            cls.interact_calls.append((session_id, query))
            return True, None

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())

    request = SimpleNamespace(
        session_id="sess-team-plan-followup",
        request_id="req-team-plan-followup",
        channel_id="web",
        metadata=None,
        params={"mode": "team.plan"},
    )
    inputs = {"query": approval_input}

    chunks = []
    async for chunk in team_helpers.process_team_message_stream(
        request,
        inputs,
        object(),
    ):
        chunks.append(chunk)

    assert _FakeManager.interact_calls == [
        ("sess-team-plan-followup", approval_input),
    ]
    assert chunks[-1].is_complete is True


@pytest.mark.anyio
async def test_process_team_message_stream_resumes_active_session_without_stream_task(monkeypatch):
    from openjiuwen.core.session.interaction.interactive_input import InteractiveInput

    ask_answer_input = InteractiveInput()
    ask_answer_input.update(
        "tool-ask-1",
        {
            "answers": {"你希望用什么技术实现?": "浏览器(HTML/CSS/JS)"},
            "original_request": "做一个斗地主游戏",
        },
    )

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        interact_calls: list[tuple[str, Any]] = []

        @staticmethod
        def is_runtime_active(session_id: str) -> bool:
            assert session_id == "sess-team-ask-followup"
            return True

        @staticmethod
        def is_runtime_pending(session_id: str) -> bool:
            assert session_id == "sess-team-ask-followup"
            return False

        @staticmethod
        def has_stream_task(session_id: str) -> bool:
            assert session_id == "sess-team-ask-followup"
            return False

        @staticmethod
        async def get_swarm_enriched_team_spec(**kwargs):
            return SimpleNamespace(team_name="unit-team")

        @classmethod
        async def interact(cls, session_id: str, query: Any):
            cls.interact_calls.append((session_id, query))
            return True, None

        @staticmethod
        def ensure_team_shared_skills_ready_for_session(*_args, **_kwargs):
            pytest.fail("active team sessions should not be treated as first requests")

        @staticmethod
        async def prepare_runtime_activation(*_args, **_kwargs):
            pytest.fail("active team sessions should not be recreated")

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())

    request = SimpleNamespace(
        session_id="sess-team-ask-followup",
        request_id="req-team-ask-followup",
        channel_id="web",
        metadata=None,
        params={"mode": "team.plan", "source": "ask_user_interrupt"},
    )
    inputs = {"query": ask_answer_input}

    chunks = []
    async for chunk in team_helpers.process_team_message_stream(
        request,
        inputs,
        object(),
    ):
        chunks.append(chunk)

    assert _FakeManager.interact_calls == [
        ("sess-team-ask-followup", ask_answer_input),
    ]
    assert chunks[-1].is_complete is True


@pytest.mark.anyio
async def test_process_team_message_stream_routes_evolution_interrupt_to_active_runtime(monkeypatch):
    from openjiuwen.core.session.interaction.interactive_input import InteractiveInput

    approval_input = InteractiveInput()
    approval_input.update(
        "team_skill_evolve_req1",
        {"answers": {"approve": True}},
    )

    class _FakeManager(_CompletingFollowupRuntimeManagerMixin):
        interact_calls: list[tuple[str, Any]] = []

        @staticmethod
        def is_runtime_active(session_id: str) -> bool:
            assert session_id == "sess-team-evolution-resume"
            return True

        @staticmethod
        def is_runtime_pending(session_id: str) -> bool:
            assert session_id == "sess-team-evolution-resume"
            return False

        @staticmethod
        def has_stream_task(session_id: str) -> bool:
            assert session_id == "sess-team-evolution-resume"
            return True

        @staticmethod
        async def get_swarm_enriched_team_spec(**kwargs):
            return SimpleNamespace(team_name="unit-team", enable_swarmflow=False)

        @staticmethod
        def ensure_team_shared_skills_ready_for_session(session_id: str, spec: Any):
            pytest.fail("active evolution interrupt resume should not prepare shared skills")

        @staticmethod
        async def prepare_runtime_activation(session_id: str, team_name: str):
            pytest.fail("active evolution interrupt resume should not recreate runtime")

        @staticmethod
        def register_stream_task(session_id: str, task: asyncio.Task) -> None:
            pytest.fail("active evolution interrupt resume should not start a stream task")

        @classmethod
        async def interact(cls, session_id: str, query: Any):
            cls.interact_calls.append((session_id, query))
            return True, None

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())

    request = SimpleNamespace(
        session_id="sess-team-evolution-resume",
        request_id="req-team-evolution-resume",
        channel_id="web",
        metadata=None,
        params={"mode": "team", "source": "evolution_interrupt"},
    )

    chunks = []
    async for chunk in team_helpers.process_team_message_stream(
        request,
        {"query": approval_input},
        object(),
    ):
        chunks.append(chunk)

    assert _FakeManager.interact_calls == [
        ("sess-team-evolution-resume", approval_input),
    ]
    assert not any(
        chunk.payload
        and chunk.payload.get("error") == "Failed to send message, please try again later"
        for chunk in chunks
    )
    assert chunks[-1].is_complete is True


@pytest.mark.anyio
async def test_process_team_message_stream_resumes_structured_team_plan_confirm_after_runtime_recovery(monkeypatch):
    from openjiuwen.core.session.interaction.interactive_input import InteractiveInput

    approval_input = InteractiveInput()
    approval_input.update(
        "exit_plan_mode_call_1",
        {"approved": True, "auto_confirm": False, "feedback": ""},
    )

    captured: dict[str, Any] = {}

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        runtime_ready = False
        interact_calls: list[tuple[str, Any]] = []

        @classmethod
        def is_runtime_active(cls, session_id: str) -> bool:
            assert session_id == "sess-team-plan-resume"
            return cls.runtime_ready

        @staticmethod
        def is_runtime_pending(session_id: str) -> bool:
            assert session_id == "sess-team-plan-resume"
            return False

        @classmethod
        async def session_has_runtime(cls, session_id: str) -> bool:
            assert session_id == "sess-team-plan-resume"
            return cls.runtime_ready

        @classmethod
        async def wait_for_resumable_runtime(cls, session_id: str, **_kwargs) -> bool:
            assert session_id == "sess-team-plan-resume"
            cls.runtime_ready = True
            return True

        @staticmethod
        def has_stream_task(session_id: str) -> bool:
            assert session_id == "sess-team-plan-resume"
            return False

        @staticmethod
        async def get_swarm_enriched_team_spec(**kwargs):
            return SimpleNamespace(team_name="unit-team", enable_swarmflow=False)

        @classmethod
        async def interact(cls, session_id: str, query: Any):
            cls.interact_calls.append((session_id, query))
            return True, None

        @staticmethod
        def ensure_team_shared_skills_ready_for_session(session_id: str, spec: Any):
            captured["skills_ready"] = (session_id, spec.team_name)

        @staticmethod
        async def prepare_runtime_activation(session_id: str, team_name: str):
            raise AssertionError("prepare_runtime_activation should not run for resumed approval")

        @staticmethod
        def register_stream_task(session_id: str, task: asyncio.Task) -> None:
            raise AssertionError("register_stream_task should not run for resumed approval")

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(team_helpers, "ensure_team_evolution_watcher", lambda *args, **kwargs: None)

    request = SimpleNamespace(
        session_id="sess-team-plan-resume",
        request_id="req-team-plan-resume",
        channel_id="web",
        metadata=None,
        params={
            "mode": "team.plan",
            "source": "confirm_interrupt",
            "plan_approval_kind": "plan_approval",
            "plan_content": "# 团队计划",
            "plan_language": "cn",
        },
    )
    inputs = {"query": approval_input}

    chunks = []
    async for chunk in team_helpers.process_team_message_stream(
        request,
        inputs,
        object(),
    ):
        chunks.append(chunk)

    await asyncio.sleep(0)

    assert _FakeManager.interact_calls == [
        ("sess-team-plan-resume", approval_input),
    ]
    assert "skills_ready" not in captured
    assert chunks[-1].is_complete is True


@pytest.mark.anyio
async def test_process_team_message_stream_rejects_orphaned_interactive_input(monkeypatch):
    from openjiuwen.core.session.interaction.interactive_input import InteractiveInput

    ask_answer_input = InteractiveInput()
    ask_answer_input.update(
        "tool-ask-1",
        {
            "answers": {"你希望用什么技术实现?": "浏览器(HTML/CSS/JS)"},
            "original_request": "做一个斗地主游戏",
        },
    )

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def is_runtime_active(session_id: str) -> bool:
            assert session_id == "sess-team-orphan-answer"
            return False

        @staticmethod
        def is_runtime_pending(session_id: str) -> bool:
            assert session_id == "sess-team-orphan-answer"
            return False

        @staticmethod
        def has_stream_task(session_id: str) -> bool:
            assert session_id == "sess-team-orphan-answer"
            return False

        @staticmethod
        async def get_swarm_enriched_team_spec(**_kwargs):
            pytest.fail("orphaned interactive inputs should not recreate team runtime")

        @staticmethod
        def ensure_team_shared_skills_ready_for_session(*_args, **_kwargs):
            pytest.fail("orphaned interactive inputs should not activate team runtime")

        @staticmethod
        async def prepare_runtime_activation(*_args, **_kwargs):
            pytest.fail("orphaned interactive inputs should not activate team runtime")

        @staticmethod
        async def interact(*_args, **_kwargs):
            pytest.fail("orphaned interactive inputs cannot resume a missing runtime")

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())

    request = SimpleNamespace(
        session_id="sess-team-orphan-answer",
        request_id="req-team-orphan-answer",
        channel_id="web",
        metadata=None,
        params={"mode": "team.plan", "source": "ask_user_interrupt"},
    )

    chunks = []
    async for chunk in team_helpers.process_team_message_stream(
        request,
        {"query": ask_answer_input},
        object(),
    ):
        chunks.append(chunk)

    assert chunks[0].payload == {
        "event_type": "chat.error",
        "error": "Team runtime is not active, please restart the task",
    }
    assert chunks[-1].is_complete is True


@pytest.mark.anyio
async def test_process_team_message_stream_recovers_paused_runtime_for_interactive_input(monkeypatch):
    from openjiuwen.core.session.interaction.interactive_input import InteractiveInput

    approval_input = InteractiveInput()
    approval_input.update(
        "exit_plan_mode_call_1",
        {"approved": True, "auto_confirm": False, "feedback": ""},
    )

    class _FakeManager(_CompletingFollowupRuntimeManagerMixin):
        runtime_ready = False
        interact_calls: list[tuple[str, Any]] = []

        @classmethod
        def is_runtime_active(cls, session_id: str) -> bool:
            assert session_id == "sess-team-plan-recover"
            return cls.runtime_ready

        @staticmethod
        def is_runtime_pending(session_id: str) -> bool:
            assert session_id == "sess-team-plan-recover"
            return False

        @classmethod
        async def session_has_runtime(cls, session_id: str) -> bool:
            assert session_id == "sess-team-plan-recover"
            return cls.runtime_ready

        @classmethod
        async def wait_for_resumable_runtime(cls, session_id: str, **_kwargs) -> bool:
            assert session_id == "sess-team-plan-recover"
            cls.runtime_ready = True
            return True

        @staticmethod
        def has_stream_task(session_id: str) -> bool:
            assert session_id == "sess-team-plan-recover"
            return False

        @staticmethod
        async def get_swarm_enriched_team_spec(**_kwargs):
            return SimpleNamespace(team_name="unit-team")

        @classmethod
        async def interact(cls, session_id: str, query: Any):
            cls.interact_calls.append((session_id, query))
            return True, None

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())

    request = SimpleNamespace(
        session_id="sess-team-plan-recover",
        request_id="req-team-plan-recover",
        channel_id="web",
        metadata=None,
        params={"mode": "team.plan", "source": "confirm_interrupt"},
    )

    chunks = []
    async for chunk in team_helpers.process_team_message_stream(
        request,
        {"query": approval_input},
        object(),
    ):
        chunks.append(chunk)

    assert _FakeManager.interact_calls == [
        ("sess-team-plan-recover", approval_input),
    ]
    assert chunks[0].payload == {"event_type": "team.completed"}
    assert chunks[-1].is_complete is True


@pytest.mark.anyio
async def test_process_team_message_stream_treats_plain_query_as_first_request_after_round_end(monkeypatch):
    captured: dict[str, Any] = {}

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def is_runtime_active(session_id: str) -> bool:
            assert session_id == "sess-team-new-round"
            return False

        @staticmethod
        def is_runtime_pending(session_id: str) -> bool:
            assert session_id == "sess-team-new-round"
            return False

        @staticmethod
        async def session_has_runtime(session_id: str) -> bool:
            assert session_id == "sess-team-new-round"
            return True

        @staticmethod
        def has_stream_task(session_id: str) -> bool:
            assert session_id == "sess-team-new-round"
            return False

        @staticmethod
        async def get_swarm_enriched_team_spec(**_kwargs):
            return SimpleNamespace(team_name="unit-team", enable_swarmflow=False)

        @staticmethod
        def ensure_team_shared_skills_ready_for_session(session_id: str, spec: Any):
            captured["skills_ready"] = (session_id, spec.team_name)

        @staticmethod
        async def prepare_runtime_activation(session_id: str, team_name: str):
            captured["prepared"] = (session_id, team_name)

        @staticmethod
        def register_stream_task(session_id: str, task: object) -> None:
            captured["registered"] = session_id

        @staticmethod
        async def interact(*_args, **_kwargs):
            raise AssertionError("plain text query after round end should start a new team round")

    async def _fake_consume_stream_with_query(
        channel_id: str | None,
        session_id: str,
        spec: object,
        query: str,
        *,
        round_id: int,
        envs: dict | None = None,
        sessions_root=None,
    ) -> None:
        _ = channel_id, spec, envs
        captured["consumed"] = (session_id, query, round_id)

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(team_helpers, "increment_session_round_count", lambda session_id: 1)
    monkeypatch.setattr(team_helpers, "_consume_stream_with_query", _fake_consume_stream_with_query)

    request = SimpleNamespace(
        session_id="sess-team-new-round",
        request_id="req-team-new-round",
        channel_id="web",
        metadata=None,
        params={"mode": "team"},
    )

    chunks = []
    async for chunk in team_helpers.process_team_message_stream(
        request,
        {"query": "你好"},
        object(),
    ):
        chunks.append(chunk)
    await asyncio.sleep(0)

    assert captured["prepared"] == ("sess-team-new-round", "unit-team")
    assert captured["registered"] == "sess-team-new-round"
    assert captured["consumed"] == ("sess-team-new-round", "你好", 1)
    assert captured["skills_ready"] == ("sess-team-new-round", "unit-team")
    assert chunks[-1].is_complete is True


@pytest.mark.anyio
async def test_process_team_message_stream_converts_a2ui_followup_event(monkeypatch):
    monkeypatch.setenv("JIUWENSWARM_A2UI_ENABLED", "true")

    class _FakeManager(_CompletingFollowupRuntimeManagerMixin):
        interact_calls: list[tuple[str, str]] = []

        @staticmethod
        def has_stream_task(session_id: str) -> bool:
            assert session_id == "sess-team-a2ui"
            return True

        @staticmethod
        async def get_swarm_enriched_team_spec(**kwargs):
            return SimpleNamespace(team_name="unit-team")

        @classmethod
        async def interact(cls, session_id: str, query: str):
            cls.interact_calls.append((session_id, query))
            return True, None

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())

    request = SimpleNamespace(
        session_id="sess-team-a2ui",
        request_id="req-team-a2ui",
        channel_id="web",
        metadata={"language": "zh"},
        params={"mode": "team"},
    )
    inputs = {
        "query": {
            "type": "a2ui.client_event",
            "protocolVersion": "0.8",
            "event": {
                "userAction": {
                    "name": "submitDietForm",
                    "surfaceId": "diet-preferences",
                    "sourceComponentId": "submit-btn",
                    "context": {"name": "Codex", "dietType": ["balanced"]},
                },
            },
        },
    }

    chunks = []
    async for chunk in team_helpers.process_team_message_stream(
        request,
        inputs,
        object(),
    ):
        chunks.append(chunk)

    assert len(_FakeManager.interact_calls) == 1
    session_id, prompt = _FakeManager.interact_calls[0]
    assert session_id == "sess-team-a2ui"
    assert isinstance(prompt, str)
    assert "A2UI" in prompt
    assert "submitDietForm" in prompt
    assert "dietType" in prompt
    assert chunks[0].payload == {"event_type": "team.completed"}
    assert chunks[1].is_complete is True


@pytest.mark.anyio
async def test_process_team_message_stream_defers_first_evolve_until_team_runtime_exists(monkeypatch, tmp_path):
    captured_queries: list[str] = []
    user_intent = "没有特殊要求时格式尽量简洁,如果使用颜色也需要保持美观"
    _write_team_skill(tmp_path, "xlsx")

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @classmethod
        def has_stream_task(cls, session_id: str) -> bool:
            return False

        @classmethod
        async def get_swarm_enriched_team_spec(cls, **kwargs):
            return SimpleNamespace(
                team_name="unit-team",
                workspace=SimpleNamespace(root_path=str(tmp_path / "team-workspace")),
            )

        @staticmethod
        def ensure_team_shared_skills_ready_for_session(session_id: str, team_spec: object) -> None:
            return None

        @staticmethod
        async def prepare_runtime_activation(session_id: str, team_name: str) -> None:
            return None

        @staticmethod
        def register_stream_task(session_id: str, task: object) -> None:
            return None

    async def _fake_consume_stream_with_query(
        channel_id: str | None,
        session_id: str,
        spec: object,
        query: str,
        *,
        round_id: int,
        envs: dict | None = None,
        sessions_root=None,
    ) -> None:
        captured_queries.append(query)

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(team_helpers, "increment_session_round_count", lambda session_id: 1)
    monkeypatch.setattr(team_helpers, "_consume_stream_with_query", _fake_consume_stream_with_query)

    request = SimpleNamespace(
        session_id="sess-first-evolve",
        request_id="req-first-evolve",
        channel_id="web",
        metadata=None,
        params={"mode": "team"},
    )
    inputs = {"query": f"/evolve xlsx {user_intent}"}

    chunks = []
    async for chunk in team_helpers.process_team_message_stream(request, inputs, object()):
        chunks.append(chunk)
    await asyncio.sleep(0)

    assert len(captured_queries) == 1
    assert "prepare_skill_evolution" in captured_queries[0]
    assert user_intent in captured_queries[0]
    assert not any(
        chunk.payload
        and chunk.payload.get("event_type") == "chat.error"
        and "TeamSkillEvolutionRail" in str(chunk.payload.get("error", ""))
        for chunk in chunks
    )


@pytest.mark.anyio
async def test_process_team_message_stream_syncs_team_skills_before_evolve_slash(monkeypatch, tmp_path):
    captured_queries: list[str] = []
    user_intent = "没有特殊要求时格式尽量简洁,如果使用颜色也需要保持美观"

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def has_stream_task(session_id: str) -> bool:
            return False

        @staticmethod
        async def get_swarm_enriched_team_spec(**kwargs):
            return SimpleNamespace(
                team_name="unit-team",
                workspace=SimpleNamespace(root_path=str(tmp_path / "team-workspace")),
            )

        @staticmethod
        def ensure_team_shared_skills_ready_for_session(session_id: str, team_spec: object) -> None:
            _write_team_skill(tmp_path, "xlsx")

        @staticmethod
        async def prepare_runtime_activation(session_id: str, team_name: str) -> None:
            return None

        @staticmethod
        def register_stream_task(session_id: str, task: object) -> None:
            return None

    async def _fake_consume_stream_with_query(
        channel_id: str | None,
        session_id: str,
        spec: object,
        query: str,
        *,
        round_id: int,
        envs: dict | None = None,
        sessions_root=None,
    ) -> None:
        captured_queries.append(query)

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(team_helpers, "increment_session_round_count", lambda session_id: 1)
    monkeypatch.setattr(team_helpers, "_consume_stream_with_query", _fake_consume_stream_with_query)

    request = SimpleNamespace(
        session_id="sess-sync-evolve",
        request_id="req-sync-evolve",
        channel_id="web",
        metadata=None,
        params={"mode": "team"},
    )
    inputs = {"query": f"/evolve xlsx {user_intent}"}

    chunks = []
    async for chunk in team_helpers.process_team_message_stream(request, inputs, object()):
        chunks.append(chunk)
    await asyncio.sleep(0)

    assert captured_queries
    assert "prepare_skill_evolution" in captured_queries[0]
    assert user_intent in captured_queries[0]
    assert not any(
        chunk.payload
        and chunk.payload.get("event_type") == "chat.error"
        and "未找到 Skill 'xlsx'" in str(chunk.payload.get("error", ""))
        for chunk in chunks
    )


@pytest.mark.anyio
async def test_process_team_message_stream_runs_evolve_followup_without_rail(monkeypatch, tmp_path):
    captured_queries: list[str] = []
    _write_team_skill(tmp_path, "demo-skill")

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def has_stream_task(session_id: str) -> bool:
            return False

        @staticmethod
        async def get_swarm_enriched_team_spec(**kwargs):
            return SimpleNamespace(
                team_name="unit-team",
                workspace=SimpleNamespace(root_path=str(tmp_path / "team-workspace")),
            )

        @staticmethod
        def ensure_team_shared_skills_ready_for_session(session_id: str, team_spec: object) -> None:
            return None

        @staticmethod
        async def prepare_runtime_activation(session_id: str, team_name: str) -> None:
            return None

        @staticmethod
        def register_stream_task(session_id: str, task: object) -> None:
            return None

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(team_helpers, "increment_session_round_count", lambda session_id: 1)

    async def _fake_consume_stream_with_query(
        channel_id: str | None,
        session_id: str,
        spec: object,
        query: str,
        *,
        round_id: int,
        envs: dict | None = None,
        sessions_root=None,
    ) -> None:
        captured_queries.append(query)

    monkeypatch.setattr(team_helpers, "_consume_stream_with_query", _fake_consume_stream_with_query)

    request = SimpleNamespace(
        session_id="sess-team-evolve",
        request_id="req-team-evolve",
        channel_id="web",
        metadata=None,
    )
    inputs = {"query": "/evolve demo-skill improve review flow"}

    chunks = []
    async for chunk in team_helpers.process_team_message_stream(
            request,
            inputs,
            object(),
    ):
        chunks.append(chunk)

    await asyncio.sleep(0)
    assert captured_queries
    assert "prepare_skill_evolution" in captured_queries[0]
    assert chunks[-1].is_complete is True


@pytest.mark.anyio
async def test_process_team_message_stream_does_not_emit_evolution_status_for_no_evolve_records(monkeypatch, tmp_path):
    _write_team_skill(tmp_path, "demo-skill")

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def has_stream_task(session_id: str) -> bool:
            return False

        @staticmethod
        async def get_swarm_enriched_team_spec(**kwargs):
            return SimpleNamespace(
                team_name="unit-team",
                workspace=SimpleNamespace(root_path=str(tmp_path / "team-workspace")),
            )

        @staticmethod
        def ensure_team_shared_skills_ready_for_session(session_id: str, team_spec: object) -> None:
            return None

        @staticmethod
        async def prepare_runtime_activation(session_id: str, team_name: str) -> None:
            return None

        @staticmethod
        def register_stream_task(session_id: str, task: object) -> None:
            return None

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(team_helpers, "increment_session_round_count", lambda session_id: 1)

    async def _fake_consume_stream_with_query(*args, **kwargs) -> None:
        return None

    monkeypatch.setattr(team_helpers, "_consume_stream_with_query", _fake_consume_stream_with_query)

    request = SimpleNamespace(
        session_id="sess-team-evolve-noop",
        request_id="req-team-evolve-noop",
        channel_id="web",
        metadata=None,
    )
    inputs = {"query": "/evolve demo-skill improve review flow"}

    chunks = []
    async for chunk in team_helpers.process_team_message_stream(
            request,
            inputs,
            object(),
    ):
        chunks.append(chunk)

    assert [chunk.payload["event_type"] for chunk in chunks if chunk.payload] == []
    assert chunks[-1].is_complete is True


@pytest.mark.anyio
@pytest.mark.parametrize(
    "snapshot",
    [
        {"members": [{"member_id": "analyst", "status": "busy"}], "tasks": []},
        {
            "members": [{"member_id": "analyst", "status": "ready"}],
            "tasks": [{"task_id": "task-1", "status": "in_progress"}],
        },
    ],
)
async def test_team_round_settled_rejects_active_work(monkeypatch, snapshot):
    class _FakeMonitorHandler:
        async def get_team_snapshot(self):
            return snapshot

    class _FakeManager:
        @staticmethod
        def get_monitor_handler(session_id: str):
            return _FakeMonitorHandler()

        @staticmethod
        def get_workflow_handler(session_id: str):
            return None

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())

    assert not await _TeamHelpersTestApi.team_round_settled("officeclaw", "sess-active")


@pytest.mark.anyio
@pytest.mark.parametrize("monitor_state", [None, [], RuntimeError("snapshot failed")])
async def test_team_round_settled_rejects_missing_or_invalid_monitor_state(
    monkeypatch,
    monitor_state,
):
    class _FakeMonitorHandler:
        async def get_team_snapshot(self):
            if isinstance(monitor_state, Exception):
                raise monitor_state
            return monitor_state

    class _FakeManager:
        @staticmethod
        def get_monitor_handler(session_id: str):
            if monitor_state is None:
                return None
            return _FakeMonitorHandler()

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())

    assert not await _TeamHelpersTestApi.team_round_settled("officeclaw", "sess-invalid")


@pytest.mark.anyio
async def test_team_round_settled_accepts_idle_empty_board(monkeypatch):
    class _FakeMessageManager:
        @staticmethod
        async def has_unread_messages(*, include_broadcast: bool) -> bool:
            return False

    class _FakeMonitorHandler:
        _monitor = SimpleNamespace(
            _team_agent=SimpleNamespace(
                team_backend=SimpleNamespace(message_manager=_FakeMessageManager())
            )
        )

        async def get_team_snapshot(self):
            return {
                "members": [
                    {"member_id": "leader", "status": "ready"},
                    {"member_id": "analyst", "status": "unstarted"},
                ],
                "tasks": [],
            }

    class _FakeManager:
        @staticmethod
        def get_monitor_handler(session_id: str):
            return _FakeMonitorHandler()

        @staticmethod
        def get_workflow_handler(session_id: str):
            return None

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())

    assert await _TeamHelpersTestApi.team_round_settled("officeclaw", "sess-idle")


@pytest.mark.anyio
async def test_team_round_settled_rejects_unread_messages(monkeypatch):
    class _FakeMessageManager:
        @staticmethod
        async def has_unread_messages(*, include_broadcast: bool) -> bool:
            return True

    class _FakeMonitorHandler:
        _monitor = SimpleNamespace(
            _team_agent=SimpleNamespace(
                team_backend=SimpleNamespace(message_manager=_FakeMessageManager())
            )
        )

        async def get_team_snapshot(self):
            return {"members": [{"member_id": "leader", "status": "ready"}], "tasks": []}

    class _FakeManager:
        @staticmethod
        def get_monitor_handler(session_id: str):
            return _FakeMonitorHandler()

        @staticmethod
        def get_workflow_handler(session_id: str):
            return None

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())

    assert not await _TeamHelpersTestApi.team_round_settled("officeclaw", "sess-unread")


@pytest.mark.anyio
@pytest.mark.parametrize("relay_pending", [True, False])
async def test_team_round_settled_honors_pending_relay_turn(monkeypatch, relay_pending):
    """A pending relay turn blocks the edge settle; a resolved one lets it pass."""

    class _FakeMessageManager:
        @staticmethod
        async def has_unread_messages(*, include_broadcast: bool) -> bool:
            return False

    class _FakeBackend:
        message_manager = _FakeMessageManager()

        # A SimpleNamespace backend without this attribute (older backend)
        # still passes: the probe is hasattr/callable-guarded.
        async def has_pending_relay_turn(self) -> bool:
            return relay_pending

    class _FakeMonitorHandler:
        _monitor = SimpleNamespace(
            _team_agent=SimpleNamespace(team_backend=_FakeBackend())
        )

        async def get_team_snapshot(self):
            return {"members": [{"member_id": "leader", "status": "ready"}], "tasks": []}

    class _FakeManager:
        @staticmethod
        def get_monitor_handler(session_id: str):
            return _FakeMonitorHandler()

        @staticmethod
        def get_workflow_handler(session_id: str):
            return None

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())

    settled = await _TeamHelpersTestApi.team_round_settled("officeclaw", "sess-relay")
    assert settled is (not relay_pending)


@pytest.mark.anyio
async def test_team_round_settled_rejects_active_workflow(monkeypatch):
    class _FakeMonitorHandler:
        async def get_team_snapshot(self):
            return {"members": [], "tasks": []}

    class _FakeManager:
        @staticmethod
        def get_monitor_handler(session_id: str):
            return _FakeMonitorHandler()

        @staticmethod
        def get_workflow_handler(session_id: str):
            return SimpleNamespace(
                get_run_states=lambda: {
                    "run-1": team_helpers.WorkflowRunState(status="running"),
                }
            )

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())

    assert not await _TeamHelpersTestApi.team_round_settled("officeclaw", "sess-workflow")


@pytest.mark.anyio
async def test_team_round_settled_accepts_terminal_workflow(monkeypatch):
    class _FakeMonitorHandler:
        async def get_team_snapshot(self):
            return {"members": [], "tasks": []}

    class _FakeManager:
        @staticmethod
        def get_monitor_handler(session_id: str):
            return _FakeMonitorHandler()

        @staticmethod
        def get_workflow_handler(session_id: str):
            return SimpleNamespace(
                get_run_states=lambda: {
                    "run-1": team_helpers.WorkflowRunState(status="completed"),
                }
            )

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())

    assert await _TeamHelpersTestApi.team_round_settled("officeclaw", "sess-workflow-done")


def test_team_stream_factory_uses_core_global_runner(monkeypatch):
    expected_stream = object()
    calls: list[dict] = []

    class _FakeGlobalRunner:
        @staticmethod
        def run_agent_team_streaming(**kwargs):
            calls.append(kwargs)
            return expected_stream

    monkeypatch.setattr(
        team_helpers,
        "_get_global_team_runner",
        lambda: _FakeGlobalRunner(),
        raising=False,
    )

    factory = getattr(team_helpers, "_run_agent_team_streaming")
    stream = factory(agent_team="demo-team", inputs={"query": "hello"}, session="sess-1")

    assert stream is expected_stream
    assert calls == [
        {
            "agent_team": "demo-team",
            "inputs": {"query": "hello"},
            "session": "sess-1",
        }
    ]


@pytest.mark.anyio
async def test_leader_direct_answer_finishes_settled_round(monkeypatch):
    broadcasted: list[dict] = []
    closed: list[str] = []
    popped: list[str] = []

    async def _hanging_stream(**kwargs):
        try:
            yield {"event_type": "chat.delta", "content": "你好"}
            yield {"event_type": "chat.final", "content": "你好,我是团队负责人。"}
            await asyncio.Event().wait()
        finally:
            closed.append("closed")

    class _FakeMonitorHandler:
        async def get_team_snapshot(self):
            return {"members": [], "tasks": []}

    class _FakeRunner:
        run_agent_team_streaming = staticmethod(_hanging_stream)

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def clear_pending_runtime(session_id: str) -> None:
            pass

        @staticmethod
        def clear_active_runtime(session_id: str) -> None:
            pass

        @staticmethod
        def get_monitor_handler(session_id: str):
            return _FakeMonitorHandler()

        @staticmethod
        def pop_stream_task(session_id: str) -> None:
            assert closed == ["closed"]
            popped.append(session_id)

    fake_mgr = _FakeManager()
    monkeypatch.setattr(
        team_helpers,
        "_run_agent_team_streaming",
        _FakeRunner.run_agent_team_streaming,
    )
    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: fake_mgr)
    monkeypatch.setattr(
        team_helpers,
        "_broadcast_event",
        lambda channel_id, session_id, event: broadcasted.append(event),
    )

    await asyncio.wait_for(
        _TeamHelpersTestApi.consume_stream_with_query(
            "officeclaw",
            "sess-direct-answer",
            SimpleNamespace(team_name="demo-team"),
            "你好",
        ),
        timeout=0.5,
    )

    event_types = [event.get("event_type") for event in broadcasted]
    assert event_types.index("chat.final") < event_types.index("team.completed")
    assert popped == ["sess-direct-answer"]
    assert closed == ["closed"]


@pytest.mark.anyio
@pytest.mark.parametrize("failure_mode", ["empty", "exception"])
async def test_team_stream_errors_include_structured_code(monkeypatch, failure_mode):
    """Team 流本地错误必须携带稳定 code,避免错误文本中的 403 被误判。"""
    broadcasted: list[dict] = []

    async def _failing_stream(**kwargs):
        if failure_mode == "exception":
            raise RuntimeError("upstream returned 403 while retrying")
        if False:
            yield None

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def clear_pending_runtime(session_id: str) -> None:
            pass

        @staticmethod
        def clear_active_runtime(session_id: str) -> None:
            pass

        @staticmethod
        def pop_stream_task(session_id: str) -> None:
            pass

    monkeypatch.setattr(team_helpers, "_run_agent_team_streaming", _failing_stream)
    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(
        team_helpers,
        "_broadcast_event",
        lambda channel_id, session_id, event: broadcasted.append(event),
    )

    await _TeamHelpersTestApi.consume_stream_with_query(
        "officeclaw",
        f"sess-{failure_mode}",
        SimpleNamespace(team_name="demo-team"),
        "hello",
    )

    errors = [event for event in broadcasted if event.get("event_type") == "chat.error"]
    assert len(errors) == 1
    assert errors[0]["code"] == "team_stream_error"


@pytest.mark.anyio
@pytest.mark.parametrize(
    "blocker",
    ["busy_member", "open_task", "unread_message", "active_workflow"],
)
async def test_leader_final_keeps_unsettled_round_open(monkeypatch, blocker):
    final_broadcasted = asyncio.Event()
    broadcasted: list[dict] = []
    closed: list[str] = []

    async def _hanging_stream(**kwargs):
        try:
            yield {"event_type": "chat.final", "content": "阶段性结论"}
            await asyncio.Event().wait()
        finally:
            closed.append("closed")

    snapshot = {"members": [{"member_id": "leader", "status": "ready"}], "tasks": []}
    if blocker == "busy_member":
        snapshot["members"].append({"member_id": "analyst", "status": "busy"})
    elif blocker == "open_task":
        snapshot["tasks"].append({"task_id": "task-1", "status": "in_progress"})

    class _FakeMessageManager:
        @staticmethod
        async def has_unread_messages(*, include_broadcast: bool) -> bool:
            return blocker == "unread_message"

    class _FakeMonitorHandler:
        _monitor = SimpleNamespace(
            _team_agent=SimpleNamespace(
                team_backend=SimpleNamespace(message_manager=_FakeMessageManager())
            )
        )

        async def get_team_snapshot(self):
            return snapshot

    class _FakeRunner:
        run_agent_team_streaming = staticmethod(_hanging_stream)

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def clear_pending_runtime(session_id: str) -> None:
            pass

        @staticmethod
        def clear_active_runtime(session_id: str) -> None:
            pass

        @staticmethod
        def get_monitor_handler(session_id: str):
            return _FakeMonitorHandler()

        @staticmethod
        def get_workflow_handler(session_id: str):
            if blocker != "active_workflow":
                return None
            return SimpleNamespace(
                get_run_states=lambda: {
                    "run-1": team_helpers.WorkflowRunState(status="running"),
                }
            )

        @staticmethod
        def pop_stream_task(session_id: str) -> None:
            pass

    def _record_broadcast(channel_id, session_id, event):
        broadcasted.append(event)
        if event.get("event_type") == "chat.final":
            final_broadcasted.set()

    monkeypatch.setattr(
        team_helpers,
        "_run_agent_team_streaming",
        _FakeRunner.run_agent_team_streaming,
    )
    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(team_helpers, "_broadcast_event", _record_broadcast)

    consumer = asyncio.create_task(
        _TeamHelpersTestApi.consume_stream_with_query(
            "officeclaw",
            f"sess-{blocker}",
            SimpleNamespace(team_name="demo-team"),
            "继续处理",
        )
    )
    await asyncio.wait_for(final_broadcasted.wait(), timeout=0.5)
    await asyncio.sleep(0)

    assert not consumer.done()
    assert not any(event.get("event_type") == "team.completed" for event in broadcasted)

    consumer.cancel()
    with pytest.raises(asyncio.CancelledError):
        await consumer
    assert closed == ["closed"]


@pytest.mark.anyio
async def test_member_settle_edge_closes_stream_without_second_leader_final(monkeypatch):
    """Repro for the 10:41 hang: the leader's chat.final arrives while a member
    is still busy (first settle check False -> stream stays open), then a member
    transitions to ready — the member-settle edge re-evaluates settle and closes
    the stream with exactly one is_complete, without a second leader chat.final.
    """
    broadcasted: list[dict] = []
    closed: list[str] = []

    async def _hanging_stream(**kwargs):
        try:
            # Leader final arrives while a member is busy -> first settle check
            # is False, so the stream must stay open (no is_complete yet).
            yield {"event_type": "chat.final", "content": "等待回复"}
            # Member transitions to ready -> the settle edge must fire and close.
            yield {
                "event_type": "team.member",
                "event": {
                    "type": "team.member.status_changed",
                    "member_id": "run1:analyst",
                    "old_status": "busy",
                    "new_status": "ready",
                },
            }
            await asyncio.Event().wait()  # hang if the edge does not fire
        finally:
            closed.append("closed")

    class _FakeMessageManager:
        @staticmethod
        async def has_unread_messages(*, include_broadcast: bool) -> bool:
            return False

    class _FakeMonitorHandler:
        _monitor = SimpleNamespace(
            _team_agent=SimpleNamespace(
                team_backend=SimpleNamespace(message_manager=_FakeMessageManager())
            )
        )

        def __init__(self) -> None:
            self._calls = 0

        async def get_team_snapshot(self):
            # First settle check (leader chat.final): a member is busy -> not settled.
            # Subsequent check (member->ready edge): all members ready -> settled.
            self._calls += 1
            if self._calls <= 1:
                return {"members": [{"member_id": "run1:analyst", "status": "busy"}], "tasks": []}
            return {"members": [{"member_id": "run1:analyst", "status": "ready"}], "tasks": []}

    shared_monitor = _FakeMonitorHandler()

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def clear_pending_runtime(session_id: str) -> None:
            pass

        @staticmethod
        def clear_active_runtime(session_id: str) -> None:
            pass

        @staticmethod
        def get_monitor_handler(session_id: str):
            return shared_monitor

        @staticmethod
        def get_workflow_handler(session_id: str):
            return None

        @staticmethod
        def claim_round_complete(session_id: str) -> bool:
            return True

        @staticmethod
        def pop_stream_task(session_id: str) -> None:
            pass

    monkeypatch.setattr(team_helpers, "_run_agent_team_streaming", _hanging_stream)
    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(team_helpers, "append_history_record", lambda **kwargs: None)
    monkeypatch.setattr(
        team_helpers,
        "_broadcast_event",
        lambda channel_id, session_id, event: broadcasted.append(event),
    )

    await asyncio.wait_for(
        _TeamHelpersTestApi.consume_stream_with_query(
            "officeclaw",
            "sess-member-settle",
            SimpleNamespace(team_name="demo-team"),
            "你好",
        ),
        timeout=0.5,
    )

    # Exactly one is_complete frame, emitted by the member->ready edge.
    is_complete = [
        e for e in broadcasted
        if e.get("event_type") == "chat.processing_status" and e.get("is_complete")
    ]
    assert len(is_complete) == 1
    # Exactly one leader chat.final (the one that arrived while busy); the
    # member->ready edge must NOT require a second leader chat.final.
    finals = [e for e in broadcasted if e.get("event_type") == "chat.final"]
    assert len(finals) == 1
    # The stream closed (member-settle edge fired, did not hang).
    assert closed == ["closed"]


@pytest.mark.anyio
@pytest.mark.parametrize("usage_scope_location", ["payload", "metadata"])
async def test_consume_stream_with_query_broadcasts_leader_and_teammate_outputs(monkeypatch, usage_scope_location):
    broadcasted: list[dict] = []
    ready_calls: list[tuple[str, str]] = []

    async def _fake_stream(**kwargs):
        yield SimpleNamespace(
            type="team.runtime_ready",
            payload={
                "event_type": "team.runtime_ready",
                "team_name": "demo-team",
                "activation_kind": "create",
            },
            role=TeamRole.LEADER,
        )
        yield SimpleNamespace(
            type="llm_usage",
            payload={
                "metadata": {
                    "usage_metadata": {
                        "input_tokens": 12,
                        "output_tokens": 3,
                        "total_tokens": 15,
                        "model_name": "glm-5.3",
                    },
                },
            },
            role=TeamRole.LEADER,
            source_member="planner",
        )
        yield SimpleNamespace(
            type="llm_usage",
            payload={"usage_metadata": {
                "model_name": "deepseek-v4.1-flash", "input_tokens": 10,
                "output_tokens": 2, "total_tokens": 12,
            }},
            role=TeamRole.TEAMMATE,
            source_member="analyst",
        )
        tool_usage = {
            "usage_metadata": {
                "model_name": "tool-model", "input_tokens": 8,
                "output_tokens": 1, "total_tokens": 9,
            },
            "plan_name": "slides", "task_id": "task-slides", "stream_source_id": "pptxpage_1",
        }
        yield SimpleNamespace(
            type="llm_usage",
            payload=tool_usage if usage_scope_location == "payload" else {"metadata": tool_usage},
            role=TeamRole.LEADER,
            source_member="planner",
        )
        yield SimpleNamespace(
            type="answer",
            payload={"output": {"output": "leader answer"}, "result_type": "answer"},
            role=TeamRole.LEADER,
        )
        yield SimpleNamespace(
            type="llm_reasoning",
            payload={"content": "teammate private reasoning"},
            role=TeamRole.TEAMMATE,
            source_member="analyst",
        )
        yield SimpleNamespace(
            type="tool_call",
            payload={"tool_call": {"name": "read_file", "arguments": {"path": "notes.md"}}},
            role=TeamRole.TEAMMATE,
            member_name="analyst",
        )
        yield SimpleNamespace(
            type="answer",
            payload={"output": {"output": "teammate answer"}, "result_type": "answer"},
            role=TeamRole.TEAMMATE,
            source_member="analyst",
        )
        yield SimpleNamespace(
            type="answer",
            payload={"output": {"output": "human answer"}, "result_type": "answer"},
            role=SimpleNamespace(value=TeamRole.HUMAN_AGENT.value),
            source_member="human_agent",
        )
        yield SimpleNamespace(
            type="team.completed",
            payload={"event_type": "team.completed"},
            role=TeamRole.LEADER,
        )

    class _FakeRunner:
        run_agent_team_streaming = staticmethod(_fake_stream)

        @staticmethod
        async def get_agent_team_monitor(team_name: str, session_id: str, hide_dm: bool = False):
            return None

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def commit_runtime_ready(session_id: str, team_name: str) -> None:
            ready_calls.append((session_id, team_name))

        @staticmethod
        def clear_pending_runtime(session_id: str) -> None:
            pass

        @staticmethod
        def pop_stream_task(session_id: str) -> None:
            pass

        @staticmethod
        def get_monitor(session_id: str):
            return None

        @staticmethod
        async def attach_distributed_hooks_for_runner_runtime(
                team_name: str,
                session_id: str,
                channel_id: str,
        ) -> None:
            pass

        @staticmethod
        def resolve_team_agent(session_id: str):
            return None

        @staticmethod
        def get_workflow_handler(session_id: str):
            return None

        @staticmethod
        def register_workflow_handler(session_id: str, handler: object) -> None:
            pass

    monkeypatch.setattr(
        team_helpers,
        "_run_agent_team_streaming",
        _FakeRunner.run_agent_team_streaming,
    )
    monkeypatch.setattr(team_helpers, "Runner", _FakeRunner)
    fake_mgr = _FakeManager()
    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: fake_mgr)
    monkeypatch.setattr(
        team_helpers,
        "_broadcast_event",
        lambda channel_id, session_id, event: (
            broadcasted.append(event),
            fake_mgr.mark_seen_team_events(session_id)
            if event.get("event_type") in team_helpers._TEAM_BUILDING_EVENT_TYPES
            else None,
        ),
    )
    monkeypatch.setattr(team_helpers, "ensure_team_evolution_watcher", lambda *args, **kwargs: None)
    monkeypatch.setattr(team_helpers, "get_session_metadata", lambda session_id: {})
    monkeypatch.setattr(team_helpers, "update_session_metadata", lambda **kwargs: None)

    await _TeamHelpersTestApi.consume_stream_with_query(
        "web",
        "sess-leader-only",
        SimpleNamespace(team_name="demo-team"),
        "hello",
    )

    assert ready_calls == [("sess-leader-only", "demo-team")]
    # The inactive runtime never settles (_team_round_settled is False: the
    # manager exposes no monitor_handler) and never authorises completion
    # (claim_round_complete returns False). Until the team settles, NO
    # is_complete frame may be emitted — the "before-settle" invariant of
    # the per-round dedup contract.
    assert [event["event_type"] for event in broadcasted] == [
        "chat.processing_status",
        "team.runtime_ready",
        "chat.usage_metadata",
        "chat.usage_metadata",
        "chat.usage_metadata",
        'chat.final',
        'chat.reasoning',
        'chat.tool_call',
        'chat.final',
        'chat.final',
        'team.completed',
    ]
    usage_event = next(
        event for event in broadcasted if event["event_type"] == "chat.usage_metadata"
    )
    assert usage_event == {
        "event_type": "chat.usage_metadata",
        "metadata": {
            "usage_metadata": {
                "input_tokens": 12,
                "output_tokens": 3,
                "total_tokens": 15,
                "model_name": "glm-5.3",
            },
        },
        "session_id": "sess-leader-only",
        "rid": 1,
        "role": TeamRole.LEADER.value,
        "member_name": "planner",
    }
    assert [
        (event["role"], event["member_name"], event["metadata"]["usage_metadata"]["model_name"])
        for event in broadcasted if event["event_type"] == "chat.usage_metadata"
    ] == [
        ("leader", "planner", "glm-5.3"),
        ("teammate", "analyst", "deepseek-v4.1-flash"),
        ("leader", "planner", "tool-model"),
    ]
    tool_event = [event for event in broadcasted if event["event_type"] == "chat.usage_metadata"][-1]
    assert tool_event["metadata"] == {
        "usage_metadata": {"model_name": "tool-model", "input_tokens": 8, "output_tokens": 1, "total_tokens": 9},
        "plan_name": "slides", "task_id": "task-slides", "stream_source_id": "pptxpage_1",
    }
    assert not any(event["event_type"] == "chat.llm_usage" for event in broadcasted)
    reasoning_event = next(event for event in broadcasted if event["event_type"] == "chat.reasoning")
    assert reasoning_event["role"] == "teammate"
    assert reasoning_event["member_name"] == "analyst"
    tool_event = next(event for event in broadcasted if event["event_type"] == "chat.tool_call")
    assert tool_event["role"] == "teammate"
    assert tool_event["member_name"] == "analyst"
    # Round-start processing_status
    assert broadcasted[0]["is_processing"] is True
    assert broadcasted[0]["is_complete"] is False
    # Explicit "before-settle" invariant: no is_complete frame is emitted
    # while the round is unsettled — the leader chat.final keeps the round
    # open (helper returns False) and the team.completed poll path is
    # blocked by claim_round_complete.
    is_complete_frames = [
        event
        for event in broadcasted
        if event.get("event_type") == "chat.processing_status"
        and event.get("is_complete") is True
    ]
    assert is_complete_frames == []
    # The post-loop team.completed marker is still broadcast as the round's
    # terminal control event (carries no is_complete payload — the dedup
    # only governs processing_status(is_complete=True) frames).
    assert broadcasted[-1]["event_type"] == "team.completed"


@pytest.mark.anyio
async def test_consume_stream_with_query_broadcasts_leader_task_failed_detail_and_final(monkeypatch):
    broadcasted: list[dict] = []
    detail = (
        "[181001] model call failed, reason: openAI API async stream error: "
        "BadRequestError: deepseek-v4-X is invalid, use deepseek-v4-pro or deepseek-v4-flash"
    )

    pulled_after_failure = False

    async def _fake_stream(**kwargs):
        nonlocal pulled_after_failure
        yield SimpleNamespace(
            type="controller_output",
            payload={
                "type": "task_failed",
                "data": [{"type": "text", "text": detail}],
            },
            role=TeamRole.LEADER,
        )
        pulled_after_failure = True
        yield SimpleNamespace(
            type="llm_output",
            payload={"content": "should-not-forward"},
            role=TeamRole.LEADER,
        )

    class _FakeRunner:
        run_agent_team_streaming = staticmethod(_fake_stream)

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def clear_pending_runtime(session_id: str) -> None:
            pass

        @staticmethod
        def pop_stream_task(session_id: str) -> None:
            pass

    monkeypatch.setattr(
        team_helpers,
        "_run_agent_team_streaming",
        _FakeRunner.run_agent_team_streaming,
    )
    fake_mgr = _FakeManager()
    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: fake_mgr)
    monkeypatch.setattr(
        team_helpers,
        "_broadcast_event",
        lambda channel_id, session_id, event: (
            broadcasted.append(event),
            fake_mgr.mark_seen_team_events(session_id)
            if event.get("event_type") in team_helpers._TEAM_BUILDING_EVENT_TYPES
            else None,
        ),
    )

    await _TeamHelpersTestApi.consume_stream_with_query(
        "web",
        "sess-leader-error",
        SimpleNamespace(team_name="demo-team"),
        "hello",
    )

    assert [event["event_type"] for event in broadcasted] == [
        "chat.processing_status",
        "chat.error",
        "chat.final",
        "team.completed",
    ]
    assert "deepseek-v4-X" in broadcasted[1]["error"]
    assert "deepseek-v4-pro" in broadcasted[1]["error"]
    assert broadcasted[1]["rid"] == 1
    assert broadcasted[2] == {
        "event_type": "chat.final",
        "content": "",
        "session_id": "sess-leader-error",
        "rid": 1,
    }
    assert not any(
        event.get("event_type") == "chat.processing_status" and event.get("is_processing") is False
        for event in broadcasted
    )
    assert pulled_after_failure is False


@pytest.mark.anyio
async def test_consume_stream_with_query_does_not_final_teammate_task_failed(monkeypatch):
    broadcasted: list[dict] = []
    detail = (
        "[181001] model call failed, reason: openAI API async stream error: "
        "BadRequestError: deepseek-v4-X is invalid, use deepseek-v4-pro or deepseek-v4-flash"
    )

    async def _fake_stream(**kwargs):
        yield SimpleNamespace(
            type="controller_output",
            payload={
                "type": "task_failed",
                "data": [{"type": "text", "text": detail}],
            },
            role=TeamRole.TEAMMATE,
            source_member="analyst",
        )

    class _FakeRunner:
        run_agent_team_streaming = staticmethod(_fake_stream)

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def clear_pending_runtime(session_id: str) -> None:
            pass

        @staticmethod
        def pop_stream_task(session_id: str) -> None:
            pass

    monkeypatch.setattr(
        team_helpers,
        "_run_agent_team_streaming",
        _FakeRunner.run_agent_team_streaming,
    )
    fake_mgr = _FakeManager()
    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: fake_mgr)
    monkeypatch.setattr(
        team_helpers,
        "_broadcast_event",
        lambda channel_id, session_id, event: (
            broadcasted.append(event),
            fake_mgr.mark_seen_team_events(session_id)
            if event.get("event_type") in team_helpers._TEAM_BUILDING_EVENT_TYPES
            else None,
        ),
    )

    await _TeamHelpersTestApi.consume_stream_with_query(
        "web",
        "sess-teammate-error",
        SimpleNamespace(team_name="demo-team"),
        "hello",
    )

    assert [event["event_type"] for event in broadcasted] == [
        "chat.processing_status",
        "chat.error",
        "team.completed",
    ]
    assert "deepseek-v4-X" in broadcasted[1]["error"]
    assert broadcasted[1]["role"] == TeamRole.TEAMMATE.value
    assert broadcasted[1]["member_name"] == "analyst"


def test_extract_query_directives_strips_hide_dm_prefix_and_flags():
    cleaned, hide_dm, debug = _TeamHelpersTestApi.extract_query_directives(
        "/hide_dm please summarize"
    )
    assert hide_dm is True
    assert debug is False
    assert cleaned == "please summarize"


@pytest.mark.anyio
async def test_consume_stream_with_query_deduplicates_ask_user_questions(monkeypatch):
    broadcasted: list[dict] = []

    async def _fake_stream(**kwargs):
        yield SimpleNamespace(
            type="chat.ask_user_question",
            payload={
                "request_id": "tool-ask-1",
                "questions": [{"question": "请选择", "header": "选择", "options": []}],
            },
            role=TeamRole.LEADER,
        )
        yield SimpleNamespace(
            type="chat.ask_user_question",
            payload={
                "request_id": "tool-ask-1",
                "questions": [{"question": "请选择", "header": "选择", "options": []}],
            },
            role=TeamRole.LEADER,
        )

    class _FakeRunner:
        run_agent_team_streaming = staticmethod(_fake_stream)

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def clear_pending_runtime(session_id: str) -> None:
            pass

        @staticmethod
        def pop_stream_task(session_id: str) -> None:
            pass

    monkeypatch.setattr(
        team_helpers,
        "_run_agent_team_streaming",
        _FakeRunner.run_agent_team_streaming,
    )
    fake_mgr = _FakeManager()
    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: fake_mgr)
    monkeypatch.setattr(
        team_helpers,
        "_broadcast_event",
        lambda channel_id, session_id, event: (
            broadcasted.append(event),
            fake_mgr.mark_seen_team_events(session_id)
            if event.get("event_type") in team_helpers._TEAM_BUILDING_EVENT_TYPES
            else None,
        ),
    )

    await _TeamHelpersTestApi.consume_stream_with_query(
        "web",
        "sess-ask-dedupe",
        SimpleNamespace(team_name="demo-team"),
        "hello",
    )

    ask_events = [
        event
        for event in broadcasted
        if event.get("event_type") == "chat.ask_user_question"
    ]
    assert len(ask_events) == 1
    assert ask_events[0]["request_id"] == "tool-ask-1"


def test_extract_query_directives_ignores_non_prefix():
    cleaned, hide_dm, debug = _TeamHelpersTestApi.extract_query_directives(
        "/hide_dmsomething else"
    )
    assert hide_dm is False
    assert debug is False
    assert cleaned == "/hide_dmsomething else"


def test_extract_query_directives_handles_bare_hide_dm():
    cleaned, hide_dm, debug = _TeamHelpersTestApi.extract_query_directives("/hide_dm")
    assert hide_dm is True
    assert debug is False
    assert cleaned == ""


@pytest.mark.anyio
async def test_consume_stream_with_query_propagates_hide_dm_to_monitor(monkeypatch):
    captured: dict[str, object] = {}

    async def _fake_stream(**kwargs):
        yield SimpleNamespace(
            type="team.runtime_ready",
            payload={
                "event_type": "team.runtime_ready",
                "team_name": "demo-team",
                "activation_kind": "create",
            },
            role=TeamRole.LEADER,
        )

    class _FakeRunner:
        run_agent_team_streaming = staticmethod(_fake_stream)

        @staticmethod
        async def get_agent_team_monitor(team_name: str, session_id: str, hide_dm: bool = False):
            captured["team_name"] = team_name
            captured["session_id"] = session_id
            captured["hide_dm"] = hide_dm
            return None

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def commit_runtime_ready(session_id: str, team_name: str) -> None:
            pass

        @staticmethod
        def clear_pending_runtime(session_id: str) -> None:
            pass

        @staticmethod
        def pop_stream_task(session_id: str) -> None:
            pass

        @staticmethod
        def get_monitor(session_id: str):
            return None

        @staticmethod
        async def attach_distributed_hooks_for_runner_runtime(
                team_name: str,
                session_id: str,
                channel_id: str,
        ) -> None:
            pass

        @staticmethod
        def resolve_team_agent(session_id: str):
            return None

    monkeypatch.setattr(
        team_helpers,
        "_run_agent_team_streaming",
        _FakeRunner.run_agent_team_streaming,
    )
    monkeypatch.setattr(team_helpers, "Runner", _FakeRunner)
    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(team_helpers, "_broadcast_event", lambda *args, **kwargs: None)
    monkeypatch.setattr(team_helpers, "get_session_metadata", lambda session_id: {})
    monkeypatch.setattr(team_helpers, "update_session_metadata", lambda **kwargs: None)

    await _TeamHelpersTestApi.consume_stream_with_query(
        "web",
        "sess-hide-dm",
        SimpleNamespace(team_name="demo-team"),
        "hello",
        round_id=1,
        envs={"hide_dm": True},
    )

    assert captured == {
        "team_name": "demo-team",
        "session_id": "sess-hide-dm",
        "hide_dm": True,
    }


@pytest.mark.anyio
async def test_handle_team_slash_command_requires_skill_name_for_bare_evolve():
    result = await _TeamHelpersTestApi.handle_team_slash_command(
        "web",
        "sess-team-evolve",
        "/evolve",
    )

    assert result == {
        "output": "请补充 Skill 名称:`/evolve <skill_name> [user_query]`",
        "result_type": "error",
    }


@pytest.mark.anyio
async def test_handle_team_slash_command_submits_evolve_request_without_intent(tmp_path):
    skills_dir = _write_team_skill(tmp_path, "demo-skill")

    result = await _TeamHelpersTestApi.handle_team_slash_command(
        "web",
        "sess-team-evolve",
        "/evolve demo-skill",
        skills_dir=skills_dir,
    )

    assert result is not None
    assert result["result_type"] == "followup"
    assert result["action"] == "run_evolve_followup"
    assert result["skill_name"] == "demo-skill"
    assert "prepare_skill_evolution" in result["followup_prompt"]
    assert 'subject={"kind": "swarm-skill", "name": "demo-skill"}' in result["followup_prompt"]
    assert 'user_intent=""' in result["followup_prompt"]


@pytest.mark.anyio
async def test_handle_team_slash_command_submits_explicit_evolve_request(tmp_path):
    skills_dir = _write_team_skill(tmp_path, "demo-skill")

    result = await _TeamHelpersTestApi.handle_team_slash_command(
        "web",
        "sess-team-evolve",
        "/evolve demo-skill improve review flow",
        skills_dir=skills_dir,
    )

    assert result is not None
    assert result["result_type"] == "followup"
    assert result["action"] == "run_evolve_followup"
    assert result["skill_name"] == "demo-skill"
    assert "prepare_skill_evolution" in result["followup_prompt"]
    assert 'subject={"kind": "swarm-skill", "name": "demo-skill"}' in result["followup_prompt"]
    assert "improve review flow" in result["followup_prompt"]


@pytest.mark.anyio
async def test_handle_team_slash_command_uses_regular_skill_subject_kind(tmp_path):
    skills_dir = _write_regular_skill(tmp_path, "regular-skill")

    result = await _TeamHelpersTestApi.handle_team_slash_command(
        "web",
        "sess-team-evolve",
        "/evolve regular-skill improve review flow",
        skills_dir=skills_dir,
    )

    assert result is not None
    assert result["result_type"] == "followup"
    assert result["action"] == "run_evolve_followup"
    assert result["skill_name"] == "regular-skill"
    assert 'subject={"kind": "skill", "name": "regular-skill"}' in result["followup_prompt"]
    assert "swarm-skill" not in result["followup_prompt"]


@pytest.mark.anyio
async def test_handle_team_slash_command_returns_agent_driven_followup_for_xlsx(tmp_path):
    user_intent = "没有特殊要求时格式尽量简洁,如果使用颜色也需要保持美观"
    skills_dir = _write_team_skill(tmp_path, "xlsx")

    result = await _TeamHelpersTestApi.handle_team_slash_command(
        "web",
        "sess-team-evolve",
        f"/evolve xlsx {user_intent}",
        skills_dir=skills_dir,
    )

    assert result is not None
    assert result["action"] == "run_evolve_followup"
    assert result["skill_name"] == "xlsx"
    assert result["result_type"] == "followup"
    assert user_intent in result["followup_prompt"]


@pytest.mark.anyio
async def test_handle_team_slash_command_reports_missing_skill(tmp_path):
    skills_dir = str(tmp_path / "team-workspace" / "skills")

    result = await _TeamHelpersTestApi.handle_team_slash_command(
        "web",
        "sess-team-evolve",
        "/evolve demo-skill improve review flow",
        skills_dir=skills_dir,
    )

    assert result is not None
    assert result["result_type"] == "error"
    assert "未找到 Skill 'demo-skill'" in result["output"]


@pytest.mark.anyio
async def test_handle_team_slash_command_simplify_reports_noop(tmp_path):
    skills_dir = _write_team_skill(tmp_path, "demo-skill")

    result = await _TeamHelpersTestApi.handle_team_slash_command(
        "web",
        "sess-team-simplify",
        "/evolve_simplify demo-skill",
        skills_dir=skills_dir,
    )

    assert result == {
        "output": "Skill 'demo-skill' 暂无演进经验,无需整理。",
        "result_type": "answer",
    }


@pytest.mark.anyio
async def test_handle_team_slash_command_lists_regular_skill_records(tmp_path):
    skills_dir = _write_regular_skill(
        tmp_path,
        "regular-skill",
        records=[_evolution_record("Improve regular retry flow")],
    )

    result = await _TeamHelpersTestApi.handle_team_slash_command(
        "web",
        "sess-team-evolve",
        "/evolve_list regular-skill",
        skills_dir=skills_dir,
    )

    assert result is not None
    assert result["result_type"] == "answer"
    assert 'Skill "regular-skill"' in result["output"]
    assert "Improve regular retry flow" in result["output"]


# ---------------------------------------------------------------------------
# WorkflowMonitorHandler integration tests
# ---------------------------------------------------------------------------


@pytest.mark.anyio
async def test_ensure_monitor_handlers_rebinds_replaced_pool_agent(monkeypatch):
    from jiuwenswarm.agents.harness.team.handlers.team_monitor_handler import (
        TeamMonitorHandler,
    )
    from jiuwenswarm.agents.harness.team.team_manager import TeamManager

    class _FakeMonitor:
        def __init__(self, team_agent: object) -> None:
            self._team_agent = team_agent
            self.team_name = "demo-team"
            self.stopped = False

        async def start(self) -> None:
            pass

        async def stop(self) -> None:
            self.stopped = True

        async def events(self):
            while not self.stopped:
                await asyncio.sleep(0.01)
            if False:
                yield None

    manager = TeamManager()
    old_agent = object()
    new_agent = object()
    stale = TeamMonitorHandler(_FakeMonitor(old_agent), "sess-monitor-rebind")
    await stale.start()
    manager.register_monitor("sess-monitor-rebind", stale)
    created: list[_FakeMonitor] = []

    async def fake_get_monitor(**kwargs):
        monitor = _FakeMonitor(new_agent)
        created.append(monitor)
        return monitor

    async def fake_pool_agent(team_name: str):
        assert team_name == "demo-team"
        return new_agent

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: manager)
    monkeypatch.setattr(team_helpers.Runner, "get_agent_team_monitor", fake_get_monitor)
    monkeypatch.setattr(
        team_helpers,
        "_current_pool_team_agent",
        fake_pool_agent,
        raising=False,
    )

    await team_helpers.ensure_monitor_handlers_for_active_runtime(
        "web",
        "sess-monitor-rebind",
        "demo-team",
    )

    current = manager.get_monitor("sess-monitor-rebind")
    assert stale._monitor.stopped is True
    assert current is not stale
    assert len(created) == 1
    assert current._monitor._team_agent is new_agent
    await current.stop()


@pytest.mark.anyio
async def test_ensure_monitor_handlers_keeps_current_pool_agent(monkeypatch):
    from jiuwenswarm.agents.harness.team.handlers.team_monitor_handler import (
        TeamMonitorHandler,
    )
    from jiuwenswarm.agents.harness.team.team_manager import TeamManager

    class _FakeMonitor:
        def __init__(self, team_agent: object) -> None:
            self._team_agent = team_agent
            self.team_name = "demo-team"
            self.stopped = False

        async def start(self) -> None:
            pass

        async def stop(self) -> None:
            self.stopped = True

        async def events(self):
            while not self.stopped:
                await asyncio.sleep(0.01)
            if False:
                yield None

    manager = TeamManager()
    current_agent = object()
    handler = TeamMonitorHandler(_FakeMonitor(current_agent), "sess-monitor-current")
    await handler.start()
    manager.register_monitor("sess-monitor-current", handler)

    async def fail_get_monitor(**kwargs):
        raise AssertionError("current monitor must not be rebuilt")

    async def fake_pool_agent(team_name: str):
        assert team_name == "demo-team"
        return current_agent

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: manager)
    monkeypatch.setattr(team_helpers.Runner, "get_agent_team_monitor", fail_get_monitor)
    monkeypatch.setattr(
        team_helpers,
        "_current_pool_team_agent",
        fake_pool_agent,
        raising=False,
    )

    await team_helpers.ensure_monitor_handlers_for_active_runtime(
        "web",
        "sess-monitor-current",
        "demo-team",
    )

    assert manager.get_monitor("sess-monitor-current") is handler
    assert handler._monitor.stopped is False
    await handler.stop()


@pytest.mark.anyio
async def test_ensure_monitor_handlers_creates_workflow_handler_when_swarmflow_enabled(monkeypatch):
    """creates a WorkflowMonitorHandler and registers it when enable_swarmflow=True."""
    registered_handlers: dict[str, object] = {}
    channel_id = "web"
    session_id = "sess-wf-int"
    team_name = "demo-team"

    class _FakeMonitor:
        async def start(self) -> None:
            pass

        async def stop(self) -> None:
            pass

        async def workflow_events(self):
            return
            yield

        async def events(self):
            return
            yield

    class _FakeRunner:
        @staticmethod
        async def get_agent_team_monitor(team_name: str, session_id: str, **kwargs):
            return _FakeMonitor()

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def get_monitor(sid: str):
            return None

        @staticmethod
        def register_monitor(sid: str, handler: object) -> None:
            pass

        @staticmethod
        def get_workflow_handler(sid: str):
            return registered_handlers.get(sid)

        @staticmethod
        def register_workflow_handler(sid: str, handler: object) -> None:
            registered_handlers[sid] = handler

    monkeypatch.setattr(team_helpers, "Runner", _FakeRunner)
    monkeypatch.setattr(team_helpers, "get_team_manager", lambda cid: _FakeManager())

    consume_calls: list[tuple] = []

    async def _fake_consume_wf(cid, sid, handler):
        consume_calls.append((cid, sid, handler))

    async def _fake_consume_monitor(cid, sid, handler):
        pass

    monkeypatch.setattr(team_helpers, "_consume_workflow_events", _fake_consume_wf)
    monkeypatch.setattr(team_helpers, "_consume_monitor_events", _fake_consume_monitor)

    await team_helpers.ensure_monitor_handlers_for_active_runtime(
        channel_id,
        session_id,
        team_name,
        options=team_helpers.TeamMonitorAttachOptions(enable_swarmflow=True),
    )

    wf_handler = registered_handlers.get(session_id)
    assert wf_handler is not None
    assert wf_handler.session_id == session_id
    assert wf_handler.is_running is True

    await asyncio.sleep(0)
    assert len(consume_calls) == 1
    assert consume_calls[0][0] == channel_id
    assert consume_calls[0][1] == session_id


@pytest.mark.anyio
async def test_ensure_monitor_handlers_skips_workflow_handler_when_swarmflow_disabled(monkeypatch):
    """not create WorkflowMonitorHandler when enable_swarmflow=False (the default)."""
    registered_wf_handlers: dict[str, object] = {}
    channel_id = "web"
    session_id = "sess-no-swarmflow"
    team_name = "demo-team"

    class _FakeMonitor:
        async def start(self) -> None:
            pass

        async def stop(self) -> None:
            pass

        async def events(self):
            return
            yield

    class _FakeRunner:
        @staticmethod
        async def get_agent_team_monitor(team_name: str, session_id: str, **kwargs):
            return _FakeMonitor()

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def get_monitor(sid: str):
            return None

        @staticmethod
        def register_monitor(sid: str, handler: object) -> None:
            pass

        @staticmethod
        def get_workflow_handler(sid: str):
            return registered_wf_handlers.get(sid)

        @staticmethod
        def register_workflow_handler(sid: str, handler: object) -> None:
            registered_wf_handlers[sid] = handler

    monkeypatch.setattr(team_helpers, "Runner", _FakeRunner)
    monkeypatch.setattr(team_helpers, "get_team_manager", lambda cid: _FakeManager())
    monkeypatch.setattr(team_helpers, "_consume_monitor_events", lambda *a: None)

    await team_helpers.ensure_monitor_handlers_for_active_runtime(
        channel_id,
        session_id,
        team_name,
        options=team_helpers.TeamMonitorAttachOptions(enable_swarmflow=False),
    )

    assert registered_wf_handlers.get(session_id) is None


@pytest.mark.anyio
async def test_consume_workflow_events_broadcasts_raw_for_tui(monkeypatch):
    """On the TUI channel _consume_workflow_events broadcasts workflow.updated as-is."""
    broadcasted: list[dict[str, object]] = []
    event = {
        "event_type": "workflow.updated",
        "session_id": "sess-wf-consume",
        "workflow": {"name": "test-flow", "status": "running"},
    }

    class _FakeWorkflowHandler:
        is_running = True

        async def events(self):
            yield event

    monkeypatch.setattr(team_helpers, "_broadcast_event", lambda *args: broadcasted.append(args[2]))

    handler = _FakeWorkflowHandler()
    await _TeamHelpersTestApi.consume_workflow_events(
        "tui", "sess-wf-consume", handler,
    )

    assert broadcasted == [event]


@pytest.mark.anyio
async def test_consume_workflow_events_converts_to_team_events_for_web(monkeypatch):
    """On a web channel _consume_workflow_events converts workflow.updated into team events."""
    broadcasted: list[dict[str, object]] = []
    event = {
        "event_type": "workflow.updated",
        "session_id": "sess-wf-web",
        "workflow": {
            "id": "run-9",
            "name": "test-flow",
            "status": "running",
            "phases": [
                {
                    "id": "planning-1",
                    "name": "planning",
                    "status": "running",
                    "agents": [
                        {"id": "researcher-1", "name": "researcher", "status": "running"}
                    ],
                }
            ],
        },
    }

    class _FakeWorkflowHandler:
        is_running = True

        async def events(self):
            yield event

    monkeypatch.setattr(team_helpers, "_broadcast_event", lambda *args: broadcasted.append(args[2]))

    handler = _FakeWorkflowHandler()
    await _TeamHelpersTestApi.consume_workflow_events(
        "web", "sess-wf-web", handler,
    )

    # No raw workflow.updated leaks to web; only team.* envelopes.
    assert broadcasted
    assert all(e["event_type"] in ("team.member", "team.task") for e in broadcasted)
    types = [e["event"]["type"] for e in broadcasted]
    assert "team.task.claimed" in types
    assert "team.member.spawned" in types


@pytest.mark.anyio
async def test_consume_stream_with_query_calls_ensure_workflow_handler_after_runtime_ready(monkeypatch):
    """After runtime_ready, calls ensure_workflow_handler_for_active_runtime if a team_agent is available."""
    calls: list[str] = []

    async def _fake_stream(**kwargs):
        yield SimpleNamespace(
            type="team.runtime_ready",
            payload={
                "event_type": "team.runtime_ready",
                "team_name": "demo-team",
                "activation_kind": "create",
            },
            role=TeamRole.LEADER,
        )

    class _FakeRunner:
        run_agent_team_streaming = staticmethod(_fake_stream)

    def _record_add_event_listener(cb):
        calls.append("add_event_listener")

    fake_team_agent = SimpleNamespace()
    fake_team_agent.add_event_listener = _record_add_event_listener

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def commit_runtime_ready(session_id: str, team_name: str) -> None:
            calls.append(f"commit:{session_id}:{team_name}")

        @staticmethod
        def clear_pending_runtime(session_id: str) -> None:
            pass

        @staticmethod
        def pop_stream_task(session_id: str) -> None:
            pass

        @staticmethod
        def get_monitor(session_id: str):
            return None

        @staticmethod
        async def attach_distributed_hooks_for_runner_runtime(**kwargs) -> None:
            calls.append("hooks")

        @staticmethod
        def resolve_team_agent(session_id: str):
            return fake_team_agent

        @staticmethod
        def get_workflow_handler(session_id: str):
            return None

        @staticmethod
        def register_workflow_handler(session_id: str, handler: object) -> None:
            calls.append("register_workflow_handler")

        @staticmethod
        def register_stream_task(session_id: str, task: asyncio.Task) -> None:
            calls.append("register_stream_task")

    async def _fake_monitor(*args, **kwargs):
        calls.append("ensure_monitor_handlers")

    monkeypatch.setattr(
        team_helpers,
        "_run_agent_team_streaming",
        _FakeRunner.run_agent_team_streaming,
    )
    monkeypatch.setattr(team_helpers, "get_team_manager", lambda cid: _FakeManager())
    monkeypatch.setattr(team_helpers, "_broadcast_event", lambda *a, **kw: None)
    monkeypatch.setattr(team_helpers, "sync_team_identity_metadata", lambda **kw: calls.append("sync"))
    monkeypatch.setattr(team_helpers, "ensure_monitor_handlers_for_active_runtime", _fake_monitor)
    monkeypatch.setattr(team_helpers, "ensure_team_evolution_watcher", lambda *a, **kw: calls.append("watcher"))
    monkeypatch.setattr(team_helpers, "get_session_metadata", lambda sid: {})
    monkeypatch.setattr(team_helpers, "update_session_metadata", lambda **kw: None)
    monkeypatch.setattr(team_helpers, "_consume_workflow_events", lambda *a: None)

    await _TeamHelpersTestApi.consume_stream_with_query(
        "web",
        "sess-wf-ready",
        SimpleNamespace(team_name="demo-team"),
        "hello",
    )

    # The merged function is called once for both monitor and workflow handler
    assert "ensure_monitor_handlers" in calls


class _CancellableStreamTask:
    """Minimal asyncio.Task stand-in: supports done/cancel/await like production code expects."""

    def __init__(self, *, cancelled: list[str], session_id: str) -> None:
        self._cancelled = cancelled
        self._session_id = session_id
        self._done = False

    def done(self) -> bool:
        return self._done

    def cancel(self) -> None:
        self._done = True

    def __await__(self):
        async def _finish() -> None:
            if self._done:
                self._cancelled.append(self._session_id)
                raise asyncio.CancelledError()
            await asyncio.Event().wait()

        return _finish().__await__()


def _make_cancellable_stream_task(*, cancelled: list[str], session_id: str) -> _CancellableStreamTask:
    return _CancellableStreamTask(cancelled=cancelled, session_id=session_id)


@pytest.mark.anyio
async def test_try_finish_cron_team_stream_cancels_background_task(monkeypatch):
    """Cron waiter should end the team stream once workflow completes and leader reports."""
    _CronFakeManager.reset()
    channel_id = "tui"
    session_id = "sess-cron-finish"
    waiter_key = (channel_id, session_id)

    cancelled: list[str] = []
    processing_done: list[dict[str, object]] = []

    _CronFakeManager._stream_tasks[session_id] = _make_cancellable_stream_task(
        cancelled=cancelled, session_id=session_id,
    )
    monkeypatch.setattr(team_helpers, "get_team_manager", lambda cid: _CronFakeManager)
    monkeypatch.setattr(
        team_helpers,
        "_broadcast_event",
        lambda cid, sid, event: processing_done.append(event),
    )

    _TeamHelpersTestApi.seed_cron_team_waiter(waiter_key, "cron-job-1:123")

    _TeamHelpersTestApi.try_finish_cron_team_stream(
        channel_id,
        session_id,
        {
            "event_type": "chat.final",
            "content": "最终报告即将生成,请稍候。",
            "rid": 7,
        },
    )
    _TeamHelpersTestApi.try_finish_cron_team_stream(
        channel_id,
        session_id,
        {
            "event_type": "workflow.updated",
            "workflow": {"status": "completed"},
        },
    )
    await asyncio.sleep(0)
    assert cancelled == []

    _TeamHelpersTestApi.try_finish_cron_team_stream(
        channel_id,
        session_id,
        {
            "event_type": "chat.final",
            "content": "## 审查完成\n\n最终建议: approve",
            "rid": 7,
        },
    )
    await asyncio.sleep(0)

    assert cancelled == [session_id]
    assert processing_done[-1]["event_type"] == "chat.processing_status"
    assert processing_done[-1]["is_processing"] is False
    _TeamHelpersTestApi.clear_cron_team_waiter(waiter_key)


@pytest.mark.anyio
async def test_try_finish_cron_team_stream_on_leader_final_without_team_completed(monkeypatch):
    """Harness teams may emit chat.final without team.completed."""
    _CronFakeManager.reset()
    channel_id = "tui"
    session_id = "sess-cron-final-only"
    waiter_key = (channel_id, session_id)

    cancelled: list[str] = []
    processing_done: list[dict[str, object]] = []

    _CronFakeManager._stream_tasks[session_id] = _make_cancellable_stream_task(
        cancelled=cancelled, session_id=session_id,
    )
    monkeypatch.setattr(team_helpers, "get_team_manager", lambda cid: _CronFakeManager)
    monkeypatch.setattr(
        team_helpers,
        "_broadcast_event",
        lambda cid, sid, event: processing_done.append(event),
    )
    monkeypatch.setattr(team_helpers, "_CRON_DELEGATION_GRACE_SECONDS", 0.0)

    _TeamHelpersTestApi.seed_cron_team_waiter(waiter_key, "cron-job-2:456")

    _TeamHelpersTestApi.try_finish_cron_team_stream(
        channel_id,
        session_id,
        {
            "event_type": "chat.final",
            "content": "## GLM vs DeepSeek\n\n对比汇总完成。",
            "rid": 3,
        },
    )
    await asyncio.sleep(0.05)

    assert cancelled == [session_id]
    assert processing_done[-1]["event_type"] == "chat.processing_status"
    assert processing_done[-1]["is_processing"] is False
    _TeamHelpersTestApi.clear_cron_team_waiter(waiter_key)


@pytest.mark.anyio
async def test_broadcast_team_state_snapshot_broadcasts_member_and_task_status(monkeypatch):
    broadcast_events: list[dict] = []

    class _FakeMonitorHandler:
        @staticmethod
        async def get_team_snapshot():
            return {
                "team_id": "team-snapshot-test",
                "members": [
                    {"member_id": "agent1", "status": "ready"},
                    {"member_id": "agent2", "status": "busy"},
                ],
                "tasks": [
                    {"task_id": "task-1", "status": "completed", "assignee": "agent1"},
                    {"task_id": "task-2", "status": "in_progress", "assignee": "agent2"},
                ],
            }

    class _FakeManager:
        @staticmethod
        def get_monitor_handler(session_id: str):
            return _FakeMonitorHandler()

        @staticmethod
        def get_active_team_name(session_id: str):
            return ""

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(
        team_helpers,
        "_broadcast_event",
        lambda cid, sid, event: broadcast_events.append(event),
    )

    await team_helpers._broadcast_team_state_snapshot("web", "sess-snapshot-test")

    # Verify member snapshots
    member_events = [e for e in broadcast_events if e.get("event_type") == "team.member"]
    assert len(member_events) == 2
    assert member_events[0]["event"]["member_id"] == "agent1"
    assert member_events[0]["event"]["new_status"] == "ready"
    assert member_events[1]["event"]["member_id"] == "agent2"
    assert member_events[1]["event"]["new_status"] == "busy"

    # Verify task snapshots
    task_events = [e for e in broadcast_events if e.get("event_type") == "team.task"]
    assert len(task_events) == 2
    assert task_events[0]["event"]["task_id"] == "task-1"
    assert task_events[0]["event"]["status"] == "completed"
    assert task_events[1]["event"]["task_id"] == "task-2"
    assert task_events[1]["event"]["status"] == "in_progress"


@pytest.mark.anyio
async def test_broadcast_team_state_snapshot_noop_when_no_monitor(monkeypatch):
    broadcast_events: list[dict] = []

    class _FakeManager:
        @staticmethod
        def get_monitor_handler(session_id: str):
            return None

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(
        team_helpers,
        "_broadcast_event",
        lambda cid, sid, event: broadcast_events.append(event),
    )

    await team_helpers._broadcast_team_state_snapshot("web", "sess-no-monitor")
    assert broadcast_events == []


@pytest.mark.anyio
async def test_broadcast_team_state_snapshot_task_event_carries_title_content_and_flags(monkeypatch):
    """The ``team.task.status_snapshot`` event must carry title/content and, when
    the snapshot task dict carries truncation flags (added by
    ``get_team_snapshot`` in T2.1), pass them through via ``t.get(...)`` so they
    are present ONLY when the field was actually truncated (absent otherwise)."""
    broadcast_events: list[dict] = []

    long_title = "T" * 542  # > 512 → truncated
    short_content = "do the research"  # ≤ 512 → not truncated

    class _FakeMonitorHandler:
        @staticmethod
        async def get_team_snapshot():
            # Mirror the shape produced by TeamMonitorHandler.get_team_snapshot
            # after T2.1: title truncated + flags, content plain (no flags).
            return {
                "team_id": "team-snap-trunc",
                "members": [],
                "tasks": [
                    {
                        "task_id": "task-trunc",
                        "team_name": "team-snap-trunc",
                        "title": "T" * 512 + "…(truncated, total 542 chars)",
                        "title_truncated": True,
                        "title_original_size": 542,
                        "content": short_content,
                        "status": "in_progress",
                        "assignee": "agent1",
                        "updated_at": None,
                    },
                    {
                        "task_id": "task-plain",
                        "team_name": "team-snap-trunc",
                        "title": "plain title",
                        "content": "plain content",
                        "status": "completed",
                        "assignee": None,
                        "updated_at": None,
                    },
                ],
            }

    class _FakeManager:
        @staticmethod
        def get_monitor_handler(session_id: str):
            return _FakeMonitorHandler()

        @staticmethod
        def get_active_team_name(session_id: str):
            return ""

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(
        team_helpers,
        "_broadcast_event",
        lambda cid, sid, event: broadcast_events.append(event),
    )
    # _persist_team_history_event hits a real DB path; stub it to a no-op so
    # the test stays isolated (production call unchanged).
    monkeypatch.setattr(team_helpers, "_persist_team_history_event", lambda *args, **kwargs: None)

    await team_helpers._broadcast_team_state_snapshot("web", "sess-snap-trunc")

    task_events = [e for e in broadcast_events if e.get("event_type") == "team.task"]
    assert len(task_events) == 2

    # Truncated task: title/content ride along, flags ride along (present).
    trunc_evt = task_events[0]["event"]
    assert trunc_evt["type"] == "team.task.status_snapshot"
    assert trunc_evt["task_id"] == "task-trunc"
    assert trunc_evt["title"] == "T" * 512 + "…(truncated, total 542 chars)"
    assert trunc_evt["content"] == short_content
    assert trunc_evt["title_truncated"] is True
    assert trunc_evt["title_original_size"] == 542
    # content was NOT truncated in the source dict, so the source has no
    # content_* flag keys. The broadcast uses ``t.get(...)`` (per spec) so
    # the event carries them as ``None`` (falsy) — the frontend treats them
    # as optional/truthy, so None is equivalent to "not truncated".
    assert trunc_evt["content_truncated"] is None
    assert trunc_evt["content_original_size"] is None
    # Non-body fields still present.
    assert trunc_evt["status"] == "in_progress"
    assert trunc_evt["assignee"] == "agent1"

    # Plain task: title/content ride along; flag keys present as None (t.get
    # on a source dict that omits them). Frontend reads truthiness → falsy.
    plain_evt = task_events[1]["event"]
    assert plain_evt["task_id"] == "task-plain"
    assert plain_evt["title"] == "plain title"
    assert plain_evt["content"] == "plain content"
    assert plain_evt["title_truncated"] is None
    assert plain_evt["title_original_size"] is None
    assert plain_evt["content_truncated"] is None
    assert plain_evt["content_original_size"] is None


# ---------------------------------------------------------------------------
# swarmflow workflow.updated -> web team.member / team.task conversion
# ---------------------------------------------------------------------------


def _wf_event(phases: list[dict], *, run_id: str = "run-1", name: str = "wf") -> dict:
    return {
        "event_type": "workflow.updated",
        "session_id": "sess-wf",
        "workflow": {"id": run_id, "name": name, "phases": phases},
    }


def test_workflow_updated_to_team_events_ignores_non_workflow_events():
    out = team_helpers._workflow_updated_to_team_events(
        {"event_type": "team.member", "event": {}}, "sess-wf", {}, {}, set()
    )
    assert out == []


def test_workflow_updated_to_team_events_planned_phase_creates_task():
    seen_phase, seen_agent, spawned = {}, {}, set()
    out = team_helpers._workflow_updated_to_team_events(
        _wf_event([{"id": "planning-1", "name": "planning", "status": "planned"}]),
        "sess-wf",
        seen_phase,
        seen_agent,
        spawned,
    )
    assert len(out) == 1
    ev = out[0]
    assert ev["event_type"] == "team.task"
    assert ev["session_id"] == "sess-wf"
    assert ev["event"]["type"] == "team.task.created"
    assert ev["event"]["task_id"] == "run-1:planning-1"
    assert ev["event"]["title"] == "planning"
    assert ev["event"]["team_id"] == "wf"


def test_workflow_updated_to_team_events_running_agent_spawns_member_and_claims_task():
    seen_phase, seen_agent, spawned = {}, {}, set()
    out = team_helpers._workflow_updated_to_team_events(
        _wf_event(
            [
                {
                    "id": "planning-1",
                    "name": "planning",
                    "status": "running",
                    "agents": [
                        {"id": "researcher-1", "name": "researcher", "status": "running"}
                    ],
                }
            ]
        ),
        "sess-wf",
        seen_phase,
        seen_agent,
        spawned,
    )
    types = [e["event"]["type"] for e in out]
    assert "team.task.claimed" in types
    assert "team.member.spawned" in types
    member = next(e for e in out if e["event"]["type"] == "team.member.spawned")
    assert member["event"]["member_id"] == "run-1:researcher-1"
    assert member["event"]["name"] == "researcher"
    # running agent should not also emit a status_changed
    assert "team.member.status_changed" not in types


def test_workflow_updated_to_team_events_dedups_repeated_running_delta():
    seen_phase, seen_agent, spawned = {}, {}, set()
    phases = [
        {
            "id": "planning-1",
            "name": "planning",
            "status": "running",
            "agents": [{"id": "researcher-1", "name": "researcher", "status": "running"}],
        }
    ]
    first = team_helpers._workflow_updated_to_team_events(
        _wf_event(phases), "sess-wf", seen_phase, seen_agent, spawned
    )
    assert first  # first delta emits events
    # Same delta again (e.g. another agent_started re-includes the running phase)
    second = team_helpers._workflow_updated_to_team_events(
        _wf_event(phases), "sess-wf", seen_phase, seen_agent, spawned
    )
    assert second == []  # no status change -> nothing re-emitted


def test_workflow_updated_to_team_events_agent_completed_changes_member_status():
    seen_phase, seen_agent, spawned = {}, {}, set()
    # First: agent running
    team_helpers._workflow_updated_to_team_events(
        _wf_event(
            [
                {
                    "id": "planning-1",
                    "name": "planning",
                    "status": "running",
                    "agents": [{"id": "researcher-1", "name": "researcher", "status": "running"}],
                }
            ]
        ),
        "sess-wf",
        seen_phase,
        seen_agent,
        spawned,
    )
    # Then: agent completed, phase completed
    out = team_helpers._workflow_updated_to_team_events(
        _wf_event(
            [
                {
                    "id": "planning-1",
                    "name": "planning",
                    "status": "completed",
                    "agents": [{"id": "researcher-1", "name": "researcher", "status": "completed"}],
                }
            ]
        ),
        "sess-wf",
        seen_phase,
        seen_agent,
        spawned,
    )
    types = [e["event"]["type"] for e in out]
    assert "team.task.completed" in types
    status_changed = next(e for e in out if e["event"]["type"] == "team.member.status_changed")
    assert status_changed["event"]["member_id"] == "run-1:researcher-1"
    assert status_changed["event"]["new_status"] == "completed"
    assert status_changed["event"]["old_status"] == "running"
    # already spawned -> no second spawn
    assert "team.member.spawned" not in types


def test_workflow_updated_to_team_events_first_sight_terminal_spawns_then_status():
    seen_phase, seen_agent, spawned = {}, {}, set()
    out = team_helpers._workflow_updated_to_team_events(
        _wf_event(
            [
                {
                    "id": "exec-1",
                    "name": "execution",
                    "status": "failed",
                    "agents": [{"id": "coder-1", "name": "coder", "status": "failed"}],
                }
            ]
        ),
        "sess-wf",
        seen_phase,
        seen_agent,
        spawned,
    )
    member_types = [e["event"]["type"] for e in out if e["event_type"] == "team.member"]
    assert member_types == ["team.member.spawned", "team.member.status_changed"]
    task = next(e for e in out if e["event_type"] == "team.task")
    assert task["event"]["type"] == "team.task.cancelled"


def test_persist_team_file_monitor_roots_replaces_stale_roots(monkeypatch: pytest.MonkeyPatch) -> None:
    """_persist_team_file_monitor_roots 应替换旧 root,而非累积合并。"""
    written: list[dict[str, Any]] = []
    write_kwargs: list[dict[str, Any]] = []

    def _fake_read_metadata(session_id: str, cache_bust: bool = False) -> dict[str, Any]:
        return {
            "session_id": session_id,
            "team_file_monitor_roots": ["/old/stale/workspace"],
        }

    def _fake_enqueue_write(
        session_id: str, metadata: dict[str, Any], **kwargs: Any
    ) -> None:
        written.append(metadata)
        write_kwargs.append(kwargs)

    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.session.session_metadata._read_metadata",
        _fake_read_metadata,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.session.session_metadata._enqueue_write",
        _fake_enqueue_write,
    )
    fake_home = Path("/team/home/unit-team")
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.team_helpers.team_home",
        lambda name: fake_home,
    )
    # independent_member_workspace 内部调用 openjiuwen 的 get_openjiuwen_home(),
    # 无法被 team_home patch 覆盖,这里显式 patch 以保持测试路径稳定。
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.team_helpers.independent_member_workspace",
        lambda name: fake_home / f"{name}_workspace",
    )

    team_spec = SimpleNamespace(
        team_name="unit-team",
        workspace=SimpleNamespace(root_path="/team/home/unit-team/team-workspace"),
        agents={
            "worker": SimpleNamespace(
                workspace=SimpleNamespace(root_path="/team/home/unit-team/workspaces/worker_workspace"),
            ),
        },
    )
    team_helpers._persist_team_file_monitor_roots("sess-1", team_spec)

    assert len(written) == 1
    persisted_roots = written[0]["team_file_monitor_roots"]
    # 旧 root 应被清除
    assert "/old/stale/workspace" not in persisted_roots
    # 新 root 应包含 team-workspace 和 member workspace(路径经 resolve 归一化)
    home = fake_home.resolve()
    assert str(home / "team-workspace") in persisted_roots
    assert str(home / "workspaces") in persisted_roots
    # session_id 经 _safe_segment sanitize(此处 "sess-1" 无特殊字符,保持原样)
    assert str(home / "sessions" / "sess-1" / "worktrees") in persisted_roots
    assert str(home / "workspaces" / "worker_workspace") in persisted_roots
    # 漏洞4修复: independent_member_workspace 路径也应被收集
    assert str(home / "worker_workspace") in persisted_roots
    assert write_kwargs[0]["sync_write"] is True
    assert write_kwargs[0]["preserve_pin_fields"] is True


def test_persist_team_file_monitor_roots_noop_when_unchanged(monkeypatch: pytest.MonkeyPatch) -> None:
    """当 roots 未变化时不应触发写盘。"""
    written: list[dict[str, Any]] = []
    fake_home = Path("/team/home/unit-team")

    expected_roots = [
        str(fake_home.resolve() / "team-workspace"),
        str(fake_home.resolve() / "workspaces"),
        str(fake_home.resolve() / "sessions" / "sess-1" / "worktrees"),
        str(fake_home.resolve() / "workspaces" / "worker_workspace"),
        # 漏洞4修复: independent_member_workspace 路径
        str(fake_home.resolve() / "worker_workspace"),
    ]

    def _fake_read_metadata(session_id: str, cache_bust: bool = False) -> dict[str, Any]:
        return {
            "session_id": session_id,
            "team_file_monitor_roots": list(expected_roots),
        }

    def _fake_enqueue_write(
        session_id: str, metadata: dict[str, Any], **kwargs: Any
    ) -> None:
        written.append(metadata)

    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.session.session_metadata._read_metadata",
        _fake_read_metadata,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.session.session_metadata._enqueue_write",
        _fake_enqueue_write,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.team_helpers.team_home",
        lambda name: fake_home,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.team_helpers.independent_member_workspace",
        lambda name: fake_home / f"{name}_workspace",
    )

    team_spec = SimpleNamespace(
        team_name="unit-team",
        workspace=SimpleNamespace(root_path="/team/home/unit-team/team-workspace"),
        agents={
            "worker": SimpleNamespace(
                workspace=SimpleNamespace(root_path="/team/home/unit-team/workspaces/worker_workspace"),
            ),
        },
    )
    team_helpers._persist_team_file_monitor_roots("sess-1", team_spec)

    assert len(written) == 0


@pytest.mark.anyio
async def test_consume_stream_injects_session_id_into_leader_ask_user_question(monkeypatch):
    """leader 的 chat.ask_user_question 透传事件必须带 session_id。

    relay 桥接提问/审批回答时优先取 payload.session_id;缺失会退化为
    sha256(userId+agentId+threadId) 哈希兜底,把回答寄到不存在的会话。
    """
    broadcasted: list[dict[str, Any]] = []

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def broadcast_event(session_id: str, event: dict) -> None:
            broadcasted.append(event)

        @staticmethod
        def get_monitor_handler(session_id: str):
            return None

        @staticmethod
        def clear_pending_runtime(session_id: str) -> None:
            pass

        @staticmethod
        def clear_active_runtime(session_id: str) -> None:
            pass

    async def _fake_stream(**kwargs):
        yield SimpleNamespace(
            type="__interaction__",
            role=TeamRole.LEADER,
            payload={"id": "call_test_ask_1", "value": {}},
        )

    monkeypatch.setattr(team_helpers, "_run_agent_team_streaming", _fake_stream)
    monkeypatch.setattr(
        team_helpers,
        "parse_stream_chunk",
        lambda chunk: {
            "event_type": "chat.ask_user_question",
            "request_id": "call_test_ask_1",
            "questions": [{"question": "q1", "options": []}],
            "source": "ask_user_interrupt",
        },
    )
    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())

    await _TeamHelpersTestApi.consume_stream_with_query(
        "officeclaw",
        "sess-ask-1",
        SimpleNamespace(team_name="spec-team"),
        "hello",
    )

    ask_events = [e for e in broadcasted if e.get("event_type") == "chat.ask_user_question"]
    assert len(ask_events) == 1
    assert ask_events[0]["session_id"] == "sess-ask-1"


@pytest.mark.anyio
async def test_consume_stream_does_not_inject_session_id_into_other_events(monkeypatch):
    """非 chat.ask_user_question 的透传事件不被注入 session_id(控制爆炸半径)。"""
    broadcasted: list[dict[str, Any]] = []

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def broadcast_event(session_id: str, event: dict) -> None:
            broadcasted.append(event)

        @staticmethod
        def get_monitor_handler(session_id: str):
            return None

        @staticmethod
        def clear_pending_runtime(session_id: str) -> None:
            pass

        @staticmethod
        def clear_active_runtime(session_id: str) -> None:
            pass

    async def _fake_stream(**kwargs):
        yield SimpleNamespace(type="llm_output", role=TeamRole.LEADER, payload="hi")

    monkeypatch.setattr(team_helpers, "_run_agent_team_streaming", _fake_stream)
    monkeypatch.setattr(
        team_helpers,
        "parse_stream_chunk",
        lambda chunk: {"event_type": "chat.delta", "content": "hi"},
    )
    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())

    await _TeamHelpersTestApi.consume_stream_with_query(
        "officeclaw",
        "sess-delta-1",
        SimpleNamespace(team_name="spec-team"),
        "hello",
    )

    delta_events = [e for e in broadcasted if e.get("event_type") == "chat.delta"]
    assert len(delta_events) == 1
    assert "session_id" not in delta_events[0]


@pytest.mark.anyio
async def test_round_complete_dedup_claim_then_reset():
    """claim_round_complete returns True once per round, False after; reset re-arms."""
    from jiuwenswarm.agents.harness.team.team_manager import TeamManager

    # Lightest path: bypass __init__, set only the dict under test.
    # If test_team_manager_registry.py has a real fixture, prefer it.
    tm = TeamManager.__new__(TeamManager)
    tm._round_complete_emitted = {}

    assert tm.claim_round_complete("s1") is True   # first claim
    assert tm.claim_round_complete("s1") is False   # second claim same round → idempotent
    tm.reset_round_complete("s1")
    assert tm.claim_round_complete("s1") is True    # re-armed after reset
    tm.reset_round_complete("never-existed")        # no-op, no KeyError


@pytest.mark.anyio
async def test_finish_round_if_settled_broadcasts_once_when_settled(monkeypatch):
    class _FakeMessageManager:
        @staticmethod
        async def has_unread_messages(*, include_broadcast: bool) -> bool:
            return False
    class _FakeMonitorHandler:
        _monitor = SimpleNamespace(
            _team_agent=SimpleNamespace(
                team_backend=SimpleNamespace(message_manager=_FakeMessageManager())
            )
        )
        async def get_team_snapshot(self):
            return {"members": [{"member_id": "leader", "status": "ready"}], "tasks": []}

    class _FakeManager(_InactiveTeamRuntimeManagerMixin):
        _claimed = {}
        @staticmethod
        def get_monitor_handler(session_id):
            return _FakeMonitorHandler()
        @staticmethod
        def get_workflow_handler(session_id):
            return None
        @staticmethod
        def claim_round_complete(session_id):
            if _FakeManager._claimed.get(session_id):
                return False
            _FakeManager._claimed[session_id] = True
            return True
        @staticmethod
        def reset_round_complete(session_id):
            _FakeManager._claimed.pop(session_id, None)

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    broadcasts: list[dict] = []
    monkeypatch.setattr(team_helpers, "_broadcast_event", lambda *a, **k: broadcasts.append(k.get("payload") or a[-1]))

    finish = getattr(team_helpers, "_finish_round_if_settled")
    closed = await finish("officeclaw", "sess", 1, reason="test")
    assert closed is True
    is_complete = [p for p in broadcasts if isinstance(p, dict) and p.get("event_type") == "chat.processing_status" and p.get("is_complete")]
    assert len(is_complete) == 1


@pytest.mark.anyio
async def test_finish_round_if_settled_no_broadcast_when_not_settled(monkeypatch):
    class _FakeMonitorHandler:
        async def get_team_snapshot(self):
            return {"members": [{"member_id": "leader", "status": "busy"}], "tasks": []}
    class _FakeManager:
        @staticmethod
        def get_monitor_handler(session_id):
            return _FakeMonitorHandler()
        @staticmethod
        def get_workflow_handler(session_id):
            return None
        @staticmethod
        def claim_round_complete(session_id):
            raise AssertionError("must not claim when not settled")

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    broadcasts: list[dict] = []
    monkeypatch.setattr(team_helpers, "_broadcast_event", lambda *a, **k: broadcasts.append(k.get("payload") or a[-1]))

    finish = getattr(team_helpers, "_finish_round_if_settled")
    closed = await finish("officeclaw", "sess", 1, reason="test")
    assert closed is False
    assert broadcasts == []


@pytest.mark.anyio
async def test_team_round_settled_empty_board_blocked_when_toggle_false(monkeypatch):
    class _FakeMessageManager:
        @staticmethod
        async def has_unread_messages(*, include_broadcast: bool) -> bool:
            return False
    class _FakeMonitorHandler:
        _monitor = SimpleNamespace(
            _team_agent=SimpleNamespace(
                team_backend=SimpleNamespace(message_manager=_FakeMessageManager())
            )
        )
        async def get_team_snapshot(self):
            return {"members": [{"member_id": "leader", "status": "ready"}], "tasks": []}
    class _FakeManager:
        @staticmethod
        def get_monitor_handler(session_id):
            return _FakeMonitorHandler()
        @staticmethod
        def get_workflow_handler(session_id):
            return None

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(team_helpers, "_taskless_completion_enabled", lambda session_id: False)

    assert not await _TeamHelpersTestApi.team_round_settled("officeclaw", "sess-toggle")


@pytest.mark.anyio
async def test_team_round_settled_empty_board_passes_when_toggle_true(monkeypatch):
    class _FakeMessageManager:
        @staticmethod
        async def has_unread_messages(*, include_broadcast: bool) -> bool:
            return False
    class _FakeMonitorHandler:
        _monitor = SimpleNamespace(
            _team_agent=SimpleNamespace(
                team_backend=SimpleNamespace(message_manager=_FakeMessageManager())
            )
        )
        async def get_team_snapshot(self):
            return {"members": [{"member_id": "leader", "status": "ready"}], "tasks": []}
    class _FakeManager:
        @staticmethod
        def get_monitor_handler(session_id):
            return _FakeMonitorHandler()
        @staticmethod
        def get_workflow_handler(session_id):
            return None

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel_id: _FakeManager())
    monkeypatch.setattr(team_helpers, "_taskless_completion_enabled", lambda session_id: True)

    assert await _TeamHelpersTestApi.team_round_settled("officeclaw", "sess-toggle")


def test_workflow_runs_persist_and_restore_honor_sessions_root(
    tmp_path: Path,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    from jiuwenswarm.agents.harness.team.handlers.workflow_state import WorkflowRunState

    correct_root = tmp_path / "agent_agentteam_sessions"
    wrong_root = tmp_path / "agent_default_sessions"
    correct_root.mkdir(parents=True)
    wrong_root.mkdir(parents=True)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.session.session_metadata.get_agent_sessions_dir",
        lambda: wrong_root,
    )

    run_state = WorkflowRunState(
        id="wf-1",
        name="demo",
        status="running",
    )
    from jiuwenswarm.server.runtime.session.session_metadata import _METADATA_QUEUE

    team_helpers.persist_workflow_runs(
        {"wf-1": run_state},
        "sess_wf_root",
        sessions_root=correct_root,
    )
    _METADATA_QUEUE.join()

    assert (correct_root / "sess_wf_root" / "metadata.json").is_file()
    assert not (wrong_root / "sess_wf_root" / "metadata.json").exists()

    restored = team_helpers.restore_workflow_runs(
        "sess_wf_root",
        sessions_root=correct_root,
    )
    assert restored is not None
    assert restored["wf-1"].id == "wf-1"


def _pool_info(state: str) -> SimpleNamespace:
    return SimpleNamespace(
        team_name="oc_team",
        current_session_id="sess",
        state=SimpleNamespace(value=state),
    )


@pytest.mark.asyncio
async def test_await_runner_pool_release_waits_until_running_entry_leaves(monkeypatch):
    snapshots = [[_pool_info("running")], []]
    stopped: list[dict[str, str]] = []

    async def _list_active_teams():
        return snapshots.pop(0)

    async def _stop_agent_team(**kwargs):
        stopped.append(kwargs)
        return True

    monkeypatch.setattr(team_helpers.Runner, "list_active_teams", _list_active_teams)
    monkeypatch.setattr(team_helpers.Runner, "stop_agent_team", _stop_agent_team)
    monkeypatch.setattr(team_helpers, "_POOL_RELEASE_POLL_S", 0.01)

    await team_helpers._await_runner_pool_release("oc_team", "sess")

    assert stopped == []
    assert snapshots == []


@pytest.mark.asyncio
async def test_await_runner_pool_release_leaves_paused_entry(monkeypatch):
    stopped: list[dict[str, str]] = []

    async def _list_active_teams():
        return [_pool_info("paused")]

    async def _stop_agent_team(**kwargs):
        stopped.append(kwargs)
        return True

    monkeypatch.setattr(team_helpers.Runner, "list_active_teams", _list_active_teams)
    monkeypatch.setattr(team_helpers.Runner, "stop_agent_team", _stop_agent_team)

    await team_helpers._await_runner_pool_release("oc_team", "sess")

    assert stopped == []


@pytest.mark.asyncio
async def test_await_runner_pool_release_stops_entry_that_stays_running(monkeypatch):
    stopped: list[dict[str, str]] = []

    async def _list_active_teams():
        return [_pool_info("running")]

    async def _stop_agent_team(**kwargs):
        stopped.append(kwargs)
        return True

    monkeypatch.setattr(team_helpers.Runner, "list_active_teams", _list_active_teams)
    monkeypatch.setattr(team_helpers.Runner, "stop_agent_team", _stop_agent_team)
    monkeypatch.setattr(team_helpers, "_POOL_RELEASE_TIMEOUT_S", 0)

    await team_helpers._await_runner_pool_release("oc_team", "sess")

    assert stopped == [{"team_name": "oc_team", "session_id": "sess"}]


def test_truncate_team_tool_result_clips_nested_raw_output_strings() -> None:
    limit = team_helpers._TEAM_TOOL_RESULT_TEXT_LIMIT
    full_markdown = "x" * (limit + 100)
    short_note = "ok"
    raw_output = {"result": full_markdown, "note": short_note}
    parsed = {
        "event_type": "chat.tool_result",
        "result": "y" * (limit + 10),
        "raw_output": raw_output,
        "tool_name": "read_file_content",
    }

    clipped = team_helpers._truncate_team_tool_result_event(parsed)

    assert clipped["truncated"] is True
    assert clipped["original_size"] == (limit + 10) + (limit + 100) + len(short_note)
    assert clipped["result"] == "y" * limit
    assert clipped["raw_output"]["result"] == "x" * limit
    assert clipped["raw_output"]["note"] == short_note
    assert clipped["tool_name"] == "read_file_content"
    assert raw_output["result"] == full_markdown
    assert parsed["raw_output"] is raw_output


def test_truncate_team_tool_result_leaves_short_nested_text_untouched() -> None:
    raw_output = {"result": "short", "rows": ["a", "b"]}
    parsed = {
        "event_type": "chat.tool_result",
        "result": "preview",
        "raw_output": raw_output,
    }

    clipped = team_helpers._truncate_team_tool_result_event(parsed)

    assert "truncated" not in clipped
    assert "original_size" not in clipped
    assert clipped["raw_output"] is raw_output


def test_truncate_team_tool_result_ignores_other_events() -> None:
    parsed = {"event_type": "chat.delta", "result": "z" * 1000}

    assert team_helpers._truncate_team_tool_result_event(parsed) is parsed


def test_truncate_team_tool_result_clips_top_level_list_and_tuple() -> None:
    limit = team_helpers._TEAM_TOOL_RESULT_TEXT_LIMIT
    long_text = "x" * (limit + 20)
    nested_text = "y" * (limit + 5)
    raw_list = [long_text, "ok", {"note": nested_text}]
    parsed = {"event_type": "chat.tool_result", "raw_output": raw_list}

    clipped = team_helpers._truncate_team_tool_result_event(parsed)

    assert isinstance(clipped["raw_output"], list)
    assert clipped["truncated"] is True
    assert clipped["original_size"] == (limit + 20) + len("ok") + (limit + 5)
    assert clipped["raw_output"][0] == "x" * limit
    assert clipped["raw_output"][1] == "ok"
    assert clipped["raw_output"][2]["note"] == "y" * limit
    assert raw_list[0] == long_text
    assert parsed["raw_output"] is raw_list

    raw_tuple = ("z" * (limit + 3), "ok")
    parsed_tuple = {"event_type": "chat.tool_result", "raw_output": raw_tuple}
    clipped_tuple = team_helpers._truncate_team_tool_result_event(parsed_tuple)

    assert isinstance(clipped_tuple["raw_output"], tuple)
    assert clipped_tuple["raw_output"][0] == "z" * limit
    assert clipped_tuple["raw_output"][1] == "ok"
    assert clipped_tuple["original_size"] == (limit + 3) + len("ok")
    assert raw_tuple[0] == "z" * (limit + 3)


@pytest.mark.anyio
@pytest.mark.parametrize("pending, settled, stopping", [(True, False, False), (False, True, True), (True, True, True)])
async def test_followup_rejects_stopping_before_snapshot_or_waiter(monkeypatch, pending, settled, stopping):
    class Manager(_InactiveTeamRuntimeManagerMixin):
        @staticmethod
        def has_stream_task(session_id):
            return True

        @staticmethod
        def has_pending_cancel(session_id):
            return pending

        @staticmethod
        async def wait_for_cancel_settled(session_id, timeout_sec):
            return settled

        @staticmethod
        async def is_runtime_stopping(session_id):
            return stopping

        def add_waiter(self, *args):
            pytest.fail("stopping runtime must retain its existing waiter")

        @staticmethod
        async def get_swarm_enriched_team_spec(**kwargs):
            return SimpleNamespace(team_name="unit-team")

        @staticmethod
        async def interact(*args):
            pytest.fail("unsettled cancellation must reject delivery")

        @staticmethod
        async def prepare_runtime_activation(*args):
            pytest.fail("unsettled cancellation must reject rebuild")

    from unittest.mock import AsyncMock
    snapshot = AsyncMock(side_effect=AssertionError("stopping runtime must not read snapshots"))
    monkeypatch.setattr(team_helpers, "_broadcast_team_state_snapshot", snapshot)
    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel: Manager())
    request = SimpleNamespace(session_id="s", request_id="r", channel_id="web",
                              metadata=None, params={"mode": "team"})
    chunks = [chunk async for chunk in team_helpers.process_team_message_stream(
        request, {"query": "continue"}, object())]
    assert any(chunk.payload and chunk.payload.get("code") == "team_stopping" for chunk in chunks)
    assert chunks[-1].is_complete

    snapshot.assert_not_awaited()


@pytest.mark.anyio
@pytest.mark.parametrize("replacement_stage", ["close", "chunks", "first", "error"])
async def test_old_stream_close_cannot_complete_or_clear_replacement(monkeypatch, replacement_stage):
    class Manager(_InactiveTeamRuntimeManagerMixin):
        owner = None
        cleared = []

        def owns_stream_task(self, session_id, task):
            return self.owner is task

        def clear_pending_runtime(self, session_id):
            self.cleared.append("pending")

        def clear_active_runtime(self, session_id):
            self.cleared.append("active")

        def pop_stream_task(self, session_id):
            self.cleared.append("stream")

    manager = Manager()
    replacement = object()
    events = []

    class Stream:
        chunks = 0

        def __aiter__(self):
            return self

        async def __anext__(self):
            if replacement_stage == "close":
                raise StopAsyncIteration
            self.chunks += 1
            replace_at = 3 if replacement_stage == "chunks" else 1
            if self.chunks == replace_at:
                manager.owner = replacement
                if replacement_stage == "error":
                    raise RuntimeError("old stream failed")
            return SimpleNamespace(
                type="llm_reasoning", payload={"content": f"old-{self.chunks}"}, role="leader",
            )

        async def aclose(self):
            # Reproduce a replacement registered while the old generator closes.
            manager.owner = replacement

    async def no_wait(*args):
        pass

    monkeypatch.setattr(team_helpers, "get_team_manager", lambda channel: manager)
    monkeypatch.setattr(team_helpers, "_run_agent_team_streaming", lambda **kwargs: Stream())
    monkeypatch.setattr(team_helpers, "_await_runner_pool_release", no_wait)
    monkeypatch.setattr(team_helpers, "_broadcast_event", lambda channel, session, event: events.append(event))
    monkeypatch.setattr(team_helpers.time, "monotonic", lambda: 0.0)
    manager.owner = asyncio.current_task()
    await _TeamHelpersTestApi.consume_stream_with_query("web", "s", SimpleNamespace(team_name="t"), "q")
    assert manager.owner is replacement
    assert not manager.cleared
    assert not any(event.get("event_type") == "team.completed" for event in events)
    assert not any(event.get("content") == "old-2" for event in events)
    errors = [event for event in events if event.get("event_type") == "chat.error"]
    assert len(errors) == (1 if replacement_stage == "close" else 0)