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

"""Tests for skills.evolution.archives / rollback / rebuild host adapters."""

from __future__ import annotations

import asyncio
import json
from pathlib import Path
from types import SimpleNamespace
from typing import Any
from unittest.mock import AsyncMock

import pytest

from jiuwenswarm.server.runtime.agent_adapter import evolution_version as evolution_version_ctl
from jiuwenswarm.server.runtime.agent_adapter.evolution_helpers import auto_rebuild_job
from jiuwenswarm.server.runtime.agent_adapter.interface_deep import JiuWenSwarmDeepAdapter
from jiuwenswarm.server.runtime.agent_manager import _DISK_ONLY_EVOLUTION_METHODS


def _write_skill(tmp_path: Path, name: str) -> Path:
    skills_dir = tmp_path / "skills"
    skill_dir = skills_dir / name
    skill_dir.mkdir(parents=True)
    skill_dir.joinpath("SKILL.md").write_text(
        f"---\nname: {name}\nversion: 1.0.0\n---\n# {name}\n",
        encoding="utf-8",
    )
    skill_dir.joinpath("evolutions.json").write_text(
        json.dumps(
            {
                "skill_id": name,
                "version": "v1.0.0",
                "updated_at": "live",
                "entries": [],
            },
            ensure_ascii=False,
        ),
        encoding="utf-8",
    )
    return skills_dir


def _write_pair(tmp_path: Path, name: str, version: str, body: str) -> None:
    archive = tmp_path / "skills" / name / "archive"
    archive.mkdir(parents=True, exist_ok=True)
    archive.joinpath(f"SKILL.{version}.md").write_text(body, encoding="utf-8")
    archive.joinpath(f"evolutions.{version}.json").write_text(
        json.dumps(
            {
                "skill_id": name,
                "version": version,
                "updated_at": "archived",
                "entries": [],
            },
            ensure_ascii=False,
        ),
        encoding="utf-8",
    )


def test_disk_only_methods_exclude_rebuild():
    assert "skills.evolution.archives" in _DISK_ONLY_EVOLUTION_METHODS
    assert "skills.evolution.rollback" in _DISK_ONLY_EVOLUTION_METHODS
    assert "skills.evolution.rebuild" not in _DISK_ONLY_EVOLUTION_METHODS


def test_safe_path_name_rejects_traversal():
    with pytest.raises(ValueError):
        evolution_version_ctl.safe_path_name("../evil", "skill")


def test_skill_md_fingerprint_changes_with_content(tmp_path: Path):
    path = tmp_path / "SKILL.md"
    path.write_text("a", encoding="utf-8")
    first = evolution_version_ctl.skill_md_fingerprint(str(path))
    path.write_text("b", encoding="utf-8")
    second = evolution_version_ctl.skill_md_fingerprint(str(path))
    assert first is not None and second is not None
    assert first != second


@pytest.mark.anyio
async def test_handle_skills_evolution_archives_lists_versions(tmp_path, monkeypatch):
    skills_dir = _write_skill(tmp_path, "demo-skill")
    _write_pair(tmp_path, "demo-skill", "v1.0.0", "# old\n")
    adapter = JiuWenSwarmDeepAdapter()
    monkeypatch.setattr(adapter, "_resolve_skill_dirs", lambda: [str(skills_dir)])

    result = await adapter.handle_skills_evolution_archives({"name": "demo-skill"})
    assert result["name"] == "demo-skill"
    assert "SKILL.v1.0.0.md" in result["versions"]


@pytest.mark.anyio
async def test_handle_skills_evolution_rollback_latest(tmp_path, monkeypatch):
    skills_dir = _write_skill(tmp_path, "demo-skill")
    skill_md = tmp_path / "skills" / "demo-skill" / "SKILL.md"
    skill_md.write_text("# current\n", encoding="utf-8")
    _write_pair(tmp_path, "demo-skill", "v1.0.0", "# archived-body\n")

    adapter = JiuWenSwarmDeepAdapter()
    monkeypatch.setattr(adapter, "_resolve_skill_dirs", lambda: [str(skills_dir)])

    result = await adapter.handle_skills_evolution_rollback(
        {"name": "demo-skill", "version": "latest"}
    )
    assert result["success"] is True
    assert result["rolled_back"] is True
    assert skill_md.read_text(encoding="utf-8") == "# archived-body\n"
    live = json.loads(
        (tmp_path / "skills" / "demo-skill" / "evolutions.json").read_text(encoding="utf-8")
    )
    assert live["entries"] == []


@pytest.mark.anyio
async def test_handle_skills_evolution_rollback_lists_when_version_omitted(tmp_path, monkeypatch):
    skills_dir = _write_skill(tmp_path, "demo-skill")
    _write_pair(tmp_path, "demo-skill", "v1.2.0", "# v120\n")
    adapter = JiuWenSwarmDeepAdapter()
    monkeypatch.setattr(adapter, "_resolve_skill_dirs", lambda: [str(skills_dir)])

    result = await adapter.handle_skills_evolution_rollback({"name": "demo-skill"})
    assert result["success"] is True
    assert result["rolled_back"] is False
    assert result["versions"]


@pytest.mark.anyio
async def test_generate_evolution_merge_version_fingerprint_gate(tmp_path, monkeypatch):
    skills_dir = _write_skill(tmp_path, "demo-skill")
    skill_md = tmp_path / "skills" / "demo-skill" / "SKILL.md"
    adapter = JiuWenSwarmDeepAdapter()
    adapter._instance = object()  # pylint: disable=protected-access
    adapter._model = object()  # pylint: disable=protected-access
    adapter._config_cache = {"evolution": {"auto_save": True}}  # pylint: disable=protected-access
    monkeypatch.setattr(adapter, "_resolve_skill_dirs", lambda: [str(skills_dir)])
    monkeypatch.setattr(adapter, "_bind_request_env_overlay", lambda: (None, None, None))
    monkeypatch.setattr(adapter, "_reset_request_env_bindings", lambda *_a, **_k: None)
    monkeypatch.setattr(adapter, "_resolve_runtime_language", lambda: "cn")
    monkeypatch.setattr(adapter, "_resolve_model_name", lambda: "test-model")
    monkeypatch.setattr(adapter, "ensure_instance", AsyncMock())
    monkeypatch.setattr(
        adapter,
        "_execute_merge_version_rewrite",
        AsyncMock(return_value=True),
    )

    # Rewrite succeeds but file unchanged → must fail before complete_rebuild
    with pytest.raises(ValueError, match="未更新"):
        await adapter.generate_evolution_merge_version({"name": "demo-skill"})

    assert skill_md.read_text(encoding="utf-8").startswith("---")


def test_extra_trusted_dirs_for_skill_md(tmp_path):
    skill_md = tmp_path / "office-claw" / "skills" / "beer" / "SKILL.md"
    skill_md.parent.mkdir(parents=True)
    skill_md.write_text("# beer\n", encoding="utf-8")
    extra = evolution_version_ctl.extra_trusted_dirs_for_skill_md(str(skill_md))
    assert str((tmp_path / "office-claw" / "skills").resolve()) in extra
    assert str(skill_md.parent.resolve()) in extra


@pytest.mark.anyio
async def test_generate_evolution_merge_version_does_not_seed_trusted_dirs(
    tmp_path, monkeypatch
):
    """Direct-LLM rebuild writes via Path.write_text; no permission trusted_dirs seed."""
    skills_dir = _write_skill(tmp_path, "demo-skill")
    skill_md = tmp_path / "skills" / "demo-skill" / "SKILL.md"
    captured: list[list[str]] = []

    class _Rail:
        def __init__(self) -> None:
            self._engine = SimpleNamespace(trusted_dirs=[])

        def set_trusted_dirs(self, dirs: list[str] | None) -> None:
            captured.append(list(dirs or []))
            self._engine.trusted_dirs = list(dirs or [])

    adapter = JiuWenSwarmDeepAdapter()
    adapter._instance = object()  # pylint: disable=protected-access
    adapter._model = object()  # pylint: disable=protected-access
    adapter._permission_rail = _Rail()  # pylint: disable=protected-access
    monkeypatch.setattr(adapter, "_resolve_skill_dirs", lambda: [str(skills_dir)])
    monkeypatch.setattr(adapter, "_bind_request_env_overlay", lambda: (None, None, None))
    monkeypatch.setattr(adapter, "_reset_request_env_bindings", lambda *_a, **_k: None)
    monkeypatch.setattr(adapter, "_resolve_runtime_language", lambda: "cn")
    monkeypatch.setattr(adapter, "_resolve_model_name", lambda: "test-model")
    monkeypatch.setattr(adapter, "ensure_instance", AsyncMock())
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.evolution_version.prepare_rebuild_followup",
        AsyncMock(
            return_value={
                "ok": True,
                "followup_prompt": "rebuild",
                "rebuild_context": {
                    "skill_md_path": str(skill_md),
                    "archive_pair": True,
                    "subject_kind": "skill",
                },
            }
        ),
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.evolution_version.finalize_rebuild_followup",
        AsyncMock(
            return_value={"ok": True, "new_version": "1.0.1", "cleared": True}
        ),
    )

    async def _rewrite(**_kwargs: Any) -> bool:
        skill_md.write_text("# rebuilt\n", encoding="utf-8")
        return True

    monkeypatch.setattr(adapter, "_execute_merge_version_rewrite", _rewrite)

    result = await adapter.generate_evolution_merge_version(
        {"name": "demo-skill", "skill_path": str(skill_md)}
    )
    assert result["success"] is True
    assert captured == []


@pytest.mark.anyio
async def test_execute_merge_version_rewrite_direct_llm_writes_skill_md(
    tmp_path, monkeypatch
):
    skills_dir = _write_skill(tmp_path, "demo-skill")
    skill_md = skills_dir / "demo-skill" / "SKILL.md"
    rebuilt = (
        "---\nname: demo-skill\nversion: 1.0.0\n---\n# demo-skill\n\nrebuilt body\n"
    )

    class _FakeModel:
        async def invoke(self, _messages, **_kwargs):
            return SimpleNamespace(content=f"```markdown\n{rebuilt}\n```")

    # CI openjiuwen may lack build_rebuild_llm_direct_prompt; stub the module
    # attribute so the in-function ``from ... import`` succeeds.
    import openjiuwen.harness.rails.evolution.commands as evolution_commands

    def _stub_direct_prompt(
        *,
        subject: dict[str, Any],
        current_skill_md: str,
        user_intent: str | None = None,
        rebuild_context: dict[str, Any] | None = None,
        language: str = "cn",
    ) -> tuple[str, str]:
        _ = (subject, user_intent, rebuild_context, language)
        return (
            "You rebuild Skill definition files (SKILL.md).",
            f"Current SKILL.md:\n{current_skill_md}\n",
        )

    monkeypatch.setattr(
        evolution_commands,
        "build_rebuild_llm_direct_prompt",
        _stub_direct_prompt,
        raising=False,
    )

    adapter = JiuWenSwarmDeepAdapter()
    adapter._model = _FakeModel()  # pylint: disable=protected-access
    monkeypatch.setattr(adapter, "_resolve_runtime_language", lambda: "cn")

    ok = await adapter._execute_merge_version_rewrite(  # pylint: disable=protected-access
        skill_md_path=str(skill_md),
        rebuild_context={
            "skill_md_path": str(skill_md),
            "records": [
                {
                    "record_id": "ev_1",
                    "summary": "add note",
                    "target": "skill",
                    "section": "Instructions",
                    "score": 0.9,
                    "content": "always mention UV",
                }
            ],
        },
        subject={"kind": "skill", "name": "demo-skill"},
    )
    assert ok is True
    text = skill_md.read_text(encoding="utf-8")
    assert "rebuilt body" in text
    assert text.startswith("---")
    assert "```" not in text


def test_build_rebuild_llm_direct_prompt_has_no_write_file_tools():
    import openjiuwen.harness.rails.evolution.commands as evolution_commands

    build_rebuild_llm_direct_prompt = getattr(
        evolution_commands, "build_rebuild_llm_direct_prompt", None
    )
    if build_rebuild_llm_direct_prompt is None:
        pytest.skip(
            "openjiuwen package lacks build_rebuild_llm_direct_prompt"
        )

    system, user = build_rebuild_llm_direct_prompt(
        subject={"kind": "skill", "name": "demo"},
        current_skill_md="---\nname: demo\n---\n# demo\n",
        rebuild_context={"skill_md_path": "/tmp/demo/SKILL.md", "records": []},
    )
    blob = f"{system}\n{user}".lower()
    assert "write_file" not in blob
    assert "skill-creator" not in blob
    assert "Current SKILL.md:" in user
    assert "---\nname: demo\n---" in user


def test_queue_auto_rebuild_respects_skill_evolution_action(monkeypatch):
    adapter = JiuWenSwarmDeepAdapter()
    monkeypatch.setattr(adapter, "_resolve_skill_dirs", lambda: [])
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.interface_deep.resolve_skill_evolution_action",
        lambda skill_name, **_kwargs: "suggest",
    )
    adapter._queue_auto_rebuild_skill("demo-skill")  # pylint: disable=protected-access
    assert adapter._pending_auto_rebuild_jobs == {}  # pylint: disable=protected-access

    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.interface_deep.resolve_skill_evolution_action",
        lambda skill_name, **_kwargs: "auto",
    )
    adapter._queue_auto_rebuild_skill("demo-skill")  # pylint: disable=protected-access
    assert list(adapter._pending_auto_rebuild_jobs) == ["demo-skill"]  # pylint: disable=protected-access

    adapter._pending_auto_rebuild_jobs.clear()  # pylint: disable=protected-access
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.interface_deep.resolve_skill_evolution_action",
        lambda skill_name, **_kwargs: "off",
    )
    adapter._queue_auto_rebuild_skill("demo-skill")  # pylint: disable=protected-access
    assert adapter._pending_auto_rebuild_jobs == {}  # pylint: disable=protected-access


def _adapter_for_auto_rebuild(monkeypatch, *, entries: list[Any]) -> JiuWenSwarmDeepAdapter:
    adapter = JiuWenSwarmDeepAdapter()
    adapter._pending_auto_rebuild_jobs = {  # pylint: disable=protected-access
        "demo-skill": auto_rebuild_job("demo-skill", source="auto_watcher"),
    }
    store = SimpleNamespace(
        load_full_evolution_log=AsyncMock(return_value=SimpleNamespace(entries=entries)),
    )
    monkeypatch.setattr(adapter, "_get_disk_evolution_store", lambda: store)
    monkeypatch.setattr(adapter, "_should_auto_merge_evolved_skill", lambda _name: True)
    return adapter


@pytest.mark.anyio
async def test_run_auto_rebuild_skips_when_no_live_records(monkeypatch):
    adapter = _adapter_for_auto_rebuild(monkeypatch, entries=[])
    merge_calls: list[str] = []

    async def _fake_merge(*, skill_name: str | None = None, **_kwargs: Any) -> dict[str, Any]:
        merge_calls.append(str(skill_name))
        return {"success": True}

    monkeypatch.setattr(adapter, "generate_evolution_merge_version", _fake_merge)

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

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


@pytest.mark.anyio
async def test_run_auto_rebuild_proceeds_when_live_records_exist(monkeypatch):
    adapter = _adapter_for_auto_rebuild(monkeypatch, entries=[SimpleNamespace(id="e1")])
    merge_calls: list[str] = []

    async def _fake_merge(*, skill_name: str | None = None, **_kwargs: Any) -> dict[str, Any]:
        merge_calls.append(str(skill_name))
        return {"success": True}

    monkeypatch.setattr(adapter, "generate_evolution_merge_version", _fake_merge)

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

    assert merge_calls == ["demo-skill"]
    assert adapter._pending_auto_rebuild_jobs == {}  # pylint: disable=protected-access


@pytest.mark.anyio
async def test_do_evolve_rollback_clears_live_evolutions(tmp_path):
    skills_dir = _write_skill(tmp_path, "demo-skill")
    skill_dir = tmp_path / "skills" / "demo-skill"
    skill_dir.joinpath("evolutions.json").write_text(
        json.dumps(
            {
                "skill_id": "demo-skill",
                "version": "v1.0.0",
                "updated_at": "dirty",
                "entries": [{"id": "e1"}],
            },
            ensure_ascii=False,
        ),
        encoding="utf-8",
    )
    _write_pair(tmp_path, "demo-skill", "v1.0.0", "# restored\n")
    store = evolution_version_ctl.get_disk_evolution_store([str(skills_dir)])
    result = await evolution_version_ctl.do_evolve_rollback(store, "demo-skill", "latest")
    assert result["ok"] is True
    assert result["rolled_back"] is True
    live = json.loads(skill_dir.joinpath("evolutions.json").read_text(encoding="utf-8"))
    assert live["entries"] == []


@pytest.mark.anyio
async def test_handle_skills_evolution_rollback_accepts_office_claw_skill_path(
    tmp_path, monkeypatch,
):
    """Control-plane .office-claw/skills path must pass even if adapter is workspace-only."""
    workspace_skills = tmp_path / "workspace" / "skills"
    workspace_skills.mkdir(parents=True)

    project_root = tmp_path / "relay-claw"
    skills_dir = project_root / ".office-claw" / "skills"
    skill_dir = skills_dir / "tianqi"
    archive = skill_dir / "archive"
    archive.mkdir(parents=True)
    skill_md = skill_dir / "SKILL.md"
    skill_md.write_text("# current\n", encoding="utf-8")
    skill_dir.joinpath("evolutions.json").write_text(
        json.dumps(
            {
                "skill_id": "tianqi",
                "version": "v2.0.0",
                "updated_at": "live",
                "entries": [],
            },
            ensure_ascii=False,
        ),
        encoding="utf-8",
    )
    archive.joinpath("SKILL.v1.0.0.md").write_text("# archived-body\n", encoding="utf-8")
    archive.joinpath("evolutions.v1.0.0.json").write_text(
        json.dumps(
            {
                "skill_id": "tianqi",
                "version": "v1.0.0",
                "updated_at": "archived",
                "entries": [],
            },
            ensure_ascii=False,
        ),
        encoding="utf-8",
    )

    adapter = JiuWenSwarmDeepAdapter()
    monkeypatch.setattr(adapter, "_resolve_skill_dirs", lambda: [str(workspace_skills)])
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.interface_deep.resolve_agent_registered_skill_dirs",
        lambda: [workspace_skills],
    )
    monkeypatch.setattr(
        evolution_version_ctl,
        "resolve_agent_registered_skill_dirs",
        lambda: [workspace_skills],
    )

    result = await adapter.handle_skills_evolution_rollback(
        {
            "name": "tianqi",
            "version": "latest",
            "skill_path": str(skill_md),
        }
    )
    assert result["success"] is True
    assert result["rolled_back"] is True
    assert skill_md.read_text(encoding="utf-8") == "# archived-body\n"


@pytest.mark.anyio
async def test_generate_evolution_merge_version_accepts_office_claw_skill_path(
    tmp_path, monkeypatch,
):
    """Rebuild with skill_path must find skill even when adapter dirs are empty."""
    workspace_skills = tmp_path / "workspace" / "skills"
    workspace_skills.mkdir(parents=True)

    skills_dir = tmp_path / ".office-claw" / "skills"
    skill_dir = skills_dir / "image-reader"
    skill_dir.mkdir(parents=True)
    skill_md = skill_dir / "SKILL.md"
    skill_md.write_text(
        "---\nname: image-reader\nversion: 1.0.0\n---\n# image-reader\n",
        encoding="utf-8",
    )
    skill_dir.joinpath("evolutions.json").write_text(
        json.dumps(
            {
                "skill_id": "image-reader",
                "version": "v1.0.0",
                "updated_at": "live",
                "entries": [
                    {
                        "id": "ev_1",
                        "score": 0.9,
                        "summary": "fix path handling",
                    }
                ],
            },
            ensure_ascii=False,
        ),
        encoding="utf-8",
    )

    adapter = JiuWenSwarmDeepAdapter()
    adapter._instance = object()  # pylint: disable=protected-access
    adapter._model = object()  # pylint: disable=protected-access
    monkeypatch.setattr(adapter, "_resolve_skill_dirs", lambda: [str(workspace_skills)])
    monkeypatch.setattr(adapter, "_bind_request_env_overlay", lambda: (None, None, None))
    monkeypatch.setattr(adapter, "_reset_request_env_bindings", lambda *_a, **_k: None)
    monkeypatch.setattr(adapter, "_resolve_runtime_language", lambda: "cn")
    monkeypatch.setattr(adapter, "_resolve_model_name", lambda: "test-model")
    monkeypatch.setattr(adapter, "ensure_instance", AsyncMock())
    monkeypatch.setattr(adapter, "_apply_rebuild_permission_trusted_dirs", lambda *_a, **_k: None)

    captured_store_dirs: list[list[str]] = []
    real_get_store = evolution_version_ctl.get_disk_evolution_store

    def _capture_store(skills_dirs=None):
        dirs = [str(p) for p in (skills_dirs or [])]
        captured_store_dirs.append(dirs)
        return real_get_store(dirs)

    monkeypatch.setattr(
        evolution_version_ctl,
        "get_disk_evolution_store",
        _capture_store,
    )
    monkeypatch.setattr(
        evolution_version_ctl,
        "prepare_rebuild_followup",
        AsyncMock(
            return_value={
                "ok": True,
                "followup_prompt": "rebuild",
                "rebuild_context": {
                    "skill_md_path": str(skill_md),
                    "archive_pair": True,
                },
            }
        ),
    )
    monkeypatch.setattr(
        evolution_version_ctl,
        "finalize_rebuild_followup",
        AsyncMock(return_value={"ok": True, "new_version": "1.0.1", "cleared": True}),
    )

    async def _rewrite(**_kwargs: Any) -> bool:
        skill_md.write_text("# rebuilt\n", encoding="utf-8")
        return True

    monkeypatch.setattr(adapter, "_execute_merge_version_rewrite", _rewrite)

    result = await adapter.generate_evolution_merge_version(
        {
            "name": "image-reader",
            "skill_path": str(skill_md),
            "record_ids": ["ev_1"],
        }
    )
    assert result["success"] is True
    assert captured_store_dirs
    resolved_store = {str(Path(p).resolve()) for p in captured_store_dirs[0]}
    assert resolved_store == {str(skills_dir.resolve())}
    assert str(workspace_skills.resolve()) not in resolved_store


@pytest.mark.anyio
async def test_handle_skills_evolution_rollback_rejects_mismatched_skill_dir_name(
    tmp_path, monkeypatch,
):
    skills_dir = tmp_path / "skills"
    wrong = skills_dir / "wrong-name"
    wrong.mkdir(parents=True)
    skill_md = wrong / "SKILL.md"
    skill_md.write_text("# dummy\n", encoding="utf-8")

    adapter = JiuWenSwarmDeepAdapter()
    monkeypatch.setattr(adapter, "_resolve_skill_dirs", lambda: [str(skills_dir)])

    with pytest.raises(ValueError, match="directory name must match skill name"):
        await adapter.handle_skills_evolution_rollback(
            {
                "name": "demo-skill",
                "version": "latest",
                "skill_path": str(skill_md),
            }
        )


@pytest.mark.anyio
async def test_ws_disk_only_evolution_uses_agent_manager_not_stateless_agent(monkeypatch):
    """archives/rollback must not skip AgentManager disk-only skill-root binding."""
    from jiuwenswarm.common.schema.agent import AgentRequest, AgentResponse
    from jiuwenswarm.common.schema.message import ReqMethod
    from jiuwenswarm.server.agent_ws_server import AgentWebSocketServer

    server = object.__new__(AgentWebSocketServer)
    manager_calls: list[AgentRequest] = []
    stateless_calls: list[AgentRequest] = []

    class _Manager:
        async def process_message(self, request):
            manager_calls.append(request)
            return AgentResponse(
                request_id=request.request_id,
                channel_id=request.channel_id,
                ok=True,
                payload={"name": "tianqi", "versions": ["SKILL.v1.0.0.md"]},
            )

    class _Stateless:
        async def process_message(self, request):
            stateless_calls.append(request)
            raise AssertionError("stateless agent must not handle disk-only evolution")

    server._agent_manager = _Manager()  # pylint: disable=protected-access
    from jiuwenswarm.server.handlers import _default as _default_handlers

    monkeypatch.setattr(
        _default_handlers,
        "_uses_tenant_pool",
        lambda _request: False,
    )
    monkeypatch.setattr(
        _default_handlers,
        "_get_stateless_agent",
        AsyncMock(return_value=_Stateless()),
    )

    sent: list[Any] = []

    async def _send_wire(_ws, wire):
        sent.append(wire)
        return True

    monkeypatch.setattr(
        "jiuwenswarm.server.agent_ws_server.send_wire_payload",
        _send_wire,
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.agent_ws_server.encode_agent_response_for_wire",
        lambda resp, response_id=None: {"ok": resp.ok, "payload": resp.payload},
    )
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.interface_deep.ensure_persistent_checkpointer",
        AsyncMock(),
    )

    request = AgentRequest(
        request_id="req-disk",
        channel_id="web",
        req_method=ReqMethod.SKILLS_EVOLUTION_ROLLBACK,
        params={"name": "tianqi", "version": "latest", "skill_path": "X:/proj/.office-claw/skills/tianqi/SKILL.md"},
        is_stream=False,
    )
    from jiuwenswarm.server.context import AgentServerServices, RequestContext
    from jiuwenswarm.server.transports.sink import WSSink

    class _FakeWS:
        async def send(self, payload):
            sent.append(payload)

    ctx = RequestContext(
        request=request,
        sink=WSSink(_FakeWS(), asyncio.Lock()),
        services=AgentServerServices(server),
        connection_id="test",
    )
    await _default_handlers._handle_unary_impl(ctx, request)

    assert len(manager_calls) == 1
    assert not stateless_calls
    assert sent