Skip to content

Dodaios is an open-source agent OS for your desktop: it runs your coding agents, browser and apps by voice or chat, on your own machine. Formerly Personal Jarvis.

51.5 KB
Raw Blame
"""Binding an agent to its canonical chat; delivering board envelopes into it."""

from __future__ import annotations

import dataclasses
import os
from pathlib import Path
from types import SimpleNamespace

import pytest
from fastapi import FastAPI
from fastapi.testclient import TestClient

from dodaios.agent_chat.store import SURFACES, AgentChatStore
from dodaios.society.chat_binding import ensure_session, frame_incoming, make_deliver_hook
from dodaios.society.events import MsgType, SocietyEnvelope
from dodaios.society.runtime import SocietyRuntime


class FakeService:
    from dodaios.agent_chat.service import AgentChatService

    receive_message = AgentChatService.receive_message
    message_status = AgentChatService.message_status

    async def _emit(self, session_id, event):
        self.store.append_event(session_id, event)

    async def post_notice(self, session_id, payload):
        from dodaios.agent_chat.events import make_event

        await self._emit(session_id, make_event("notice", payload))

    async def cancel(self, _session_id, *, expected_turn_id=None):
        self.cancelled_turns.append(expected_turn_id)
        return False

    async def bind_society_session(self, session_id):
        from dodaios.society.chat_binding import bind_society_session

        return await bind_society_session(self, session_id)

    def __init__(self, store: AgentChatStore) -> None:
        self.store = store
        self.sent: list[tuple[str, str]] = []
        self.busy: set[str] = set()
        self.cancelled_turns: list[str | None] = []

    def is_running(self, session_id: str) -> bool:
        return session_id in self.busy

    async def send(self, session_id: str, text: str, attachments=None, *, incoming=None) -> str:
        self.sent.append((session_id, text))
        return "turn-1"


@pytest.fixture
async def world(tmp_path: Path):
    cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
    runtime = SocietyRuntime(tmp_path, seed_starter_team=False, cfg=lambda: cfg)
    await runtime.ensure_started()
    svc = FakeService(AgentChatStore(tmp_path / "agent_chat.db"))
    try:
        yield runtime, svc, cfg
    finally:
        await runtime.close()


async def _legacy_agent(rt: SocietyRuntime, agent):
    """Model a saved pre-approval-mode roster row in both stores."""
    await rt.store.update_agent(agent.agent_id, {"approval_mode": None})
    return dataclasses.replace(agent, approval_mode=None)


def test_society_is_a_surface():
    assert "society" in SURFACES


async def test_ensure_session_is_deterministic_and_reseats(world):
    rt, svc, cfg = world
    scout, _ = await rt.roster.create(name="Scout", provider="openai", model="gpt-5.2")
    first = ensure_session(svc, cfg, scout)
    assert first.session_id == "society:scout"
    assert first.surface == "society"
    assert first.provider == "openai" and first.model == "gpt-5.2"
    # New agents start on the Society ladder's Bypass default.
    assert first.permission_mode == "bypass"
    assert first.title == "Scout"
    assert Path(first.cwd).name == "workspace" and os.path.isdir(first.cwd)  # noqa: ASYNC240
    assert Path(first.cwd).is_absolute()

    again = ensure_session(svc, cfg, scout)
    assert again.session_id == first.session_id
    assert len(svc.store.list_sessions(surface="society")) == 1

    moved = await rt.roster.update("scout", {"provider": "gemini", "model": "gemini-3-pro"})
    reseated = ensure_session(svc, cfg, moved)
    assert reseated.provider == "gemini" and reseated.model == "gemini-3-pro"
    assert reseated.session_id == "society:scout"


async def test_legacy_ceiling_maps_to_stance(world):
    """A pre-migration row (no approval mode) keeps its ceiling's old stance."""
    rt, svc, cfg = world
    safe, _ = await rt.roster.create(name="Reader", provider="openai", permission_ceiling="safe")
    ask, _ = await rt.roster.create(name="Asker", provider="openai", permission_ceiling="ask")
    safe = dataclasses.replace(safe, approval_mode=None)
    ask = dataclasses.replace(ask, approval_mode=None)
    assert ensure_session(svc, cfg, safe).permission_mode == "plan"
    assert ensure_session(svc, cfg, ask).permission_mode == "ask"


async def test_existing_session_follows_roster_permissions_name_and_workspace(world):
    rt, svc, cfg = world
    agent, _ = await rt.roster.create(name="Scout", provider="openai")
    agent = await _legacy_agent(rt, agent)
    first = ensure_session(svc, cfg, agent)
    updated = await rt.roster.update(
        agent.agent_id,
        {
            "name": "Research Scout",
            "permission_ceiling": "safe",
            "workspace_dir": "society/scout/research",
        },
    )

    session = ensure_session(svc, cfg, updated)
    assert session.session_id == first.session_id
    assert session.permission_mode == "plan"
    assert session.title == "Research Scout"
    assert Path(session.cwd).name == "research"
    assert len(svc.store.list_sessions(surface="society")) == 1


async def test_rebinding_preserves_a_more_restrictive_user_stance(world):
    rt, svc, cfg = world
    agent, _ = await rt.roster.create(name="Scout", provider="openai")
    agent = await _legacy_agent(rt, agent)
    first = ensure_session(svc, cfg, agent)
    assert first.permission_mode == "ask"

    svc.store.update_session(first.session_id, permission_mode="plan")
    svc.store.set_permission_override(first.session_id, "plan")
    assert ensure_session(svc, cfg, agent).permission_mode == "plan"

    svc.store.update_session(first.session_id, permission_mode="ask")
    svc.store.set_permission_override(first.session_id, "ask")
    assert ensure_session(svc, cfg, agent).permission_mode == "ask"


async def test_relaxed_roster_ceiling_restores_default_without_user_override(world):
    rt, svc, cfg = world
    agent, _ = await rt.roster.create(name="Reader", provider="openai", permission_ceiling="safe")
    agent = await _legacy_agent(rt, agent)
    first = ensure_session(svc, cfg, agent)
    assert first.permission_mode == "plan"

    updated = await rt.roster.update(agent.agent_id, {"permission_ceiling": "monitor"})
    assert ensure_session(svc, cfg, updated).permission_mode == "accept-edits"

    svc.store.set_permission_override(first.session_id, "plan")
    assert ensure_session(svc, cfg, updated).permission_mode == "plan"


async def test_chat_route_records_an_explicit_permission_choice(world):
    from dodaios.ui.web.agent_chat_routes import router

    rt, svc, cfg = world
    agent, _ = await rt.roster.create(name="Scout", provider="openai")
    session = ensure_session(svc, cfg, agent)
    svc.controls = SimpleNamespace(state=lambda _sid: SimpleNamespace(goal=None))
    app = FastAPI()
    app.include_router(router)
    app.state.agent_chat = svc

    with TestClient(app) as client:
        response = client.patch(
            f"/api/agent-chat/sessions/{session.session_id}",
            json={"permission_mode": "ask"},
        )
        stale_model = client.patch(
            f"/api/agent-chat/sessions/{session.session_id}",
            json={"model": "not-the-roster-model"},
        )
    assert response.status_code == 200
    assert svc.store.permission_override(session.session_id) == "ask"
    assert ensure_session(svc, cfg, agent).permission_mode == "ask"
    assert stale_model.status_code == 200
    assert stale_model.json()["model"] == agent.model
    updates = [
        event["payload"]
        for event in svc.store.list_events(session.session_id)
        if event["kind"] == "session_updated"
    ]
    assert {"model": agent.model} in updates


async def test_safe_agent_route_clamps_a_requested_bypass(world):
    from dodaios.ui.web.agent_chat_routes import router

    rt, svc, cfg = world
    agent, _ = await rt.roster.create(name="Reader", provider="openai", permission_ceiling="safe")
    agent = await _legacy_agent(rt, agent)
    session = ensure_session(svc, cfg, agent)
    svc.controls = SimpleNamespace(state=lambda _sid: SimpleNamespace(goal=None))
    app = FastAPI()
    app.include_router(router)
    app.state.agent_chat = svc

    with TestClient(app) as client:
        response = client.patch(
            f"/api/agent-chat/sessions/{session.session_id}",
            json={"permission_mode": "bypass"},
        )
    assert response.status_code == 200
    assert response.json()["permission_mode"] == "plan"
    assert svc.store.get_session(session.session_id).permission_mode == "plan"
    assert svc.store.permission_override(session.session_id) == "plan"
    assert any(
        event["kind"] == "session_updated" and event["payload"].get("permission_mode") == "plan"
        for event in svc.store.list_events(session.session_id)
    )


async def test_society_route_rejects_an_unsupported_ask_before_storage(world, monkeypatch):
    from dodaios.ui.web import agent_chat_routes

    rt, svc, cfg = world
    agent, _ = await rt.roster.create(name="Scout", provider="openai")
    session = ensure_session(svc, cfg, agent)
    monkeypatch.setattr(agent_chat_routes, "resolve_runner", lambda *_args, **_kw: "grok-cli")
    app = FastAPI()
    app.include_router(agent_chat_routes.router)
    app.state.agent_chat = svc

    with TestClient(app) as client:
        response = client.patch(
            f"/api/agent-chat/sessions/{session.session_id}",
            json={"permission_mode": "ask"},
        )
    assert response.status_code == 422
    assert svc.store.permission_override(session.session_id) == ""
    assert svc.store.get_session(session.session_id).permission_mode == "bypass"


async def test_society_patch_does_not_reseat_if_a_turn_starts_during_cleanup(world):
    from dodaios.ui.web.agent_chat_routes import router

    rt, svc, cfg = world
    agent, _ = await rt.roster.create(name="Scout", provider="openai")
    session = ensure_session(svc, cfg, agent)

    async def begin_turn(_session_id):
        svc.busy.add(session.session_id)

    svc.controls = SimpleNamespace(
        state=lambda _sid: SimpleNamespace(goal=None),
        _clear_saved_native=begin_turn,
    )
    app = FastAPI()
    app.include_router(router)
    app.state.agent_chat = svc
    with TestClient(app) as client:
        response = client.patch(
            f"/api/agent-chat/sessions/{session.session_id}",
            json={"provider": "gemini"},
        )
    assert response.status_code == 409
    assert svc.store.get_session(session.session_id).provider == "openai"


async def test_direct_send_rebinds_safe_agent_before_runner(tmp_path: Path):
    from dodaios.agent_chat.service import AgentChatService

    store = AgentChatStore(tmp_path / "agent_chat.db")
    svc = AgentChatService(store, assistant_name=lambda: "Test")
    cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
    rt = SocietyRuntime(
        tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
    )
    await rt.ensure_started()
    try:
        agent, _ = await rt.roster.create(
            name="Reader", provider="openai", permission_ceiling="safe"
        )
        agent = await _legacy_agent(rt, agent)
        session = ensure_session(svc, cfg, agent)
        store.update_session(session.session_id, permission_mode="bypass")
        store.set_permission_override(session.session_id, "bypass")
        observed: list[str] = []

        async def capture(handle, _text):
            observed.append(handle.session.permission_mode)

        await svc.send(
            session.session_id,
            "Read the note",
            control_runner=capture,
            control_owned=True,
            direct_user=False,
        )
        await svc.wait_turn(session.session_id)
        assert observed == ["plan"]
        assert store.get_session(session.session_id).permission_mode == "plan"
    finally:
        await svc.cancel_all()
        await rt.close()


async def test_routine_chat_rejects_direct_messages_and_inactive_owner(tmp_path: Path):
    from dodaios.agent_chat.service import AgentChatService
    from dodaios.ui.web.agent_chat_routes import router

    store = AgentChatStore(tmp_path / "agent_chat.db")
    svc = AgentChatService(store, assistant_name=lambda: "Test")
    cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
    rt = SocietyRuntime(
        tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
    )
    await rt.ensure_started()
    try:
        agent, _ = await rt.roster.create(name="Scout", provider="openai")
        routine = store.create_session(
            session_id=f"{agent.session_id}:routine:task-1:run-1",
            surface="society",
            provider="openai",
            model="",
            effort="low",
            cwd=str(tmp_path),
            permission_mode="bypass",
        )
        app = FastAPI()
        app.include_router(router)
        app.state.agent_chat = svc
        with TestClient(app) as client:
            response = client.post(
                f"/api/agent-chat/sessions/{routine.session_id}/messages",
                json={"text": "Do something unrelated"},
            )
        assert response.status_code == 403
        assert store.list_events(routine.session_id) == []

        await rt.roster.update(agent.agent_id, {"state": "paused"})
        with pytest.raises(PermissionError, match="active scheduled run"):
            await svc.send(
                routine.session_id, "Scheduled task", direct_user=False, routine_run=True
            )
    finally:
        await svc.cancel_all()
        await rt.close()


async def test_busy_turn_defers_provider_reseat_until_it_finishes(tmp_path: Path):
    import asyncio

    from dodaios.agent_chat.control_types import CommandRequest
    from dodaios.agent_chat.service import AgentChatService, SessionBusy

    store = AgentChatStore(tmp_path / "agent_chat.db")
    svc = AgentChatService(store, assistant_name=lambda: "Test")
    cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
    rt = SocietyRuntime(
        tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
    )
    await rt.ensure_started()
    started = asyncio.Event()
    release = asyncio.Event()
    try:
        agent, _ = await rt.roster.create(name="Scout", provider="openai", model="old")
        session = ensure_session(svc, cfg, agent)

        async def held_runner(_handle, _text):
            started.set()
            await release.wait()
            return "old-vendor-session"

        await svc.send(
            session.session_id,
            "First task",
            control_runner=held_runner,
            control_owned=True,
            direct_user=False,
        )
        await asyncio.wait_for(started.wait(), timeout=3)
        await rt.roster.update(agent.agent_id, {"provider": "gemini", "model": "new"})
        with pytest.raises(SessionBusy):
            await svc.send(session.session_id, "Second task")
        command = await svc.controls.execute(
            session.session_id, CommandRequest(command="status", request_id="busy-status")
        )
        assert command.status == "done"
        assert command.data["running"] is True
        assert store.get_session(session.session_id).provider == "openai"

        release.set()
        await svc.wait_turn(session.session_id)
        assert store.get_session(session.session_id).vendor_session == "old-vendor-session"
        moved = await svc.bind_society_session(session.session_id)
        assert moved.provider == "gemini" and moved.model == "new"
        assert moved.vendor_session == ""
    finally:
        release.set()
        await svc.cancel_all()
        await rt.close()


async def test_an_older_side_chat_is_read_only(tmp_path: Path):
    """Side chats from before the one-chat change stay readable, never run."""
    from dodaios.agent_chat.service import AgentChatService

    store = AgentChatStore(tmp_path / "agent_chat.db")
    svc = AgentChatService(store, assistant_name=lambda: "Test")
    cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
    rt = SocietyRuntime(
        tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
    )
    await rt.ensure_started()
    try:
        agent, _ = await rt.roster.create(name="Scout", provider="openai")
        legacy = store.create_session(
            session_id=f"{agent.session_id}:with:jarvis", surface="society",
            provider="openai", model="", effort="", cwd=str(tmp_path),
            permission_mode="bypass", title="Scout · Jarvis",
        )
        with pytest.raises(PermissionError, match="read-only"):
            await svc.bind_society_session(legacy.session_id)
        chat = ensure_session(svc, cfg, agent)
        assert chat.session_id == agent.session_id
        assert (await svc.bind_society_session(chat.session_id)).session_id == agent.session_id
    finally:
        await svc.cancel_all()
        await rt.close()


async def test_routine_turn_does_not_reserve_direct_chat_seat(tmp_path: Path):
    import asyncio

    from dodaios.agent_chat.service import AgentChatService

    store = AgentChatStore(tmp_path / "agent_chat.db")
    svc = AgentChatService(store, assistant_name=lambda: "Test")
    cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
    rt = SocietyRuntime(
        tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
    )
    await rt.ensure_started()
    entered = asyncio.Event()
    release = asyncio.Event()
    try:
        agent, _ = await rt.roster.create(name="Scout", provider="openai")
        direct = ensure_session(svc, cfg, agent)
        routine = store.create_session(
            session_id=f"{agent.session_id}:routine:task-1:run-1",
            surface="society", provider="openai", model="", effort="low",
            cwd=direct.cwd, permission_mode="bypass",
        )

        async def held_runner(_handle, _text):
            entered.set()
            await release.wait()

        await svc.send(
            direct.session_id, "Direct task", control_runner=held_runner,
            control_owned=True, direct_user=False,
        )
        await asyncio.wait_for(entered.wait(), timeout=3)
        await svc.send(
            routine.session_id, "Scheduled task", control_runner=held_runner,
            control_owned=True, direct_user=False, routine_run=True,
        )
        assert svc.is_running(direct.session_id)
        assert svc.is_running(routine.session_id)
    finally:
        release.set()
        await svc.cancel_all()
        await rt.close()


async def test_build_cannot_raise_a_safe_agent_above_its_ceiling(world):
    from dodaios.agent_chat.control import ChatControls
    from dodaios.agent_chat.control_types import CommandRequest

    rt, svc, cfg = world
    agent, _ = await rt.roster.create(name="Scout", provider="openai")
    agent = await _legacy_agent(rt, agent)
    session = ensure_session(svc, cfg, agent)
    controls = ChatControls(svc, adapters=[])
    svc.controls = controls
    plan = await controls.execute(
        session.session_id, CommandRequest(command="plan", request_id="plan-1")
    )
    assert plan.status == "done"
    updated = await rt.roster.update(agent.agent_id, {"permission_ceiling": "safe"})
    assert updated.permission_ceiling == "safe"
    build = await controls.execute(
        session.session_id, CommandRequest(command="build", request_id="build-1")
    )
    assert build.status == "failed"
    assert svc.store.get_session(session.session_id).permission_mode == "plan"
    assert svc.store.permission_override(session.session_id) == "plan"


async def test_build_sees_a_relaxed_roster_ceiling_before_checking_plan(world):
    from dodaios.agent_chat.control import ChatControls
    from dodaios.agent_chat.control_types import CommandRequest

    rt, svc, cfg = world
    agent, _ = await rt.roster.create(name="Reader", provider="openai", permission_ceiling="safe")
    agent = await _legacy_agent(rt, agent)
    session = ensure_session(svc, cfg, agent)
    controls = ChatControls(svc, adapters=[])
    svc.controls = controls
    await rt.roster.update(agent.agent_id, {"permission_ceiling": "monitor"})

    result = await controls.execute(
        session.session_id, CommandRequest(command="build", request_id="build-after-roster")
    )
    assert result.status == "done"
    assert svc.store.get_session(session.session_id).permission_mode == "ask"


async def test_provider_change_with_default_model_discards_old_provider_model(world):
    rt, svc, cfg = world
    agent, _ = await rt.roster.create(name="Scout", provider="openai", model="gpt-5.2")
    first = ensure_session(svc, cfg, agent)
    assert first.model == "gpt-5.2"

    updated = await rt.roster.update(agent.agent_id, {"provider": "gemini", "model": ""})
    session = ensure_session(svc, cfg, updated)
    assert session.provider == "gemini"
    assert session.model == ""
    assert session.session_id == first.session_id


async def test_explicit_approval_mode_wins(world):
    rt, svc, cfg = world
    asker, _ = await rt.roster.create(name="Asker", provider="openai")
    asker = await rt.roster.update("asker", {"approval_mode": "ask"})
    assert ensure_session(svc, cfg, asker).permission_mode == "ask"


async def test_explicit_chat_mode_stays_separate_from_tool_ceiling(world):
    rt, svc, cfg = world
    agent, _ = await rt.roster.create(
        name="Reader", provider="openai", permission_ceiling="safe"
    )
    session = ensure_session(svc, cfg, agent)
    assert session.permission_mode == "bypass"

    agent = await rt.roster.update(agent.agent_id, {"approval_mode": "ask"})
    assert ensure_session(svc, cfg, agent).permission_mode == "ask"

    svc.store.set_permission_override(session.session_id, "always_ask")
    assert ensure_session(svc, cfg, agent).permission_mode == "always_ask"


async def test_legacy_ask_agent_refuses_runner_without_actionable_approvals(world, monkeypatch):
    rt, svc, cfg = world
    agent, _ = await rt.roster.create(name="Legacy", provider="openai")
    agent = await _legacy_agent(rt, agent)
    monkeypatch.setattr(
        "dodaios.agent_chat.service.resolve_runner", lambda *_args, **_kw: "grok-cli"
    )

    with pytest.raises(PermissionError, match="actionable approval"):
        ensure_session(svc, cfg, agent)
    assert svc.store.get_session(agent.session_id) is None


@pytest.mark.parametrize("blocked_by", ["paused", "kill_switch"])
async def test_inactive_agent_cannot_bind_canonical_chat(world, blocked_by):
    from dodaios.society.chat_binding import bind_society_session

    rt, svc, cfg = world
    agent, _ = await rt.roster.create(name="Scout", provider="openai")
    ensure_session(svc, cfg, agent)
    if blocked_by == "paused":
        await rt.roster.update(agent.agent_id, {"state": "paused"})
    else:
        await rt.store.set_kill_switch(True)

    with pytest.raises(PermissionError, match="paused or disabled"):
        await bind_society_session(svc, agent.session_id)


@pytest.mark.parametrize(
    ("blocked_by", "active_goal"), [("paused", True), ("kill_switch", False)]
)
async def test_live_roster_change_during_pre_admission_await_blocks_turn(
    tmp_path: Path, monkeypatch: pytest.MonkeyPatch, blocked_by: str, active_goal: bool,
):
    import asyncio

    from dodaios.agent_chat.control_types import GoalState
    from dodaios.agent_chat.service import AgentChatService

    store = AgentChatStore(tmp_path / "agent_chat.db")
    svc = AgentChatService(store, assistant_name=lambda: "Test")
    cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
    rt = SocietyRuntime(
        tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
    )
    await rt.ensure_started()
    entered = asyncio.Event()
    release = asyncio.Event()
    sending = None
    try:
        agent, _ = await rt.roster.create(name="Scout", provider="openai")
        session = ensure_session(svc, cfg, agent)
        controls = svc.controls
        if active_goal:
            state = controls.state(session.session_id)
            state.goal = GoalState(
                id="goal-1", objective="Keep the task", started_ms=1, updated_ms=1
            )
            controls.store.save(state)
        original_get = rt.roster.get
        calls = 0

        async def held_second_roster_read(agent_id):
            nonlocal calls
            calls += 1
            if calls == 2:
                entered.set()
                await release.wait()
            return await original_get(agent_id)

        monkeypatch.setattr(rt.roster, "get", held_second_roster_read)

        async def fake_runner(_handle, _text):
            pytest.fail("a disabled Society agent must never start paid work")

        sending = asyncio.create_task(
            svc.send(session.session_id, "Task", control_runner=fake_runner)
        )
        await asyncio.wait_for(entered.wait(), timeout=3)
        assert controls.state(session.session_id).last_status == "running"
        if blocked_by == "paused":
            await rt.roster.update(agent.agent_id, {"state": "paused"})
        else:
            await rt.store.set_kill_switch(True)
        release.set()
        with pytest.raises(PermissionError, match="paused or disabled"):
            await sending
        assert not svc.is_running(session.session_id)
        state = controls.state(session.session_id)
        assert state.last_status == ("interrupted" if active_goal else "failed")
        if active_goal:
            assert state.goal is not None
            assert state.goal.status == "paused"
            assert state.goal.objective == "Keep the task"
        assert not any(
            event["kind"] in ("user_message", "turn_started")
            for event in store.list_events(session.session_id)
        )
    finally:
        release.set()
        if sending is not None and not sending.done():
            sending.cancel()
            await asyncio.gather(sending, return_exceptions=True)
        await svc.cancel_all()
        await rt.close()


async def test_final_society_rebind_keeps_read_only_turn_override(
    tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
):
    import asyncio

    from dodaios.agent_chat.service import AgentChatService

    store = AgentChatStore(tmp_path / "agent_chat.db")
    svc = AgentChatService(store, assistant_name=lambda: "Test")
    cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
    rt = SocietyRuntime(
        tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
    )
    await rt.ensure_started()
    entered = asyncio.Event()
    release = asyncio.Event()
    observed: list[tuple[str, str]] = []

    async def held_control_message(_sid, _text):
        entered.set()
        await release.wait()

    monkeypatch.setattr(svc.controls, "user_message", held_control_message)
    try:
        agent, _ = await rt.roster.create(name="Scout", provider="openai")
        session = ensure_session(svc, cfg, agent)

        async def fake_runner(handle, _text):
            observed.append((handle.session.permission_mode, handle.stance))

        sending = asyncio.create_task(
            svc.send(session.session_id, "Read only task", read_only=True,
                     control_runner=fake_runner)
        )
        await asyncio.wait_for(entered.wait(), timeout=3)
        release.set()
        await sending
        await svc.wait_turn(session.session_id)
        assert observed == [("plan", "plan")]
        assert store.get_session(session.session_id).permission_mode == "bypass"
    finally:
        release.set()
        await svc.cancel_all()
        await rt.close()


async def test_two_sends_cannot_replace_pre_admission_control_owner(
    tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
):
    import asyncio

    from dodaios.agent_chat.events import make_event
    from dodaios.agent_chat.service import AgentChatService, SessionBusy

    store = AgentChatStore(tmp_path / "agent_chat.db")
    svc = AgentChatService(store, assistant_name=lambda: "Test")
    cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
    rt = SocietyRuntime(
        tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
    )
    await rt.ensure_started()
    entered = asyncio.Event()
    release = asyncio.Event()
    finished = asyncio.Event()
    sending = None
    try:
        agent, _ = await rt.roster.create(name="Scout", provider="openai")
        session = ensure_session(svc, cfg, agent)
        controls = svc.controls
        original_completed = controls.turn_completed

        async def mark_completed(*args):
            await original_completed(*args)
            finished.set()

        monkeypatch.setattr(controls, "turn_completed", mark_completed)
        original_get = rt.roster.get
        calls = 0

        async def held_second_roster_read(agent_id):
            nonlocal calls
            calls += 1
            if calls == 2:
                entered.set()
                await release.wait()
            return await original_get(agent_id)

        monkeypatch.setattr(rt.roster, "get", held_second_roster_read)

        async def fake_runner(handle, _text):
            await handle.emit(make_event(
                "turn_finished", {"turn_id": handle.turn_id, "status": "done"}
            ))

        sending = asyncio.create_task(
            svc.send(session.session_id, "Task A", control_runner=fake_runner)
        )
        await asyncio.wait_for(entered.wait(), timeout=3)
        assert controls.state(session.session_id).last_request == "Task A"
        with pytest.raises(SessionBusy):
            await svc.send(session.session_id, "Task B", control_runner=fake_runner)
        assert controls.state(session.session_id).last_request == "Task A"

        release.set()
        await sending
        await asyncio.wait_for(finished.wait(), timeout=3)
        state = controls.state(session.session_id)
        assert state.last_request == "Task A"
        assert state.last_status == "done"
        assert not any(
            event["kind"] == "user_message"
            and event["payload"].get("text") == "Task B"
            for event in store.list_events(session.session_id)
        )
    finally:
        release.set()
        if sending is not None and not sending.done():
            sending.cancel()
            await asyncio.gather(sending, return_exceptions=True)
        await svc.cancel_all()
        await rt.close()


async def test_stop_during_final_roster_lookup_prevents_a_runner(
    tmp_path: Path, monkeypatch: pytest.MonkeyPatch,
):
    import asyncio

    from dodaios.agent_chat.service import AgentChatService

    store = AgentChatStore(tmp_path / "agent_chat.db")
    svc = AgentChatService(store, assistant_name=lambda: "Test")
    cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
    rt = SocietyRuntime(
        tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
    )
    await rt.ensure_started()
    entered = asyncio.Event()
    release = asyncio.Event()
    sending = None
    try:
        agent, _ = await rt.roster.create(name="Scout", provider="openai")
        session = ensure_session(svc, cfg, agent)
        controls = svc.controls
        original_get = rt.roster.get
        calls = 0

        async def held_second_roster_read(agent_id):
            nonlocal calls
            calls += 1
            if calls == 2:
                entered.set()
                await release.wait()
            return await original_get(agent_id)

        monkeypatch.setattr(rt.roster, "get", held_second_roster_read)

        async def fake_runner(_handle, _text):
            pytest.fail("Stop must prevent the runner from starting")

        sending = asyncio.create_task(
            svc.send(session.session_id, "Task", control_runner=fake_runner)
        )
        await asyncio.wait_for(entered.wait(), timeout=3)
        assert controls.state(session.session_id).last_status == "running"
        assert svc.is_running(session.session_id)
        await controls.pause(session.session_id, "Stopped by the user")
        release.set()
        with pytest.raises(asyncio.CancelledError):
            await sending
        assert not svc.is_running(session.session_id)
        assert controls.state(session.session_id).last_status == "interrupted"
        assert not any(
            event["kind"] == "turn_started"
            for event in store.list_events(session.session_id)
        )
    finally:
        release.set()
        if sending is not None and not sending.done():
            sending.cancel()
            await asyncio.gather(sending, return_exceptions=True)
        await svc.cancel_all()
        await rt.close()


async def test_roster_mode_edit_defers_busy_chat_and_preserves_override(world, monkeypatch):
    from dodaios.ui.web.society_routes import router

    rt, svc, cfg = world
    monkeypatch.setattr(rt, "_get_chat", lambda: svc)
    agent, _ = await rt.roster.create(name="Scout", provider="openai", approval_mode="ask")
    session = ensure_session(svc, cfg, agent)
    svc.store.set_permission_override(session.session_id, "always_ask")
    assert ensure_session(svc, cfg, agent).permission_mode == "always_ask"
    svc.busy.add(session.session_id)

    app = FastAPI()
    app.include_router(router)
    app.state.society = rt
    with TestClient(app) as client:
        response = client.patch(
            f"/api/society/agents/{agent.agent_id}",
            json={"approval_mode": "bypass"},
        )
    assert response.status_code == 200, response.text
    assert svc.store.get_session(session.session_id).permission_mode == "always_ask"

    svc.busy.remove(session.session_id)
    updated = await rt.roster.get(agent.agent_id)
    assert ensure_session(svc, cfg, updated).permission_mode == "always_ask"


@pytest.mark.parametrize(
    ("method", "suffix", "payload"),
    [
        ("POST", "/model", {"provider": "grok", "model": "grok-test"}),
        ("PATCH", "", {"provider": "grok"}),
    ],
)
async def test_runner_change_rejects_incompatible_chat_override(
    world, monkeypatch, method, suffix, payload
):
    from dodaios.ui.web.society_routes import router

    rt, svc, cfg = world
    monkeypatch.setattr(rt, "_get_chat", lambda: svc)
    agent, _ = await rt.roster.create(name="Scout", provider="openai")
    session = ensure_session(svc, cfg, agent)
    svc.store.set_permission_override(session.session_id, "always_ask")
    assert ensure_session(svc, cfg, agent).permission_mode == "always_ask"
    monkeypatch.setattr(
        "dodaios.agent_chat.service.resolve_runner",
        lambda provider, **_kw: "grok-cli" if provider == "grok" else "brain",
    )

    app = FastAPI()
    app.include_router(router)
    app.state.society = rt
    with TestClient(app) as client:
        response = client.request(
            method,
            f"/api/society/agents/{agent.agent_id}{suffix}",
            json=payload,
        )
    assert response.status_code == 422
    assert (await rt.roster.get(agent.agent_id)).provider == "openai"
    assert svc.store.get_session(session.session_id).provider == "openai"


async def test_without_provider_the_agents_tier_answers(world, monkeypatch):
    rt, svc, cfg = world
    import dodaios.local_models.assistant_session as tier_mod

    monkeypatch.setattr(
        tier_mod,
        "agents_tier",
        lambda cfg, **kw: SimpleNamespace(provider="grok", model="grok-5", ready=True, reason=""),
    )
    scout, _ = await rt.roster.create(name="Scout")
    session = ensure_session(svc, cfg, scout)
    assert session.provider == "grok" and session.model == "grok-5"

    monkeypatch.setattr(
        tier_mod,
        "agents_tier",
        lambda cfg, **kw: SimpleNamespace(provider="", model="", ready=False, reason="no key"),
    )
    quill, _ = await rt.roster.create(name="Quill")
    with pytest.raises(PermissionError):
        ensure_session(svc, cfg, quill)


async def test_deliver_hook_frames_and_sends(world):
    rt, svc, cfg = world
    scout, _ = await rt.roster.create(name="Scout", provider="openai")
    deliver = make_deliver_hook(lambda: svc, lambda: cfg, resolve_name=lambda a: a.title())
    env = SocietyEnvelope(
        msg_type=MsgType.QUERY,
        from_agent="archivist",
        to_agent="scout",
        trace_id="t",
        payload={"text": "Where is the VPS note?", "refs": ["wiki:society/archivist/vps.md"]},
    )
    await deliver(scout, env)
    # A teammate's message runs in Scout's one chat, as a delegation card.
    assert svc.sent == [
        (
            "society:scout",
            "[query from Archivist]\nWhere is the VPS note?\nRefs: wiki:society/archivist/vps.md\n"
            f"Message id: {env.event_id}; sender id: archivist\n"
            "Reply expectation: always. Answer with society_message_agent kind 'answer' "
            "(reply_status=blocked if you cannot).",
        )
    ]
    assert svc.store.get_session("society:scout:with:archivist") is None
    assert svc.store.get_session("society:scout").title == "Scout"
    svc.busy.add("society:scout")
    with pytest.raises(RuntimeError, match="target busy"):
        await deliver(scout, env)


def test_result_frame_carries_the_handoff():
    env = SocietyEnvelope(
        msg_type=MsgType.RESULT,
        from_agent="scout",
        to_agent="archivist",
        trace_id="t",
        payload={
            "status": "partial",
            "done": "Found three providers.",
            "output": ["wiki:society/scout/vps.md"],
            "open": ["pricing for the 4 GB tier"],
        },
    )
    text = frame_incoming(env, "Scout")
    assert text.splitlines()[:5] == [
        "[result from Scout]",
        "Status: partial",
        "Done: Found three providers.",
        "Output: wiki:society/scout/vps.md",
        "Open: pricing for the 4 GB tier",
    ]


async def test_scheduler_delivers_through_the_hook(world):
    rt, svc, cfg = world
    await rt.roster.create(name="Scout", provider="openai")
    await rt.roster.create(name="Archivist", provider="openai")
    rt.set_deliver(make_deliver_hook(lambda: svc, lambda: cfg))
    await rt.say(from_agent="scout", to_agent="archivist", text="ping")
    assert [s[0] for s in svc.sent] == ["society:archivist"]
    assert svc.sent[0][1].startswith("[say from Scout]")


def test_unfiltered_session_list_hides_society_sessions(tmp_path: Path):
    from dodaios.ui.web.agent_chat_routes import router

    store = AgentChatStore(tmp_path / "agent_chat.db")
    store.create_session(provider="openai", model="m", effort="", cwd="", surface="agent")
    store.create_session(
        provider="openai", model="m", effort="", cwd="", surface="society", session_id="society:x"
    )
    app = FastAPI()
    app.include_router(router)
    app.state.agent_chat = SimpleNamespace(
        store=store, is_running=lambda sid: False, pending_approvals=lambda sid: []
    )
    with TestClient(app) as c:
        everything = c.get("/api/agent-chat/sessions").json()["sessions"]
        assert [s["surface"] for s in everything] == ["agent"]
        only = c.get("/api/agent-chat/sessions", params={"surface": "society"}).json()["sessions"]
        assert [s["session_id"] for s in only] == ["society:x"]


class FakeTurnService(FakeService):
    """A service whose turns end: the watcher must write a RESULT and free the slot."""

    def __init__(self, store: AgentChatStore) -> None:
        super().__init__(store)
        self.queues: dict[str, list] = {}

    def subscribe(self, session_id: str):
        import asyncio

        q = asyncio.Queue()
        self.queues.setdefault(session_id, []).append(q)
        return q

    def unsubscribe(self, session_id: str, q) -> None:
        subscribers = self.queues.get(session_id, [])
        if q in subscribers:
            subscribers.remove(q)

    async def send(self, session_id: str, text: str, attachments=None, *, incoming=None) -> str:
        self.sent.append((session_id, text))
        # A sent turn runs until it finishes, as in the real service: the
        # watcher must not take a quiet but live turn for one that has ended.
        self.busy.add(session_id)
        return "turn-1"

    async def finish(self, session_id: str, text: str, *, status: str = "ok") -> None:
        self.busy.discard(session_id)
        for q in list(self.queues.get(session_id, [])):
            q.put_nowait({"kind": "assistant_text", "payload": {"turn_id": "turn-1", "text": text}})
            q.put_nowait(
                {"kind": "turn_finished", "payload": {"turn_id": "turn-1", "status": status}}
            )


async def test_assign_runs_in_the_canonical_chat_and_ends_as_a_result(tmp_path: Path):
    import asyncio

    svc = FakeTurnService(AgentChatStore(tmp_path / "agent_chat.db"))
    cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
    rt = SocietyRuntime(
        tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
    )
    await rt.ensure_started()
    try:
        await rt.roster.create(name="Scout", provider="openai", model="gpt-5.2")
        env = await rt.say(
            from_agent="user", to_agent="scout", text="Find the best VPS.", msg_type=MsgType.ASSIGN
        )
        # The assignment became a framed chat turn on Scout's own session.
        assert svc.sent[0][0] == "society:scout"
        assert svc.sent[0][1].startswith("[assignment from the user]\nFind the best VPS.")
        assert "handoff" in svc.sent[0][1]
        assert rt.scheduler.running == {"turn:turn-1": "scout"}
        await svc.finish("society:scout", "Hetzner CX22 wins. Done.")
        await asyncio.sleep(0.05)
        assert rt.scheduler.running == {}
        thread = await rt.store.events_for_trace(env.trace_id)
        assert [e.msg_type for e in thread] == [MsgType.ASSIGN, MsgType.CLAIM, MsgType.RESULT]
        result = thread[-1]
        assert result.from_agent == "scout" and result.payload["status"] == "done"
        assert result.payload["done"] == "Hetzner CX22 wins. Done."
        assert result.payload["output"] == ["chat:society:scout"]
    finally:
        await rt.close()


async def test_failed_turn_becomes_a_blocked_result(tmp_path: Path):
    import asyncio

    svc = FakeTurnService(AgentChatStore(tmp_path / "agent_chat.db"))
    cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
    rt = SocietyRuntime(
        tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
    )
    await rt.ensure_started()
    try:
        await rt.roster.create(name="Scout", provider="openai")
        env = await rt.say(from_agent="user", to_agent="scout", text="x", msg_type=MsgType.ASSIGN)
        await svc.finish("society:scout", "", status="error")
        await asyncio.sleep(0.05)
        result = (await rt.store.events_for_trace(env.trace_id))[-1]
        assert result.msg_type is MsgType.RESULT and result.payload["status"] == "blocked"
        assert result.payload["open"]
    finally:
        await rt.close()


async def test_a_picture_that_could_not_be_shown_does_not_block_finished_work(tmp_path: Path):
    """Live 2026-10-02: Scout's finished research came back "blocked" because
    two screenshots it mentioned could not be displayed in its chat."""
    import asyncio

    svc = FakeTurnService(AgentChatStore(tmp_path / "agent_chat.db"))
    cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
    rt = SocietyRuntime(
        tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
    )
    await rt.ensure_started()
    try:
        await rt.roster.create(name="Scout", provider="openai")
        env = await rt.say(from_agent="user", to_agent="scout", text="x", msg_type=MsgType.ASSIGN)
        for q in list(svc.queues["society:scout"]):
            for kind, payload in (
                ("assistant_text", {"text": "Research done: three findings."}),
                ("assistant_text", {"text": "![image](/media/a.png)", "media_only": True}),
                ("error", {"message": "Media could not be displayed: a.png",
                           "display_only": True}),
                ("turn_finished", {"status": "ok"}),
            ):
                q.put_nowait({"kind": kind, "payload": {"turn_id": "turn-1", **payload}})
        await asyncio.sleep(0.05)
        result = (await rt.store.events_for_trace(env.trace_id))[-1]
        assert result.msg_type is MsgType.RESULT
        assert result.payload["status"] == "done"
        assert result.payload["done"] == "Research done: three findings."
    finally:
        await rt.close()


async def test_empty_successful_turn_does_not_claim_task_completion(tmp_path: Path):
    import asyncio

    svc = FakeTurnService(AgentChatStore(tmp_path / "agent_chat.db"))
    cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
    rt = SocietyRuntime(
        tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
    )
    await rt.ensure_started()
    try:
        await rt.roster.create(name="Scout", provider="openai")
        env = await rt.say(from_agent="user", to_agent="scout", text="x", msg_type=MsgType.ASSIGN)
        await svc.finish("society:scout", "")
        await asyncio.sleep(0.05)
        result = (await rt.store.events_for_trace(env.trace_id))[-1]
        assert result.msg_type is MsgType.RESULT
        assert result.payload["status"] == "blocked"
        assert result.payload["open"] == ["Agent finished without a result report."]
    finally:
        await rt.close()


async def test_lost_subscriber_recovers_the_durable_turn_result(tmp_path: Path, monkeypatch):
    import asyncio

    import dodaios.society.runtime as runtime_module
    from dodaios.agent_chat.events import make_event

    monkeypatch.setattr(runtime_module, "_WATCH_EVENT_POLL_SECONDS", 0.01)
    svc = FakeTurnService(AgentChatStore(tmp_path / "agent_chat.db"))
    cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
    rt = SocietyRuntime(
        tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
    )
    await rt.ensure_started()
    try:
        await rt.roster.create(name="Scout", provider="openai")
        env = await rt.say(
            from_agent="user", to_agent="scout", text="Find the answer", msg_type=MsgType.ASSIGN
        )
        # A full subscriber queue is detached by the service. The terminal
        # event still lives in the chat store but never reaches this queue.
        svc.queues["society:scout"].clear()
        svc.store.append_event(
            "society:scout",
            make_event("assistant_text", {"turn_id": "turn-1", "text": "Found the answer."}),
        )
        svc.store.append_event(
            "society:scout",
            make_event("turn_finished", {"turn_id": "turn-1", "status": "done"}),
        )
        for _ in range(20):
            thread = await rt.store.events_for_trace(env.trace_id)
            if thread[-1].msg_type is MsgType.RESULT:
                break
            await asyncio.sleep(0.01)
        else:
            pytest.fail("watcher did not recover the durable terminal event")
        assert thread[-1].payload["status"] == "done"
        assert thread[-1].payload["done"] == "Found the answer."
        assert rt.scheduler.running == {}
    finally:
        await rt.close()


async def test_turn_that_ends_without_a_terminal_event_releases_the_slot(
    tmp_path: Path, monkeypatch
):
    import asyncio

    import dodaios.society.runtime as runtime_module
    from dodaios.agent_chat.events import make_event

    monkeypatch.setattr(runtime_module, "_WATCH_EVENT_POLL_SECONDS", 0.01)
    svc = FakeTurnService(AgentChatStore(tmp_path / "agent_chat.db"))
    cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
    rt = SocietyRuntime(
        tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
    )
    await rt.ensure_started()
    try:
        await rt.roster.create(name="Scout", provider="openai")
        env = await rt.say(
            from_agent="user", to_agent="scout", text="Find the answer", msg_type=MsgType.ASSIGN
        )
        svc.busy.add("society:scout")  # The turn is running...
        for q in svc.queues["society:scout"]:
            q.put_nowait(make_event("assistant_text", {"turn_id": "turn-1", "text": "Halfway."}))
        await asyncio.sleep(0.08)
        thread = await rt.store.events_for_trace(env.trace_id)
        assert thread[-1].msg_type is MsgType.CLAIM, "a live turn is waited for, however quiet"
        svc.busy.discard("society:scout")  # ...and its task ends without turn_finished.
        for _ in range(50):
            thread = await rt.store.events_for_trace(env.trace_id)
            if thread[-1].msg_type is MsgType.RESULT:
                break
            await asyncio.sleep(0.01)
        else:
            pytest.fail("watcher kept waiting for a turn that no longer runs")
        assert thread[-1].payload["status"] == "blocked"
        assert thread[-1].payload["open"] == [
            "The agent's turn ended without reporting a result."
        ]
        assert rt.scheduler.running == {}
    finally:
        await rt.close()


async def test_durable_read_failure_releases_the_agent_slot(tmp_path: Path, monkeypatch):
    import asyncio

    import dodaios.society.runtime as runtime_module

    monkeypatch.setattr(runtime_module, "_WATCH_EVENT_POLL_SECONDS", 0.01)
    svc = FakeTurnService(AgentChatStore(tmp_path / "agent_chat.db"))
    cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
    rt = SocietyRuntime(
        tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
    )
    await rt.ensure_started()
    try:
        await rt.roster.create(name="Scout", provider="openai")
        env = await rt.say(
            from_agent="user", to_agent="scout", text="Find the answer", msg_type=MsgType.ASSIGN
        )
        svc.queues["society:scout"].clear()

        def unreadable(_session_id, *, after_seq=0):
            raise OSError("chat history unavailable")

        monkeypatch.setattr(svc.store, "list_events", unreadable)
        for _ in range(30):
            thread = await rt.store.events_for_trace(env.trace_id)
            if thread[-1].msg_type is MsgType.RESULT:
                break
            await asyncio.sleep(0.01)
        else:
            pytest.fail("watcher did not release the slot after durable read failure")
        assert thread[-1].payload["status"] == "blocked"
        assert thread[-1].payload["open"] == [
            "Agent result could not be recovered from chat history."
        ]
        assert svc.cancelled_turns == ["turn-1"]
        assert rt.scheduler.running == {}
    finally:
        await rt.close()


async def test_a_picture_that_could_not_be_shown_does_not_block_finished_work(tmp_path: Path):
    """Live 2026-10-02: Scout's finished research came back "blocked" because
    two screenshots it mentioned could not be displayed in its chat."""
    import asyncio

    svc = FakeTurnService(AgentChatStore(tmp_path / "agent_chat.db"))
    cfg = SimpleNamespace(memory=SimpleNamespace(data_dir=str(tmp_path / "data")))
    rt = SocietyRuntime(
        tmp_path, seed_starter_team=False, chat_service=lambda: svc, cfg=lambda: cfg
    )
    await rt.ensure_started()
    try:
        await rt.roster.create(name="Scout", provider="openai")
        env = await rt.say(from_agent="user", to_agent="scout", text="x", msg_type=MsgType.ASSIGN)
        for q in list(svc.queues["society:scout"]):
            for kind, payload in (
                ("assistant_text", {"text": "Research done: three findings."}),
                ("assistant_text", {"text": "![image](/media/a.png)", "media_only": True}),
                ("error", {"message": "Media could not be displayed: a.png",
                           "display_only": True}),
                ("turn_finished", {"status": "ok"}),
            ):
                q.put_nowait({"kind": kind, "payload": {"turn_id": "turn-1", **payload}})
        await asyncio.sleep(0.05)
        result = (await rt.store.events_for_trace(env.trace_id))[-1]
        assert result.msg_type is MsgType.RESULT
        assert result.payload["status"] == "done"
        assert result.payload["done"] == "Research done: three findings."
    finally:
        await rt.close()