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

from __future__ import annotations

import asyncio
from types import SimpleNamespace

import pytest

from jiuwenswarm.server.runtime.agent_adapter import evolution_helpers
from jiuwenswarm.server.runtime.agent_adapter import interface_deep as interface_deep_module
from jiuwenswarm.server.runtime.agent_adapter.evolution_helpers import auto_rebuild_job
from jiuwenswarm.server.runtime.agent_adapter.interface_deep import JiuWenSwarmDeepAdapter


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)


def _approval_event(request_id: str = "team_skill_evolve_req1") -> SimpleNamespace:
    return SimpleNamespace(
        type="chat.ask_user_question",
        payload={"request_id": request_id, "questions": [{"header": "x"}]},
    )


def _outcome_event(status: str, message: str) -> SimpleNamespace:
    return SimpleNamespace(
        type="llm_reasoning",
        payload={
            "_evolution_meta": {"event_kind": "outcome", "status": status},
            "content": message,
        },
    )


def _sdk_noop_outcome_event(skill_name: str = "powerpoint-pptx") -> SimpleNamespace:
    return SimpleNamespace(
        type="llm_reasoning",
        payload={
            "_evolution_meta": {
                "event_kind": "outcome",
                "rail_kind": "regular",
                "status": "no_evolution_no_records",
                "stage": "completed",
                "skill_name": skill_name,
                "source": "experience_updater",
            },
            "content": f"[Evolution] no applied updates for skill={skill_name}\n",
        },
    )


def _progress_event(
    content: str,
    *,
    stage: str | None = None,
    skill_name: str | None = None,
) -> SimpleNamespace:
    payload = {"content": content}
    if stage is not None:
        meta: dict[str, object] = {"event_kind": "progress", "stage": stage}
        if skill_name is not None:
            meta["skill_name"] = skill_name
        payload["_evolution_meta"] = meta
    return SimpleNamespace(type="llm_reasoning", payload=payload)


class _FakeEvolutionRail:
    def __init__(self, batches: list[list[object]] | None = None) -> None:
        self._batches = list(
            batches
            if batches is not None
            else [[_approval_event(), _outcome_event("completed", "done")]]
        )
        self.drain_waits: list[bool] = []
        self.cleanup_calls = 0
        self.llm_updates: list[tuple[object, str | None]] = []

    def update_llm(self, model: object, model_name: str | None) -> None:
        self.llm_updates.append((model, model_name))

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

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

class _FakeApprovalRail:
    def __init__(
        self,
        *,
        request_id: str = "",
        record_ids: list[str] | None = None,
    ) -> None:
        self.approved: list[tuple[str, list[str] | None]] = []
        self.rejected: list[str] = []
        if record_ids is not None:
            self._pending_approval_snapshots = {
                request_id: SimpleNamespace(
                    payload=[SimpleNamespace(id=record_id) for record_id in record_ids],
                ),
            }

    async def approve_record(
        self,
        request_id: str,
        *,
        approved_record_ids: list[str] | None = None,
    ) -> None:
        self.approved.append((request_id, approved_record_ids))

    async def reject_record(self, request_id: str) -> None:
        self.rejected.append(request_id)


class _FakeStore:
    def __init__(self, entries: list[object] | None = None) -> None:
        self._entries = list(entries or [])

    async def load_full_evolution_log(self, skill_name, subject_kind=None):
        return SimpleNamespace(entries=list(self._entries))


class _TestAdapter(JiuWenSwarmDeepAdapter):
    @classmethod
    def build_with_rail(
        cls,
        rail: _FakeEvolutionRail,
        *,
        auto_save: bool = False,
        evolution_entries: list[object] | None = None,
    ) -> "_TestAdapter":
        adapter = object.__new__(cls)
        setattr(adapter, "_skill_evolution_rail", rail)
        setattr(
            adapter,
            "_config_cache",
            {"react": {"evolution": {"auto_save": auto_save}}},
        )
        setattr(adapter, "_pending_auto_rebuild_jobs", {})
        setattr(adapter, "_auto_rebuild_lock", asyncio.Lock())
        setattr(adapter, "_auto_rebuild_task", None)
        setattr(adapter, "_auto_evolution_generated_ids", set())
        # Minimal attrs so watcher → _queue_auto_rebuild_skill →
        # _should_auto_merge_evolved_skill → _resolve_skill_dirs works.
        setattr(adapter, "_agent_id", "test-agent")
        setattr(adapter, "_service_id", "test-service")
        setattr(adapter, "_workspace_dir", ".")
        setattr(adapter, "_resolve_skill_dirs", lambda extra_skill_dir=None: [])
        store = _FakeStore(evolution_entries)
        setattr(adapter, "_get_disk_evolution_store", lambda: store)
        return adapter

    async def watch_evolution_and_push(
        self,
        request_id: str,
        channel_id: str,
        session_id: str,
    ) -> None:
        watcher = getattr(self, "_watch_evolution_and_push")
        await watcher(request_id, channel_id, session_id)


@pytest.mark.asyncio
async def test_evolution_watcher_supersedes_previous_request_for_same_session(monkeypatch):
    """A resumed request replaces the paused request's old watcher ownership."""
    adapter = object.__new__(JiuWenSwarmDeepAdapter)
    adapter._skill_evolution_rail = object()
    adapter._evolution_watcher_tasks = set()
    adapter._evolution_watchers = {}
    release = asyncio.Event()
    started = asyncio.Event()

    async def watch(request_id: str, channel_id: str, session_id: str) -> None:
        started.set()
        await release.wait()

    monkeypatch.setattr(adapter, "_watch_evolution_and_push", watch)

    first = adapter._start_evolution_watcher("rid-old", "channel-1", "session-1")
    await started.wait()
    started.clear()
    second = adapter._start_evolution_watcher("rid-new", "channel-1", "session-1")
    await started.wait()
    await asyncio.sleep(0)

    assert first.cancelled()
    assert getattr(first, "_evolution_watcher_graceful", False) is True
    assert adapter._evolution_watchers[("channel-1", "session-1")] is second
    assert second in adapter._evolution_watcher_tasks

    release.set()
    await second
    await asyncio.sleep(0)

    assert ("channel-1", "session-1") not in adapter._evolution_watchers
    assert second not in adapter._evolution_watcher_tasks


@pytest.mark.asyncio
async def test_cancel_evolution_watchers_does_not_cancel_skill_sleep_tasks():
    """Adapter-owned watchers are teardown-safe without changing SkillSleep lifetime."""
    adapter = object.__new__(JiuWenSwarmDeepAdapter)
    adapter._evolution_watcher_tasks = set()
    adapter._evolution_watchers = {}
    watcher_release = asyncio.Event()
    sleep_release = asyncio.Event()
    watcher_task = asyncio.create_task(watcher_release.wait())
    sleep_task = asyncio.create_task(sleep_release.wait())
    adapter._evolution_watcher_tasks.update({watcher_task, sleep_task})
    adapter._evolution_watchers[("channel-1", "session-1")] = watcher_task

    await adapter._cancel_evolution_watchers()

    assert watcher_task.cancelled()
    assert not adapter._evolution_watchers
    assert sleep_task in adapter._evolution_watcher_tasks
    assert not sleep_task.done()

    sleep_release.set()
    await sleep_task


@pytest.mark.asyncio
async def test_stream_start_does_not_cancel_inflight_route_watcher(monkeypatch):
    """A new request must not abort an in-flight prior passive evolution."""
    adapter = object.__new__(JiuWenSwarmDeepAdapter)
    adapter._is_session_scoped_adapter = True
    adapter._instance = object()
    adapter._deepresearch_rewrite_tx_uncertain = False
    adapter._STALE_CRON_PERMISSION_TEXT = "stale"

    async def refresh_stale_mcp_tool_lists() -> None:
        return None

    async def block_stale_cron_permission_resume(request) -> bool:
        return True

    monkeypatch.setattr(adapter, "_refresh_stale_mcp_tool_lists", refresh_stale_mcp_tool_lists)
    monkeypatch.setattr(
        adapter,
        "_inject_extension_config_into_inputs",
        lambda inputs: None,
    )
    monkeypatch.setattr(
        interface_deep_module,
        "_inject_model_selection_into_inputs",
        lambda request, inputs: None,
    )
    monkeypatch.setattr(
        interface_deep_module,
        "_inject_model_routing_into_inputs",
        lambda request, inputs: None,
    )
    monkeypatch.setattr(
        interface_deep_module,
        "_inject_request_id_into_inputs",
        lambda request, inputs: None,
    )
    monkeypatch.setattr(adapter, "_has_valid_model_config", lambda model_name: True)
    monkeypatch.setattr(
        adapter,
        "_block_stale_cron_permission_resume",
        block_stale_cron_permission_resume,
    )
    request = SimpleNamespace(
        request_id="rid-new",
        channel_id="channel-1",
        session_id="session-1",
        params={},
        metadata={},
    )
    chunks = [chunk async for chunk in adapter._process_message_stream_impl(request, {})]

    assert chunks[-1].is_complete is True


@pytest.mark.asyncio
async def test_superseded_evolution_watcher_does_not_cancel_shared_pending_evolution(
    monkeypatch,
):
    """Route handoff stops the listener without killing rail-owned evolution work."""
    _FakeTransport.pushes = []
    drain_release = asyncio.Event()

    class _BlockingRail(_FakeEvolutionRail):
        def __init__(self):
            super().__init__(batches=[[]])
            self.cancel_calls = 0

        async def cancel_pending_evolution(self) -> None:
            self.cancel_calls += 1

        async def drain_pending_approval_events(self, wait=False, timeout=None):
            self.drain_waits.append(wait)
            await drain_release.wait()
            return []

    rail = _BlockingRail()
    adapter = _TestAdapter.build_with_rail(rail)
    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    task = asyncio.create_task(
        adapter.watch_evolution_and_push("rid", "channel-1", "session-1")
    )
    await asyncio.sleep(0)
    assert rail.drain_waits

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

    assert rail.cleanup_calls == 1
    assert rail.cancel_calls == 0


@pytest.mark.asyncio
async def test_active_evolution_rail_unconfigure_isolates_failures(monkeypatch):
    """One failed unregister keeps its cached reference; the other can still unload."""
    adapter = object.__new__(JiuWenSwarmDeepAdapter)
    active_rail = object()
    interrupt_rail = object()
    adapter._instance = SimpleNamespace()
    adapter._skill_evolution_rail = active_rail
    adapter._evolution_interrupt_rail = interrupt_rail
    calls: list[object] = []

    async def unregister(rail):
        calls.append(rail)
        if rail is active_rail:
            raise RuntimeError("active rail unregister failed")

    def bulk_unconfigure(instance, team=False):
        return None

    adapter._instance.unregister_rail = unregister
    monkeypatch.setattr(interface_deep_module, "unconfigure_skill_evolution", bulk_unconfigure)

    await adapter._unconfigure_active_evolution_rails()

    assert calls == [active_rail, interrupt_rail]
    assert adapter._skill_evolution_rail is active_rail
    assert adapter._evolution_interrupt_rail is None


@pytest.mark.asyncio
async def test_skill_sleep_rail_unconfigure_keeps_cache_on_failure():
    """A failed SkillSleep unregister must not erase the still-mounted rail reference."""
    adapter = object.__new__(JiuWenSwarmDeepAdapter)
    rail = object()
    adapter._instance = SimpleNamespace()
    adapter._skill_sleep_rail = rail
    adapter._skill_sleep_tasks = set()

    async def unregister(unmounted_rail):
        assert unmounted_rail is rail
        raise RuntimeError("SkillSleep unregister failed")

    adapter._instance.unregister_rail = unregister

    await adapter._unconfigure_skill_sleep_rail()

    assert adapter._skill_sleep_rail is rail


@pytest.mark.asyncio
async def test_cancel_evolution_watchers_cleans_registry_without_user_data():
    """Adapter teardown cancels its own in-flight watchers and empties ownership."""
    adapter = object.__new__(JiuWenSwarmDeepAdapter)
    adapter._evolution_watcher_tasks = set()
    adapter._evolution_watchers = {}
    release = asyncio.Event()
    task = asyncio.create_task(release.wait())
    adapter._evolution_watcher_tasks.add(task)
    adapter._evolution_watchers[("channel-1", "session-1")] = task

    await adapter._cancel_evolution_watchers()
    with pytest.raises(asyncio.CancelledError):
        await task

    assert task.cancelled()
    assert not adapter._evolution_watchers
    assert not adapter._evolution_watcher_tasks


@pytest.mark.asyncio
async def test_normal_evolution_watcher_runs_when_rail_mounted(monkeypatch):
    """Mounted evolution rail enables passive scan; watcher does not gate on signal_trigger."""
    _FakeTransport.pushes = []
    rail = _FakeEvolutionRail(batches=[[]])
    adapter = _TestAdapter.build_with_rail(rail)

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(
        interface_deep_module,
        "resolve_evolution_event_timeout_sec",
        lambda rail, fallback_sec=30.0: 0.01,
    )

    await adapter.watch_evolution_and_push("stream-rid", "web", "sess-mounted")

    assert rail.drain_waits
    assert rail.cleanup_calls >= 1


@pytest.mark.asyncio
async def test_normal_evolution_watcher_uses_delivery_context_metadata(monkeypatch):
    _FakeTransport.pushes = []
    adapter = _TestAdapter.build_with_rail(_FakeEvolutionRail())

    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(
        interface_deep_module,
        "build_server_push_message",
        _fake_build_server_push_message,
    )

    await adapter.watch_evolution_and_push("stream-rid", "web", "sess-normal")

    assert recorded_calls
    assert all(call["session_id"] == "sess-normal" 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.asyncio
async def test_normal_evolution_watcher_does_not_push_status_without_sdk_events(monkeypatch):
    _FakeTransport.pushes = []
    rail = _FakeEvolutionRail([])
    adapter = _TestAdapter.build_with_rail(rail)

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

    await adapter.watch_evolution_and_push("stream-rid", "web", "sess-no-events")

    assert _FakeTransport.pushes == []
    assert rail.drain_waits
    assert rail.cleanup_calls == 1


@pytest.mark.asyncio
async def test_normal_evolution_watcher_uses_sdk_timeout_before_legacy_fallback(monkeypatch):
    class _SdkTimeoutRail(_FakeEvolutionRail):
        @property
        def evolution_total_timeout_secs(self) -> float:
            return 0.01

    _FakeTransport.pushes = []
    rail = _SdkTimeoutRail([[_progress_event("generating", stage="generating_updates")]])
    adapter = _TestAdapter.build_with_rail(rail)

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

    await asyncio.wait_for(
        adapter.watch_evolution_and_push("stream-rid", "web", "sess-sdk-timeout"),
        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.asyncio
async def test_normal_evolution_watcher_maps_sdk_progress_stages(monkeypatch):
    _FakeTransport.pushes = []
    rail = _FakeEvolutionRail(
        [
            [_progress_event("detecting", stage="detecting_signals")],
            [_progress_event("generating", stage="generating_updates")],
            [_outcome_event("completed", "done")],
        ]
    )
    adapter = _TestAdapter.build_with_rail(rail)

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )

    await adapter.watch_evolution_and_push("stream-rid", "web", "sess-sdk-stages")

    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",
    ]


@pytest.mark.asyncio
async def test_normal_evolution_watcher_ends_on_cancelled_progress(monkeypatch):
    _FakeTransport.pushes = []
    rail = _FakeEvolutionRail([[_progress_event("no skill usage detected", stage="cancelled")]])
    adapter = _TestAdapter.build_with_rail(rail)

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

    await adapter.watch_evolution_and_push("stream-rid", "web", "sess-sdk-cancelled")

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


@pytest.mark.asyncio
async def test_normal_evolution_watcher_does_not_start_for_no_signal_scan(monkeypatch):
    _FakeTransport.pushes = []
    rail = _FakeEvolutionRail(
        [
            [_progress_event("starting regular skill evolution review", stage="started")],
            [
                _progress_event(
                    "checking regular skill(s) for evolution signals",
                    stage="detecting_signals",
                )
            ],
            [
                _progress_event(
                    "no skill usage of a regular skill or actionable evolution signal detected",
                    stage="cancelled",
                )
            ],
        ]
    )
    adapter = _TestAdapter.build_with_rail(rail)

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )

    await adapter.watch_evolution_and_push("stream-rid", "web", "sess-no-signal-scan")

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


@pytest.mark.asyncio
async def test_normal_evolution_watcher_ends_on_auto_approved_progress(monkeypatch):
    _FakeTransport.pushes = []
    rail = _FakeEvolutionRail([[_progress_event("auto saved", stage="auto_approved")]])
    adapter = _TestAdapter.build_with_rail(rail)

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

    await adapter.watch_evolution_and_push("stream-rid", "web", "sess-sdk-auto")

    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] == [
        "completed",
        "completed",
    ]
    assert rail.cleanup_calls == 1


@pytest.mark.asyncio
async def test_normal_evolution_watcher_auto_rebuilds_after_auto_approved(
    monkeypatch,
):
    """selfEvolution=auto: persist (auto_approved) schedules rebuild immediately."""
    _FakeTransport.pushes = []
    rail = _FakeEvolutionRail(
        [
            [
                _progress_event(
                    "experience records auto-saved to 'demo-skill'",
                    stage="auto_approved",
                    skill_name="demo-skill",
                )
            ]
        ]
    )
    adapter = _TestAdapter.build_with_rail(
        rail,
        auto_save=True,
        evolution_entries=[
            SimpleNamespace(
                id="ev_auto_1",
                summary="auto tip",
                timestamp="2026-09-17T01:00:00.000Z",
                review_status="auto",
                change=SimpleNamespace(summary="", content=""),
            )
        ],
    )
    rebuild_calls: list[dict] = []
    queued_jobs: list = []

    async def _capture_rebuild(*, request_id: str | None = None) -> None:
        queued_jobs.extend(adapter._pending_auto_rebuild_jobs.values())  # pylint: disable=protected-access
        rebuild_calls.append({"request_id": request_id})
        # Drain queue the same way production does so pending does not leak.
        adapter._take_pending_auto_rebuild_jobs()  # pylint: disable=protected-access

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(
        interface_deep_module,
        "resolve_skill_evolution_action",
        lambda skill_name, **_kwargs: "auto",
    )
    monkeypatch.setattr(adapter, "_run_auto_rebuild_skills_detached", _capture_rebuild)
    monkeypatch.setattr(
        interface_deep_module.evolution_version_ctl,
        "resolve_subject",
        lambda _store, _name: {"kind": "skill"},
    )

    await adapter.watch_evolution_and_push("stream-rid", "web", "sess-auto-rebuild")
    await asyncio.sleep(0)

    assert rebuild_calls == [{"request_id": "stream-rid"}]
    assert adapter._pending_auto_rebuild_jobs == {}  # pylint: disable=protected-access
    assert rail.cleanup_calls == 1
    generated = [
        push
        for push in _FakeTransport.pushes
        if push.get("payload", {}).get("event_type") == "chat.evolution_generated"
    ]
    assert len(generated) == 1
    assert generated[0]["payload"]["skill_name"] == "demo-skill"
    assert generated[0]["payload"]["items"][0]["id"] == "ev_auto_1"
    assert [job.skill_name for job in queued_jobs] == ["demo-skill"]
    assert queued_jobs[0].session_id == "sess-auto-rebuild"
    assert queued_jobs[0].channel_id == "web"
    assert queued_jobs[0].request_id == "stream-rid"
    assert queued_jobs[0].source == "auto_watcher"
    assert queued_jobs[0].push_metrics is True


@pytest.mark.asyncio
async def test_normal_evolution_watcher_auto_rebuilds_before_noop_outcome(
    monkeypatch,
):
    """auto_approved schedules rebuild even if a later noop outcome arrives."""
    _FakeTransport.pushes = []
    rail = _FakeEvolutionRail(
        [
            [
                _progress_event(
                    "experience records auto-saved to 'demo-skill'",
                    stage="auto_approved",
                    skill_name="demo-skill",
                )
            ],
            [_sdk_noop_outcome_event("demo-skill")],
        ]
    )
    adapter = _TestAdapter.build_with_rail(rail, auto_save=True)
    rebuild_calls: list[dict] = []

    async def _capture_rebuild(*, request_id: str | None = None) -> None:
        rebuild_calls.append({"request_id": request_id})
        adapter._take_pending_auto_rebuild_jobs()  # pylint: disable=protected-access

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(
        interface_deep_module,
        "resolve_skill_evolution_action",
        lambda skill_name, **_kwargs: "auto",
    )
    monkeypatch.setattr(adapter, "_run_auto_rebuild_skills_detached", _capture_rebuild)
    monkeypatch.setattr(
        interface_deep_module.evolution_version_ctl,
        "resolve_subject",
        lambda _store, _name: {"kind": "skill"},
    )

    await adapter.watch_evolution_and_push("stream-rid", "web", "sess-auto-then-noop")
    await asyncio.sleep(0)

    assert rebuild_calls == [{"request_id": "stream-rid"}]
    assert adapter._pending_auto_rebuild_jobs == {}  # pylint: disable=protected-access


@pytest.mark.asyncio
async def test_evolution_watcher_timeout_schedules_pending_auto_rebuild(
    monkeypatch,
):
    """Watcher timeout must flush any queued auto rebuild before exit."""
    _FakeTransport.pushes = []
    rail = _FakeEvolutionRail(batches=[[]])
    adapter = _TestAdapter.build_with_rail(rail, auto_save=True)
    adapter._pending_auto_rebuild_jobs["demo-skill"] = auto_rebuild_job(  # pylint: disable=protected-access
        "demo-skill",
        source="auto_watcher",
        session_id="sess-timeout-flush",
        request_id="stream-rid",
        push_metrics=True,
    )
    rebuild_calls: list[dict] = []

    async def _capture_rebuild(*, request_id: str | None = None) -> None:
        rebuild_calls.append({"request_id": request_id})
        adapter._take_pending_auto_rebuild_jobs()  # pylint: disable=protected-access

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(
        interface_deep_module,
        "resolve_evolution_event_timeout_sec",
        lambda rail, fallback_sec=30.0: 0.01,
    )
    monkeypatch.setattr(interface_deep_module, "TEAM_EVOLUTION_IDLE_SLEEP_SEC", 0.001)
    monkeypatch.setattr(adapter, "_run_auto_rebuild_skills_detached", _capture_rebuild)

    await adapter.watch_evolution_and_push("stream-rid", "web", "sess-timeout-flush")
    await asyncio.sleep(0)

    assert rebuild_calls == [{"request_id": "stream-rid"}]
    assert adapter._pending_auto_rebuild_jobs == {}  # pylint: disable=protected-access
    assert rail.cleanup_calls >= 1


@pytest.mark.asyncio
async def test_auto_rebuild_skills_detached_pushes_published_metric(monkeypatch):
    """Auto rebuild success emits chat.evolution_published for AOM."""
    _FakeTransport.pushes = []
    adapter = _TestAdapter.build_with_rail(_FakeEvolutionRail(), auto_save=True)
    adapter._pending_auto_rebuild_jobs["demo-skill"] = auto_rebuild_job(  # pylint: disable=protected-access
        "demo-skill",
        source="auto_watcher",
        session_id="sess-pub",
        channel_id="web",
        request_id="rid-pub",
        push_metrics=True,
    )

    async def _merge(*, skill_name: str | None = None, params=None, stream_ctx=None):
        return {"success": True, "name": skill_name, "new_version": "v1.3.0"}

    async def _has_records(_name: str) -> bool:
        return True

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(
        interface_deep_module,
        "resolve_skill_evolution_action",
        lambda skill_name, **_kwargs: "auto",
    )
    monkeypatch.setattr(adapter, "generate_evolution_merge_version", _merge)
    monkeypatch.setattr(adapter, "_skill_has_live_evolution_records", _has_records)

    await adapter._run_auto_rebuild_skills_detached(request_id="rid-pub")  # pylint: disable=protected-access

    published = [
        push
        for push in _FakeTransport.pushes
        if push.get("payload", {}).get("event_type") == "chat.evolution_published"
    ]
    assert len(published) == 1
    assert published[0]["payload"]["skill_name"] == "demo-skill"
    assert published[0]["payload"]["version"] == "v1.3.0"
    assert published[0]["session_id"] == "sess-pub"


@pytest.mark.asyncio
async def test_auto_rebuild_published_uses_job_session_not_latest_slot(monkeypatch):
    """Each pending skill keeps the session captured at enqueue (no shared slot)."""
    _FakeTransport.pushes = []
    adapter = _TestAdapter.build_with_rail(_FakeEvolutionRail(), auto_save=True)
    adapter._pending_auto_rebuild_jobs["skill-a"] = auto_rebuild_job(  # pylint: disable=protected-access
        "skill-a",
        source="auto_watcher",
        session_id="sess-a",
        channel_id="web",
        request_id="rid-a",
        push_metrics=True,
    )
    adapter._pending_auto_rebuild_jobs["skill-b"] = auto_rebuild_job(  # pylint: disable=protected-access
        "skill-b",
        source="auto_watcher",
        session_id="sess-b",
        channel_id="web",
        request_id="rid-b",
        push_metrics=True,
    )

    async def _merge(*, skill_name: str | None = None, **_kwargs):
        return {"success": True, "name": skill_name, "new_version": f"v-{skill_name}"}

    async def _has_records(_name: str) -> bool:
        return True

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(
        interface_deep_module,
        "resolve_skill_evolution_action",
        lambda skill_name, **_kwargs: "auto",
    )
    monkeypatch.setattr(adapter, "generate_evolution_merge_version", _merge)
    monkeypatch.setattr(adapter, "_skill_has_live_evolution_records", _has_records)

    await adapter._run_auto_rebuild_skills_detached(request_id="latest-should-not-win")

    published = [
        push
        for push in _FakeTransport.pushes
        if push.get("payload", {}).get("event_type") == "chat.evolution_published"
    ]
    by_skill = {push["payload"]["skill_name"]: push for push in published}
    assert by_skill["skill-a"]["session_id"] == "sess-a"
    assert by_skill["skill-b"]["session_id"] == "sess-b"


@pytest.mark.asyncio
async def test_queue_auto_rebuild_keeps_first_session_context(monkeypatch):
    adapter = _TestAdapter.build_with_rail(_FakeEvolutionRail(), auto_save=True)
    monkeypatch.setattr(
        interface_deep_module,
        "resolve_skill_evolution_action",
        lambda skill_name, **_kwargs: "auto",
    )
    adapter._queue_auto_rebuild_skill(  # pylint: disable=protected-access
        "demo-skill",
        source="auto_watcher",
        session_id="sess-first",
        channel_id="web",
        request_id="rid-1",
        push_metrics=True,
    )
    adapter._queue_auto_rebuild_skill(  # pylint: disable=protected-access
        "demo-skill",
        source="auto_watcher",
        session_id="sess-second",
        channel_id="web",
        request_id="rid-2",
        push_metrics=True,
    )
    job = adapter._pending_auto_rebuild_jobs["demo-skill"]  # pylint: disable=protected-access
    assert job.session_id == "sess-first"
    assert job.request_id == "rid-1"


@pytest.mark.asyncio
async def test_manual_approval_rebuild_does_not_push_published(monkeypatch):
    _FakeTransport.pushes = []
    adapter = _TestAdapter.build_with_rail(_FakeEvolutionRail(), auto_save=True)
    adapter._pending_auto_rebuild_jobs["demo-skill"] = auto_rebuild_job(  # pylint: disable=protected-access
        "demo-skill",
        source="manual_approval",
        session_id="sess-manual",
        channel_id="web",
        request_id="rid-manual",
        push_metrics=False,
    )

    async def _merge(*, skill_name: str | None = None, **_kwargs):
        return {"success": True, "name": skill_name, "new_version": "v9.9.9"}

    async def _has_records(_name: str) -> bool:
        return True

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(
        interface_deep_module,
        "resolve_skill_evolution_action",
        lambda skill_name, **_kwargs: "auto",
    )
    monkeypatch.setattr(adapter, "generate_evolution_merge_version", _merge)
    monkeypatch.setattr(adapter, "_skill_has_live_evolution_records", _has_records)

    await adapter._run_auto_rebuild_skills_detached(request_id="rid-manual")

    published = [
        push
        for push in _FakeTransport.pushes
        if push.get("payload", {}).get("event_type") == "chat.evolution_published"
    ]
    assert published == []


@pytest.mark.asyncio
async def test_generated_metrics_skip_already_reported_ids(monkeypatch):
    """Full live-log snapshots must not re-push ids already reported by this adapter."""
    _FakeTransport.pushes = []
    entries = [
        SimpleNamespace(
            id="ev_auto_1",
            summary="auto tip",
            timestamp="2026-09-17T01:00:00.000Z",
            review_status="auto",
            change=SimpleNamespace(summary="", content=""),
        )
    ]
    rail = _FakeEvolutionRail(
        [
            [
                _progress_event(
                    "experience records auto-saved to 'demo-skill'",
                    stage="auto_approved",
                    skill_name="demo-skill",
                )
            ]
        ]
    )
    adapter = _TestAdapter.build_with_rail(rail, auto_save=True, evolution_entries=entries)

    async def _capture_rebuild(*, request_id: str | None = None) -> None:
        adapter._take_pending_auto_rebuild_jobs()  # pylint: disable=protected-access

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(
        interface_deep_module,
        "resolve_skill_evolution_action",
        lambda skill_name, **_kwargs: "auto",
    )
    monkeypatch.setattr(adapter, "_run_auto_rebuild_skills_detached", _capture_rebuild)
    monkeypatch.setattr(
        interface_deep_module.evolution_version_ctl,
        "resolve_subject",
        lambda _store, _name: {"kind": "skill"},
    )

    await adapter.watch_evolution_and_push("stream-rid-1", "web", "sess-dup")
    first = [
        push
        for push in _FakeTransport.pushes
        if push.get("payload", {}).get("event_type") == "chat.evolution_generated"
    ]
    assert len(first) == 1

    rail._batches = [
        [
            _progress_event(
                "experience records auto-saved to 'demo-skill'",
                stage="auto_approved",
                skill_name="demo-skill",
            )
        ]
    ]
    await adapter.watch_evolution_and_push("stream-rid-2", "web", "sess-dup")
    generated = [
        push
        for push in _FakeTransport.pushes
        if push.get("payload", {}).get("event_type") == "chat.evolution_generated"
    ]
    assert len(generated) == 1


@pytest.mark.asyncio
async def test_auto_rebuild_skills_detached_runs_serially(monkeypatch):
    """Concurrent auto-rebuild tasks serialize on the adapter lock."""
    adapter = _TestAdapter.build_with_rail(_FakeEvolutionRail(), auto_save=True)
    order: list[str] = []
    hold = asyncio.Event()
    release = asyncio.Event()

    async def _slow_merge(*, skill_name: str | None = None, **_kwargs):
        name = str(skill_name or "")
        order.append(f"start:{name}")
        if name == "skill-a":
            hold.set()
            await release.wait()
        order.append(f"end:{name}")
        return {"success": True, "name": name}

    monkeypatch.setattr(
        interface_deep_module,
        "resolve_skill_evolution_action",
        lambda skill_name, **_kwargs: "auto",
    )
    monkeypatch.setattr(adapter, "generate_evolution_merge_version", _slow_merge)

    async def _has_records(_name: str) -> bool:
        return True

    monkeypatch.setattr(adapter, "_skill_has_live_evolution_records", _has_records)

    adapter._pending_auto_rebuild_jobs["skill-a"] = auto_rebuild_job(  # pylint: disable=protected-access
        "skill-a", source="auto_watcher", session_id="sess-a", push_metrics=True
    )
    task_a = asyncio.create_task(
        adapter._run_auto_rebuild_skills_detached(request_id="a")  # pylint: disable=protected-access
    )
    await hold.wait()
    adapter._pending_auto_rebuild_jobs["skill-b"] = auto_rebuild_job(  # pylint: disable=protected-access
        "skill-b", source="auto_watcher", session_id="sess-b", push_metrics=True
    )
    task_b = asyncio.create_task(
        adapter._run_auto_rebuild_skills_detached(request_id="b")  # pylint: disable=protected-access
    )
    await asyncio.sleep(0)
    assert order == ["start:skill-a"]
    release.set()
    await asyncio.gather(task_a, task_b)
    assert order == ["start:skill-a", "end:skill-a", "start:skill-b", "end:skill-b"]


@pytest.mark.asyncio
async def test_normal_evolution_watcher_skips_auto_rebuild_when_suggest(
    monkeypatch,
):
    """selfEvolution=suggest: persisted experience must not schedule rebuild."""
    _FakeTransport.pushes = []
    rail = _FakeEvolutionRail(
        [
            [
                _progress_event(
                    "experience records auto-saved to 'demo-skill'",
                    stage="auto_approved",
                    skill_name="demo-skill",
                )
            ]
        ]
    )
    adapter = _TestAdapter.build_with_rail(rail, auto_save=False)
    rebuild_calls: list[dict] = []

    async def _capture_rebuild(*, request_id: str | None = None) -> None:
        rebuild_calls.append({"request_id": request_id})

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(
        interface_deep_module,
        "resolve_skill_evolution_action",
        lambda skill_name, **_kwargs: "suggest",
    )
    monkeypatch.setattr(adapter, "_run_auto_rebuild_skills_detached", _capture_rebuild)

    await adapter.watch_evolution_and_push("stream-rid", "web", "sess-no-auto-rebuild")
    await asyncio.sleep(0)

    assert rebuild_calls == []
    assert adapter._pending_auto_rebuild_jobs == {}  # pylint: disable=protected-access


@pytest.mark.asyncio
async def test_normal_evolution_watcher_skips_auto_rebuild_on_noop_after_generation(
    monkeypatch,
):
    """selfEvolution=auto: generating then no records must not schedule rebuild."""
    _FakeTransport.pushes = []
    rail = _FakeEvolutionRail(
        [
            [_progress_event("generating", stage="generating_updates")],
            [_sdk_noop_outcome_event("demo-skill")],
        ]
    )
    adapter = _TestAdapter.build_with_rail(rail, auto_save=True)
    rebuild_calls: list[dict] = []

    async def _capture_rebuild(*, request_id: str | None = None) -> None:
        rebuild_calls.append({"request_id": request_id})

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(
        interface_deep_module,
        "resolve_skill_evolution_action",
        lambda skill_name, **_kwargs: "auto",
    )
    monkeypatch.setattr(adapter, "_run_auto_rebuild_skills_detached", _capture_rebuild)

    await adapter.watch_evolution_and_push("stream-rid", "web", "sess-noop-no-rebuild")
    await asyncio.sleep(0)

    assert rebuild_calls == []
    assert adapter._pending_auto_rebuild_jobs == {}  # pylint: disable=protected-access
    assert rail.cleanup_calls == 1


@pytest.mark.asyncio
async def test_normal_evolution_watcher_skips_auto_rebuild_on_completed_without_persist(
    monkeypatch,
):
    """selfEvolution=auto: completed + skill_name without persist must not rebuild."""
    _FakeTransport.pushes = []
    rail = _FakeEvolutionRail(
        [
            [
                _progress_event(
                    "evolution request ready for 'demo-skill'",
                    stage="completed",
                    skill_name="demo-skill",
                )
            ]
        ]
    )
    adapter = _TestAdapter.build_with_rail(rail, auto_save=True)
    rebuild_calls: list[dict] = []

    async def _capture_rebuild(*, request_id: str | None = None) -> None:
        rebuild_calls.append({"request_id": request_id})

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(
        interface_deep_module,
        "resolve_skill_evolution_action",
        lambda skill_name, **_kwargs: "auto",
    )
    monkeypatch.setattr(adapter, "_run_auto_rebuild_skills_detached", _capture_rebuild)

    await adapter.watch_evolution_and_push("stream-rid", "web", "sess-completed-no-rebuild")
    await asyncio.sleep(0)

    assert rebuild_calls == []
    assert adapter._pending_auto_rebuild_jobs == {}  # pylint: disable=protected-access


@pytest.mark.asyncio
async def test_normal_evolution_watcher_reads_outcome_status_from_metadata(monkeypatch):
    _FakeTransport.pushes = []
    adapter = _TestAdapter.build_with_rail(
        _FakeEvolutionRail([[_outcome_event("failed", "failed")]])
    )

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )

    await adapter.watch_evolution_and_push("stream-rid", "web", "sess-normal-failed")

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


@pytest.mark.asyncio
async def test_normal_evolution_watcher_hides_sdk_noop_outcome_without_prior_generation(monkeypatch):
    """Noop-only path returns before schedule; auto mode still must not queue rebuild."""
    _FakeTransport.pushes = []
    rail = _FakeEvolutionRail([[_sdk_noop_outcome_event("demo-skill")]])
    adapter = _TestAdapter.build_with_rail(rail, auto_save=True)
    rebuild_calls: list[dict] = []

    async def _capture_rebuild(*, request_id: str | None = None) -> None:
        rebuild_calls.append({"request_id": request_id})

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )
    monkeypatch.setattr(
        interface_deep_module,
        "resolve_skill_evolution_action",
        lambda skill_name, **_kwargs: "auto",
    )
    monkeypatch.setattr(adapter, "_run_auto_rebuild_skills_detached", _capture_rebuild)

    await adapter.watch_evolution_and_push("stream-rid", "web", "sess-sdk-noop-only")
    await asyncio.sleep(0)

    status_pushes = [
        push for push in _FakeTransport.pushes
        if push["payload"]["event_type"] == "chat.evolution_status"
    ]
    assert status_pushes == []
    assert rebuild_calls == []
    assert adapter._pending_auto_rebuild_jobs == {}  # pylint: disable=protected-access
    assert rail.cleanup_calls == 1


@pytest.mark.asyncio
async def test_normal_evolution_watcher_ends_sdk_noop_outcome_after_generation(monkeypatch):
    _FakeTransport.pushes = []
    rail = _FakeEvolutionRail(
        [
            [_progress_event("generating", stage="generating_updates")],
            [_sdk_noop_outcome_event()],
        ]
    )
    adapter = _TestAdapter.build_with_rail(rail)

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )

    await adapter.watch_evolution_and_push("stream-rid", "web", "sess-sdk-noop-after-generation")

    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",
        "no_evolution_no_records",
    ]
    assert rail.cleanup_calls == 1


@pytest.mark.asyncio
async def test_normal_evolution_watcher_does_not_push_progress_as_reasoning(monkeypatch):
    _FakeTransport.pushes = []
    rail = _FakeEvolutionRail(
        [
            [
                _progress_event(
                    "starting regular skill evolution review for completed conversation",
                    stage="started",
                )
            ],
            [
                _progress_event(
                    "checking 2 regular skill(s) for evolution signals",
                    stage="detecting_signals",
                )
            ],
            [_approval_event("skill_evolve_progress_req")],
        ]
    )
    adapter = _TestAdapter.build_with_rail(rail)

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )

    await adapter.watch_evolution_and_push("stream-rid", "web", "sess-progress")

    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 not any(
        push["payload"].get("event_type") == "chat.reasoning"
        for push in _FakeTransport.pushes
    )
    assert _FakeTransport.pushes[0]["payload"]["status"] == "start"
    assert _FakeTransport.pushes[0]["payload"]["stage"] == "approval_required"
    assert _FakeTransport.pushes[1]["payload"]["request_id"] == "skill_evolve_progress_req"
    assert _FakeTransport.pushes[2]["payload"]["status"] == "end"
    assert _FakeTransport.pushes[2]["payload"]["stage"] == "approval_required"
    assert rail.cleanup_calls == 1
    assert rail.drain_waits
    assert set(rail.drain_waits) == {False}


@pytest.mark.asyncio
async def test_normal_evolution_watcher_times_out_after_idle_progress(monkeypatch):
    _FakeTransport.pushes = []
    rail = _FakeEvolutionRail([[_progress_event("evolution progress")]])
    adapter = _TestAdapter.build_with_rail(rail)

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

    await adapter.watch_evolution_and_push("stream-rid", "web", "sess-timeout")

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


@pytest.mark.asyncio
async def test_normal_evolution_watcher_hides_timed_out_terminal_progress(monkeypatch):
    _FakeTransport.pushes = []
    adapter = _TestAdapter.build_with_rail(
        _FakeEvolutionRail([[_progress_event("timed out", stage="timed_out")]])
    )

    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )

    await adapter.watch_evolution_and_push("stream-rid", "web", "sess-terminal-timeout")

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


@pytest.mark.asyncio
async def test_team_skill_evolve_approval_keeps_legacy_whole_request_without_record_ids(monkeypatch):
    rail = _FakeApprovalRail()
    adapter = object.__new__(JiuWenSwarmDeepAdapter)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.interface_deep.find_team_skill_rail",
        lambda request_id, channel_id=None: rail,
    )
    handled = await adapter.handle_team_skill_evolve_approval(
        "team_skill_evolve_req1",
        [{"selected_options": ["accept"]}],
        session_id="sess-1",
        channel_id="web",
    )

    assert handled is True
    assert rail.approved == [("team_skill_evolve_req1", None)]
    assert rail.rejected == []


@pytest.mark.asyncio
async def test_team_skill_evolve_approval_passes_selected_record_ids(monkeypatch):
    rail = _FakeApprovalRail(
        request_id="team_skill_evolve_req1",
        record_ids=["team-rec-1", "team-rec-2", "team-rec-3"],
    )
    adapter = object.__new__(JiuWenSwarmDeepAdapter)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.interface_deep.find_team_skill_rail",
        lambda request_id, channel_id=None: rail,
    )
    monkeypatch.setattr(
        "jiuwenswarm.agents.harness.team.refresh_team_shared_skill_links_across_managers",
        lambda session_id: None,
    )

    handled = await adapter.handle_team_skill_evolve_approval(
        "team_skill_evolve_req1",
        [
            {"selected_options": ["accept"]},
            {"selected_options": ["reject"]},
            {"selected_options": ["接收"]},
        ],
        session_id="sess-1",
        channel_id="web",
    )

    assert handled is True
    assert rail.approved == [("team_skill_evolve_req1", ["team-rec-1", "team-rec-3"])]
    assert rail.rejected == []


@pytest.mark.asyncio
async def test_team_skill_evolve_approval_pushes_terminal_status(monkeypatch):
    _FakeTransport.pushes = []
    adapter = object.__new__(JiuWenSwarmDeepAdapter)
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.interface_deep.find_team_skill_rail",
        lambda request_id, channel_id=None: _FakeApprovalRail(),
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.gateway_push.WebSocketGatewayPushTransport",
        _FakeTransport,
    )

    handled = await adapter.handle_team_skill_evolve_approval(
        "team_skill_evolve_req1",
        [{"selected_options": ["接收"]}],
        session_id="sess-1",
        channel_id="web",
    )

    assert handled is True
    assert _FakeTransport.pushes == [
        {
            "session_id": "sess-1",
            "request_id": "team_skill_evolve_req1",
            "channel_id": "web",
            "payload": {
                "event_type": "chat.evolution_status",
                "request_id": "team_skill_evolve_req1",
                "status": "end",
                "stage": "completed",
                "message": "Team skill evolution accepted",
            },
        }
    ]