Skip to content

armgit / avibe

Public Imported from GitHub
0

Make your computer a home for your AI partner. Avibe is the local-first Agent OS: Vibey, its built-in AI partner, works out of the box, and Claude Code, Codex & OpenCode run unchanged beside it — reach them from your browser, phone, or any chat app.

119 KB
Raw Blame
from __future__ import annotations

import asyncio
import time
from datetime import datetime, timezone
from types import SimpleNamespace
from unittest.mock import AsyncMock, Mock

import aiohttp
import pytest
from aiohttp.client_reqrep import ConnectionKey
from core.agent_input import AgentInputMetadata

from core.services.agent_steering import (
    ActiveSteerTarget,
    SteerOutcome,
    SteerReconcileRequest,
    SteerRequest,
    active_steer_identity,
    reconcile_steer_attempt,
    steer_active_turn,
)
from modules.agents.base import AgentRequest
from modules.agents.claude_agent import ClaudeAgent
from modules.agents.codex.agent import CodexAgent
from modules.agents.opencode.agent import (
    OpenCodeAgent,
    _OpenCodeSteerState,
    _SteeringAwareOpenCodeServer,
)
from modules.agents.opencode.poll_loop import OpenCodePollLoop
from modules.agents.opencode.server import OpenCodePromptRejectedError
from modules.im import MessageContext
from modules.im.base import FileAttachment

from tests.opencode_generation_fakes import serve_opencode_agent
from tests.test_session_delivery_fsm import (
    _context, _seed_session,
    _fsm_schema_template, managers,  # noqa: F401 -- hermetic durable delivery fixtures
)
from tests.codex_generation_support import init_generation_state, install_codex_transport


STEER_TEXT = "补充:**不要改写**\n```python\nprint('λ')\n```"
ATTEMPT_ID = "atm_1234567890abcdef1234567890abcdef"


@pytest.fixture(params=["plain", "human", "harness"])
def native_input(request, monkeypatch):
    now = datetime(2026, 9, 6, 11, 10, tzinfo=timezone.utc)
    monkeypatch.setattr("core.agent_input.datetime", SimpleNamespace(
        now=lambda: SimpleNamespace(astimezone=lambda: now)
    ))
    if request.param == "plain":
        return None, ""
    if request.param == "human":
        return AgentInputMetadata(user_id="incoming", user_name="Sender"), "[Now: 2026-09-06 11:10:00 UTC+00:00]\n[Sender<incoming>]\n"
    return AgentInputMetadata(harness_source="agent run run-1 from #source-session"), (
        "[Harness: agent run run-1 from #source-session]\n[Now: 2026-09-06 11:10:00 UTC+00:00]\n"
    )


def test_steer_outcomes_are_exhaustive() -> None:
    assert {outcome.value for outcome in SteerOutcome} == {
        "accepted",
        "not_active",
        "refused",
        "unknown",
    }


@pytest.fixture
def anyio_backend() -> str:
    return "asyncio"


class _CodexTurnRegistry:
    def __init__(self, base_session_id: str, turn_id: str) -> None:
        self.active_turns = {base_session_id: turn_id}

    def get_active_turn(self, base_session_id: str) -> str | None:
        return self.active_turns.get(base_session_id)


class _CodexSessionManager:
    def __init__(self, base_session_id: str, thread_id: str, cwd: str) -> None:
        self.base_session_id = base_session_id
        self.thread_id = thread_id
        self.cwd = cwd

    def get_thread_id(self, base_session_id: str) -> str | None:
        return self.thread_id if base_session_id == self.base_session_id else None

    def get_cwd(self, base_session_id: str) -> str | None:
        return self.cwd if base_session_id == self.base_session_id else None


class _CodexTransport:
    is_initialized = True

    def __init__(self, *, response=None, error: Exception | None = None) -> None:
        self.response = response or {"turnId": "codex-turn"}
        self.error = error
        self.calls: list[tuple[str, dict]] = []

    async def send_request(self, method: str, params: dict) -> dict:
        self.calls.append((method, params))
        if self.error is not None:
            raise self.error
        return self.response


class _ClaudeClient:
    def __init__(self, *, error: Exception | None = None) -> None:
        self.error = error
        self.queries = [("primary", "runtime-key")]
        self._transport = SimpleNamespace(end_input=AsyncMock())

    async def query(self, text, *, session_id: str) -> None:
        if hasattr(text, "__aiter__"):
            frames = [frame async for frame in text]
            assert len(frames) == 1
            text = frames[0]["message"]["content"]
        self.queries.append((text, session_id))
        if self.error is not None:
            raise self.error


class _ClaudeSessionHandler:
    def __init__(self, runtime_key: str) -> None:
        self.active_sessions = {runtime_key}
        self.activity_touches: list[str] = []

    def touch_session_activity(self, runtime_key: str) -> None:
        self.activity_touches.append(runtime_key)


class _OpenCodeSessionManager:
    def __init__(self, base_session_id: str, native_session_id: str, cwd: str) -> None:
        self.base_session_id = base_session_id
        self.request_session = (native_session_id, cwd, "session-key")
        self.session_lock = asyncio.Lock()

    def get_request_session(self, base_session_id: str):
        return self.request_session if base_session_id == self.base_session_id else None

    def get_session_lock(self, _base_session_id: str):
        return self.session_lock


class _OpenCodeServer:
    def __init__(
        self,
        *,
        error: Exception | None = None,
        list_error: Exception | None = None,
        messages: list[dict] | None = None,
        status: dict | None = None,
        status_error: Exception | None = None,
        status_responses: list[dict | None] | None = None,
        prompt_started: asyncio.Event | None = None,
        release_prompt: asyncio.Event | None = None,
    ) -> None:
        self.error = error
        self.list_error = list_error
        self.messages = messages or [
            {"info": {"id": "primary-user", "role": "user"}, "parts": []},
        ]
        self.status = status or {"type": "busy"}
        self.status_error = status_error
        self.status_responses = list(status_responses or [])
        self.prompt_started = prompt_started
        self.release_prompt = release_prompt
        self.list_calls = 0
        self.prompt_calls: list[dict] = []
        self.abort_calls: list[tuple] = []
        self.inactive_runs: list[str] = []

    async def prompt_async(self, **kwargs) -> None:
        self.prompt_calls.append(kwargs)
        if self.prompt_started is not None:
            self.prompt_started.set()
        if self.release_prompt is not None:
            await self.release_prompt.wait()
        if self.error is not None:
            raise self.error
        attempt_id = kwargs.get("attempt_id")
        part = {"type": "text", "text": kwargs["text"]}
        if attempt_id:
            part["id"] = f"prt_{attempt_id.removeprefix('atm_')}"
        self.messages.append(
            {
                "info": {
                    "id": f"steer-user-{len(self.prompt_calls)}",
                    "role": "user",
                },
                "parts": [part],
            }
        )

    async def list_messages(self, session_id: str, directory: str) -> list[dict]:
        self.list_calls += 1
        if self.list_error is not None:
            raise self.list_error
        return list(self.messages)

    async def get_session_status(self, session_id: str, directory: str) -> dict | None:
        if self.status_error is not None:
            raise self.status_error
        if self.status_responses:
            return self.status_responses.pop(0)
        return self.status

    async def get_message(self, session_id: str, message_id: str, directory: str) -> dict:
        return next(
            message
            for message in self.messages
            if message.get("info", {}).get("id") == message_id
        )

    async def abort_session(self, *args) -> bool:
        self.abort_calls.append(args)
        return True

    async def mark_run_inactive(self, session_id: str) -> None:
        self.inactive_runs.append(session_id)


def _primary_request(*, session_id: str = "avibe-session", backend: str) -> AgentRequest:
    context = MessageContext(
        user_id="user",
        channel_id=session_id,
        platform="avibe",
        platform_specific={
            "agent_session_target": {"id": session_id, "agent_backend": backend},
            "agent_session_id": session_id,
            "workbench_session_id": session_id,
            "turn_token": "logical-turn",
            "agent_runtime_turn_token": "runtime-token",
        },
    )
    return AgentRequest(
        context=context,
        message="primary",
        user_message="primary",
        working_path="/tmp/steering-test",
        base_session_id=session_id,
        composite_session_id="runtime-key",
        session_key="scope-key",
        vibe_agent_model="fixture-provider/fixture-model" if backend == "opencode" else f"{backend}-fixture",
    )


def _controller_with_active_gate(agent, primary: AgentRequest, gate_task: asyncio.Task):
    gate = SimpleNamespace(
        backend=agent.name,
        token="runtime-token",
        runtime_started=True,
        task=gate_task,
        request=primary,
        context=primary.context,
        agent=agent,
    )
    service = SimpleNamespace(agents={agent.name: agent}, _turn_gates={"runtime-key": gate})
    controller = SimpleNamespace(agent_service=service)
    agent.controller = controller
    return controller


def _steer_request(native_turn_id: str, *, logical_turn_id: str = "logical-turn", input_metadata=None) -> SteerRequest:
    return SteerRequest(
        target_session_id="avibe-session",
        expected_logical_turn_id=logical_turn_id,
        expected_native_turn_id=native_turn_id,
        text=STEER_TEXT,
        input_metadata=input_metadata,
    )


async def _held_task() -> asyncio.Task:
    event = asyncio.Event()
    return asyncio.create_task(event.wait())


async def _cancel_tasks(*tasks: asyncio.Task) -> None:
    for task in tasks:
        task.cancel()
    await asyncio.gather(*tasks, return_exceptions=True)


@pytest.mark.anyio
@pytest.mark.parametrize("backend", ["codex", "claude", "opencode"])
@pytest.mark.parametrize("text", ["", STEER_TEXT])
async def test_native_steer_uses_normal_attachment_input_without_replacing_primary(backend, text, tmp_path):
    """QUEUE-IMAGE-002: attachment delivery shares each adapter's start format."""
    image = tmp_path / "队列图片.png"
    image.write_bytes(b"test image")
    document = tmp_path / "说明.txt"
    document.write_text("附件说明", encoding="utf-8")
    files = (
        FileAttachment(name=image.name, local_path=str(image), mimetype="image/png"),
        FileAttachment(name=document.name, local_path=str(document), mimetype="text/plain"),
    )
    primary = _primary_request(backend=backend)
    gate_task = await _held_task()
    receiver_task = await _held_task()
    transport = _CodexTransport()
    client = _ClaudeClient()
    server = _OpenCodeServer()
    if backend == "codex":
        agent = init_generation_state(object.__new__(CodexAgent))
        agent._turn_registry = _CodexTurnRegistry(primary.base_session_id, "codex-turn")
        agent._session_mgr = _CodexSessionManager(primary.base_session_id, "codex-thread", primary.working_path)
        install_codex_transport(agent, primary.working_path, transport, sessions={primary.base_session_id: "codex-thread"}, last_activity=0.0)
    elif backend == "claude":
        agent = object.__new__(ClaudeAgent)
        agent.claude_sessions = {"runtime-key": client}
        agent.receiver_tasks = {"runtime-key": receiver_task}
        agent.session_handler = _ClaudeSessionHandler("runtime-key")
        agent._pending_requests = {"runtime-key": [primary]}
    else:
        agent = _opencode_agent(primary, gate_task, server)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    try:
        identity = active_steer_identity(controller, backend, "avibe-session")
        assert identity is not None
        request = SteerRequest(
            target_session_id="avibe-session",
            expected_logical_turn_id=identity[0],
            expected_native_turn_id=identity[1],
            text=text,
            files=files,
        )
        receipt = await steer_active_turn(controller, backend, request)
        assert receipt.outcome is SteerOutcome.ACCEPTED
        if backend == "codex":
            assert transport.calls == [("turn/steer", {
                "threadId": "codex-thread",
                "expectedTurnId": identity[1],
                "input": [
                    {"type": "text", "text": f"{text}\n\n[User Attachments]\n- File: {document} (text/plain)"},
                    {"type": "localImage", "path": str(image)},
                ],
            })]
        else:
            prompt = (
                f"{text}\n[User Attachments]\n"
                f"- Image: {image} (image/png)\n- File: {document} (text/plain)"
            )
            if not text:
                prompt = prompt.lstrip()
            if backend == "claude":
                assert client.queries[-1] == (prompt, "runtime-key")
                assert agent._pending_requests["runtime-key"] == [primary]
                assert agent.receiver_tasks["runtime-key"] is receiver_task
                client._transport.end_input.assert_not_awaited()
            else:
                assert server.prompt_calls[0]["text"] == prompt
                assert agent._steering_states[primary.base_session_id].awaiting_user_text == prompt
                assert server.abort_calls == []
        assert request.text == text
        assert primary.message == "primary" and primary.files is None
        assert not gate_task.done() and not receiver_task.done()
    finally:
        await _cancel_tasks(gate_task, receiver_task)


@pytest.mark.anyio
async def test_codex_steers_expected_active_turn_without_starting_another_turn(native_input) -> None:
    metadata, prefix = native_input
    primary = _primary_request(backend="codex")
    gate_task = await _held_task()
    transport = _CodexTransport()
    agent = init_generation_state(object.__new__(CodexAgent))
    agent.config = SimpleNamespace(include_time_info=True, include_user_info=True)
    agent._turn_registry = _CodexTurnRegistry(primary.base_session_id, "codex-turn")
    agent._session_mgr = _CodexSessionManager(primary.base_session_id, "codex-thread", primary.working_path)
    install_codex_transport(agent, primary.working_path, transport, sessions={primary.base_session_id: "codex-thread"}, last_activity=0.0)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    try:
        identity = active_steer_identity(controller, "codex", "avibe-session")
        assert identity == ("logical-turn", "codex-turn")

        request = _steer_request(identity[1], input_metadata=metadata)
        receipt = await steer_active_turn(controller, "codex", request)
        assert request.text == STEER_TEXT
        assert primary.message == "primary"

        assert receipt.outcome is SteerOutcome.ACCEPTED
        assert transport.calls == [
            (
                "turn/steer",
                {
                    "threadId": "codex-thread",
                    "expectedTurnId": "codex-turn",
                    "input": [{"type": "text", "text": prefix + STEER_TEXT}],
                },
            )
        ]
        assert len(agent._turn_registry.active_turns) == 1
        assert agent.transport_for_session(primary.base_session_id) is transport
        assert not gate_task.done()
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_codex_steer_reconciliation_uses_persisted_client_message_id() -> None:
    primary = _primary_request(backend="codex")
    gate_task = await _held_task()
    attempt_id = ATTEMPT_ID

    class _ReconcileTransport(_CodexTransport):
        async def send_request(self, method: str, params: dict) -> dict:
            self.calls.append((method, params))
            if method == "thread/read":
                return {
                    "thread": {
                        "turns": [{
                            "id": "codex-turn",
                            "status": "inProgress",
                            "items": [{
                                "type": "userMessage",
                                "id": "user-message-1",
                                "clientId": attempt_id,
                                "content": [{"type": "text", "text": STEER_TEXT}],
                            }],
                        }],
                    },
                }
            return {"turnId": "codex-turn"}

    transport = _ReconcileTransport()
    agent = init_generation_state(object.__new__(CodexAgent))
    agent._turn_registry = _CodexTurnRegistry(primary.base_session_id, "codex-turn")
    agent._session_mgr = _CodexSessionManager(
        primary.base_session_id,
        "codex-thread",
        primary.working_path,
    )
    install_codex_transport(agent, primary.working_path, transport, sessions={primary.base_session_id: "codex-thread"}, last_activity=0.0)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    target = ActiveSteerTarget(
        runtime_key="runtime-key",
        logical_turn_id="logical-turn",
        context=primary.context,
        agent_request=primary,
        agent=agent,
    )
    try:
        receipt = await steer_active_turn(
            controller,
            "codex",
            SteerRequest(
                target_session_id="avibe-session",
                expected_logical_turn_id="logical-turn",
                expected_native_turn_id="codex-turn",
                text=STEER_TEXT,
                attempt_id=attempt_id,
            ),
        )
        assert receipt.outcome is SteerOutcome.ACCEPTED
        assert transport.calls[0] == (
            "turn/steer",
            {
                "threadId": "codex-thread",
                "expectedTurnId": "codex-turn",
                "input": [{"type": "text", "text": STEER_TEXT}],
                "clientUserMessageId": attempt_id,
            },
        )

        reconciled = await agent.reconcile_steer_attempt(
            SteerReconcileRequest(
                target_session_id="avibe-session",
                expected_logical_turn_id="logical-turn",
                expected_native_turn_id="codex-turn",
                attempt_id=attempt_id,
            ),
            target,
        )
        assert reconciled.outcome is SteerOutcome.ACCEPTED
        assert reconciled.reason == "native_attempt_client_id_found"
        assert [method for method, _params in transport.calls] == [
            "turn/steer",
            "thread/read",
        ]
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_codex_steer_reconciliation_survives_completed_native_turn() -> None:
    primary = _primary_request(backend="codex")
    gate_task = await _held_task()
    attempt_id = ATTEMPT_ID

    class _CompletedTurnTransport(_CodexTransport):
        async def send_request(self, method: str, params: dict) -> dict:
            self.calls.append((method, params))
            if method == "turn/steer":
                self.is_initialized = False
                raise TimeoutError("steer response lost after native write")
            return {
                "thread": {
                    "turns": [{
                        "id": "codex-turn",
                        "status": "completed",
                        "items": [{
                            "type": "userMessage",
                            "clientId": attempt_id,
                        }],
                    }],
                },
            }

    transport = _CompletedTurnTransport()
    agent = init_generation_state(object.__new__(CodexAgent))
    agent._turn_registry = _CodexTurnRegistry(primary.base_session_id, "codex-turn")
    agent._session_mgr = _CodexSessionManager(
        primary.base_session_id,
        "codex-thread",
        primary.working_path,
    )
    install_codex_transport(agent, primary.working_path, transport, sessions={primary.base_session_id: "codex-thread"}, last_activity=0.0)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    request = SteerRequest(
        target_session_id="avibe-session",
        expected_logical_turn_id="logical-turn",
        expected_native_turn_id="codex-turn",
        text=STEER_TEXT,
        attempt_id=attempt_id,
    )
    try:
        receipt = await steer_active_turn(controller, "codex", request)
        assert receipt.outcome is SteerOutcome.UNKNOWN

        agent._turn_registry.active_turns.clear()
        controller.agent_service._turn_gates.clear()
        reconciled = await reconcile_steer_attempt(
            controller,
            "codex",
            SteerReconcileRequest(
                target_session_id="avibe-session",
                expected_logical_turn_id="logical-turn",
                expected_native_turn_id="codex-turn",
                attempt_id=attempt_id,
            ),
        )

        assert reconciled.outcome is SteerOutcome.ACCEPTED
        assert reconciled.reason == "native_attempt_client_id_found"
        assert [method for method, _params in transport.calls] == [
            "turn/steer",
            "thread/read",
        ]
        assert not agent._steer_reconciliation_targets
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_codex_steer_reconciliation_uses_durable_binding_after_restart(monkeypatch) -> None:
    primary = _primary_request(backend="codex")
    attempt_id = ATTEMPT_ID

    class _CompletedTransport(_CodexTransport):
        async def send_request(self, method: str, params: dict) -> dict:
            self.calls.append((method, params))
            return {
                "thread": {
                    "turns": [{
                        "id": "codex-turn",
                        "status": "completed",
                        "items": [{"type": "userMessage", "clientId": attempt_id}],
                    }],
                },
            }

    monkeypatch.setattr(
        "core.scheduled_tasks.resolve_session_id_target",
        lambda _session_id: SimpleNamespace(
            agent_backend="codex",
            native_session_id="codex-thread",
            workdir=primary.working_path,
        ),
    )
    transport = _CompletedTransport()
    agent = init_generation_state(object.__new__(CodexAgent))
    agent._turn_registry = _CodexTurnRegistry(primary.base_session_id, "different-turn")
    agent._session_mgr = _CodexSessionManager(
        primary.base_session_id,
        "stale-thread",
        primary.working_path,
    )
    install_codex_transport(agent, primary.working_path, transport, sessions={primary.base_session_id: "codex-thread"}, last_activity=0.0)
    agent._steer_reconciliation_targets = {}

    request = SteerReconcileRequest(
        target_session_id=primary.base_session_id,
        expected_logical_turn_id="logical-turn",
        expected_native_turn_id="codex-turn",
        attempt_id=attempt_id,
    )
    target = agent.reconciliation_steer_target(request)
    assert target is not None
    assert target.agent_request is None

    reconciled = await agent.reconcile_steer_attempt(request, target)

    assert reconciled.outcome is SteerOutcome.ACCEPTED
    assert reconciled.reason == "native_attempt_client_id_found"
    assert transport.calls == [("thread/read", {"threadId": "codex-thread", "includeTurns": True})]


@pytest.mark.anyio
async def test_codex_steer_reconciliation_cache_keeps_only_unknown_receipts() -> None:
    primary = _primary_request(backend="codex")

    async def run(error: Exception | None, response: dict | None) -> dict:
        gate_task = await _held_task()
        transport = _CodexTransport(error=error, response=response)
        agent = init_generation_state(object.__new__(CodexAgent))
        agent._turn_registry = _CodexTurnRegistry(primary.base_session_id, "codex-turn")
        agent._session_mgr = _CodexSessionManager(
            primary.base_session_id,
            "codex-thread",
            primary.working_path,
        )
        install_codex_transport(agent, primary.working_path, transport, sessions={primary.base_session_id: "codex-thread"}, last_activity=0.0)
        controller = _controller_with_active_gate(agent, primary, gate_task)
        try:
            await steer_active_turn(
                controller,
                "codex",
                SteerRequest(
                    target_session_id=primary.base_session_id,
                    expected_logical_turn_id="logical-turn",
                    expected_native_turn_id="codex-turn",
                    text=STEER_TEXT,
                    attempt_id=ATTEMPT_ID,
                ),
            )
            return dict(agent._steer_reconciliation_targets)
        finally:
            await _cancel_tasks(gate_task)

    accepted = await run(None, {"turnId": "codex-turn"})
    refused = await run(RuntimeError("activeTurnNotSteerable"), None)
    unknown = await run(TimeoutError("turn/steer timed out"), None)

    assert accepted == {}
    assert refused == {}
    assert set(unknown) == {ATTEMPT_ID}


@pytest.mark.anyio
async def test_codex_start_renders_now_after_runtime_prompt_preparation(monkeypatch):
    """Scenario: MESSAGE-DELIVERY-318."""
    current = datetime(2026, 9, 6, 11, 0, tzinfo=timezone.utc)
    monkeypatch.setattr("core.agent_input.datetime", SimpleNamespace(
        now=lambda: SimpleNamespace(astimezone=lambda: current)
    ))
    request = _primary_request(backend="codex")
    request.input_metadata = AgentInputMetadata(user_id="sender", user_name="Sender")
    agent = init_generation_state(object.__new__(CodexAgent))
    agent.config = SimpleNamespace(include_time_info=True, include_user_info=True)
    agent.controller = SimpleNamespace()
    agent._prompt_state_agent_session_id = lambda _request: None
    agent._resolve_codex_agent_settings = lambda _request: (None, None, None, None)
    agent._read_persisted_prompt_strategy_marker = Mock(return_value=None)
    agent._write_caller_env_script = Mock()
    agent._turn_registry = SimpleNamespace(
        begin_turn_start=Mock(),
        finalize_turn_start_response=Mock(return_value=SimpleNamespace()),
    )

    async def prepare_runtime(*_args, **_kwargs):
        nonlocal current
        await asyncio.sleep(0)
        current = datetime(2026, 9, 6, 11, 10, tzinfo=timezone.utc)

    agent._inject_thread_developer_instructions = AsyncMock(side_effect=prepare_runtime)
    transport = SimpleNamespace(send_request=AsyncMock(return_value={"turn": {"id": "native-turn"}}))
    await agent._start_turn(transport, request, "native-thread", developer_instructions="runtime instructions")
    agent._inject_thread_developer_instructions.assert_awaited_once()
    params = transport.send_request.await_args.args[1]
    assert params["input"] == [{"type": "text", "text": "[Now: 2026-09-06 11:10:00 UTC+00:00]\n[Sender<sender>]\nprimary"}]
    assert request.message == request.user_message == "primary"


@pytest.mark.anyio
async def test_shared_gate_remains_steerable_after_dispatch_task_returns() -> None:
    primary = _primary_request(backend="codex")
    completed_dispatch = asyncio.create_task(asyncio.sleep(0))
    await completed_dispatch
    transport = _CodexTransport()
    agent = init_generation_state(object.__new__(CodexAgent))
    agent._turn_registry = _CodexTurnRegistry(primary.base_session_id, "codex-turn")
    agent._session_mgr = _CodexSessionManager(primary.base_session_id, "codex-thread", primary.working_path)
    install_codex_transport(agent, primary.working_path, transport, sessions={primary.base_session_id: "codex-thread"}, last_activity=0.0)
    controller = _controller_with_active_gate(agent, primary, completed_dispatch)

    identity = active_steer_identity(controller, "codex", "avibe-session")
    receipt = await steer_active_turn(controller, "codex", _steer_request("codex-turn"))

    assert identity == ("logical-turn", "codex-turn")
    assert receipt.outcome is SteerOutcome.ACCEPTED
    assert [method for method, _params in transport.calls] == ["turn/steer"]


@pytest.mark.anyio
@pytest.mark.parametrize(
    ("error", "expected"),
    [
        (RuntimeError("Codex RPC error: activeTurnNotSteerable"), SteerOutcome.REFUSED),
        (RuntimeError("Codex RPC error: no active turn to steer"), SteerOutcome.NOT_ACTIVE),
        (ConnectionError("Codex app-server transport is not available"), SteerOutcome.REFUSED),
        (TimeoutError("turn/steer timed out"), SteerOutcome.UNKNOWN),
        (ConnectionError("Codex app-server stdout closed"), SteerOutcome.UNKNOWN),
    ],
)
async def test_codex_maps_native_failures_without_turn_start(error: Exception, expected: SteerOutcome) -> None:
    primary = _primary_request(backend="codex")
    gate_task = await _held_task()
    transport = _CodexTransport(error=error)
    agent = init_generation_state(object.__new__(CodexAgent))
    agent._turn_registry = _CodexTurnRegistry(primary.base_session_id, "codex-turn")
    agent._session_mgr = _CodexSessionManager(primary.base_session_id, "codex-thread", primary.working_path)
    agent_generation = install_codex_transport(agent, primary.working_path, transport, sessions={primary.base_session_id: "codex-thread"}, last_activity=0.0)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    try:
        receipt = await steer_active_turn(controller, "codex", _steer_request("codex-turn"))
        assert receipt.outcome is expected
        assert [method for method, _params in transport.calls] == ["turn/steer"]
        if expected is SteerOutcome.UNKNOWN:
            assert agent_generation.runtime.last_activity > 0.0
        else:
            assert agent_generation.runtime.last_activity == 0.0
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_codex_rejects_stale_native_turn_and_unavailable_runtime() -> None:
    primary = _primary_request(backend="codex")
    gate_task = await _held_task()
    transport = _CodexTransport()
    agent = init_generation_state(object.__new__(CodexAgent))
    agent._turn_registry = _CodexTurnRegistry(primary.base_session_id, "codex-turn")
    agent._session_mgr = _CodexSessionManager(primary.base_session_id, "codex-thread", primary.working_path)
    install_codex_transport(agent, primary.working_path, transport, sessions={primary.base_session_id: "codex-thread"}, last_activity=0.0)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    try:
        stale = await steer_active_turn(controller, "codex", _steer_request("stale-turn"))
        assert stale.outcome is SteerOutcome.NOT_ACTIVE
        assert transport.calls == []

        agent._session_generations.clear()
        unavailable = await steer_active_turn(controller, "codex", _steer_request("codex-turn"))
        assert unavailable.outcome is SteerOutcome.REFUSED
        assert unavailable.reason == "runtime_unavailable"
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_claude_uses_one_client_receiver_and_primary_result_owner(native_input) -> None:
    metadata, prefix = native_input
    primary = _primary_request(backend="claude")
    gate_task = await _held_task()
    receiver_task = await _held_task()
    client = _ClaudeClient()
    agent = object.__new__(ClaudeAgent)
    agent.config = SimpleNamespace(include_time_info=True, include_user_info=True)
    agent.claude_sessions = {"runtime-key": client}
    agent.receiver_tasks = {"runtime-key": receiver_task}
    agent.session_handler = _ClaudeSessionHandler("runtime-key")
    primary_requests = [primary]
    agent._pending_requests = {"runtime-key": primary_requests}
    controller = _controller_with_active_gate(agent, primary, gate_task)
    try:
        identity = active_steer_identity(controller, "claude", "avibe-session")
        assert identity is not None
        receiver_generation = identity[1]

        request = _steer_request(receiver_generation, input_metadata=metadata)
        receipt = await steer_active_turn(controller, "claude", request)
        assert request.text == STEER_TEXT

        assert receipt.outcome is SteerOutcome.ACCEPTED
        assert client.queries == [("primary", "runtime-key"), (prefix + STEER_TEXT, "runtime-key")]
        assert agent.receiver_tasks == {"runtime-key": receiver_task}
        assert agent._pending_requests["runtime-key"] is primary_requests
        assert agent._pending_requests["runtime-key"] == [primary]
        client._transport.end_input.assert_not_awaited()
        # Steering admission is not execution progress and must not refresh the
        # stuck-runtime clock before assistant/tool output arrives.
        assert agent.session_handler.activity_touches == []
        assert not gate_task.done()
        assert not receiver_task.done()
    finally:
        await _cancel_tasks(gate_task, receiver_task)


@pytest.mark.anyio
@pytest.mark.parametrize(
    ("error", "expected"),
    [
        (RuntimeError("Not connected. Call connect() first."), SteerOutcome.REFUSED),
        (TimeoutError("write acknowledgement timed out"), SteerOutcome.UNKNOWN),
        (ConnectionError("Failed to write to process stdin"), SteerOutcome.UNKNOWN),
        (ValueError("unclassified SDK transport failure"), SteerOutcome.UNKNOWN),
    ],
)
async def test_claude_maps_query_failures_at_the_write_boundary(
    error: Exception,
    expected: SteerOutcome,
) -> None:
    primary = _primary_request(backend="claude")
    gate_task = await _held_task()
    receiver_task = await _held_task()
    client = _ClaudeClient(error=error)
    agent = object.__new__(ClaudeAgent)
    agent.claude_sessions = {"runtime-key": client}
    agent.receiver_tasks = {"runtime-key": receiver_task}
    agent.session_handler = _ClaudeSessionHandler("runtime-key")
    agent._pending_requests = {"runtime-key": [primary]}
    controller = _controller_with_active_gate(agent, primary, gate_task)
    try:
        identity = active_steer_identity(controller, "claude", "avibe-session")
        assert identity is not None
        receipt = await steer_active_turn(controller, "claude", _steer_request(identity[1]))
        assert receipt.outcome is expected
        assert agent._pending_requests["runtime-key"] == [primary]
        assert agent.receiver_tasks["runtime-key"] is receiver_task
        assert agent.session_handler.activity_touches == []
    finally:
        await _cancel_tasks(gate_task, receiver_task)


@pytest.mark.anyio
async def test_claude_refuses_steering_without_ambiguous_input_reconciliation() -> None:
    primary = _primary_request(backend="claude")
    gate_task = await _held_task()
    receiver_task = await _held_task()
    client = _ClaudeClient()
    client._transport = None
    agent = object.__new__(ClaudeAgent)
    agent.claude_sessions = {"runtime-key": client}
    agent.receiver_tasks = {"runtime-key": receiver_task}
    agent.session_handler = _ClaudeSessionHandler("runtime-key")
    agent._pending_requests = {"runtime-key": [primary]}
    controller = _controller_with_active_gate(agent, primary, gate_task)
    try:
        identity = active_steer_identity(controller, "claude", "avibe-session")
        assert identity is not None

        receipt = await steer_active_turn(controller, "claude", _steer_request(identity[1]))

        assert receipt.outcome is SteerOutcome.REFUSED
        assert receipt.reason == "native_input_reconciliation_unsupported"
        assert client.queries == [("primary", "runtime-key")]
    finally:
        await _cancel_tasks(gate_task, receiver_task)


@pytest.mark.anyio
async def test_claude_preserves_receiver_when_ambiguous_input_half_close_fails() -> None:
    primary = _primary_request(backend="claude")
    gate_task = await _held_task()
    receiver_task = await _held_task()
    client = _ClaudeClient(error=TimeoutError("write acknowledgement timed out"))
    client._transport.end_input = AsyncMock(side_effect=RuntimeError("stdin close failed"))
    client.disconnect = AsyncMock()
    agent = object.__new__(ClaudeAgent)
    agent.claude_sessions = {"runtime-key": client}
    agent.receiver_tasks = {"runtime-key": receiver_task}
    agent.session_handler = _ClaudeSessionHandler("runtime-key")
    agent._pending_requests = {"runtime-key": [primary]}
    controller = _controller_with_active_gate(agent, primary, gate_task)
    try:
        identity = active_steer_identity(controller, "claude", "avibe-session")
        assert identity is not None

        receipt = await steer_active_turn(controller, "claude", _steer_request(identity[1]))

        assert receipt.outcome is SteerOutcome.UNKNOWN
        client._transport.end_input.assert_awaited_once_with()
        client.disconnect.assert_not_awaited()
        assert not receiver_task.done()
        assert agent.steering_native_turn_id(
            ActiveSteerTarget(
                runtime_key="runtime-key",
                logical_turn_id="logical-turn",
                context=primary.context,
                agent_request=primary,
                agent=agent,
            )
        ) is None
    finally:
        await _cancel_tasks(gate_task, receiver_task)


@pytest.mark.anyio
async def test_claude_accepts_stable_steer_without_closing_native_input() -> None:
    primary = _primary_request(backend="claude")
    gate_task = await _held_task()
    receiver_task = await _held_task()
    client = _ClaudeClient()
    client._transport.end_input = AsyncMock(side_effect=RuntimeError("stdin close failed"))
    agent = object.__new__(ClaudeAgent)
    agent.claude_sessions = {"runtime-key": client}
    agent.receiver_tasks = {"runtime-key": receiver_task}
    agent.session_handler = _ClaudeSessionHandler("runtime-key")
    agent._pending_requests = {"runtime-key": [primary]}
    controller = _controller_with_active_gate(agent, primary, gate_task)
    try:
        identity = active_steer_identity(controller, "claude", "avibe-session")
        assert identity is not None

        receipt = await steer_active_turn(
            controller,
            "claude",
            _steer_request(identity[1]),
        )

        assert receipt.outcome is SteerOutcome.ACCEPTED
        assert client.queries[-1] == (STEER_TEXT, "runtime-key")
        client._transport.end_input.assert_not_awaited()
        assert not receiver_task.done()
    finally:
        await _cancel_tasks(gate_task, receiver_task)


@pytest.mark.anyio
async def test_shared_boundary_finishes_native_reconciliation_before_propagating_cancel() -> None:
    primary = _primary_request(backend="claude")
    gate_task = await _held_task()
    receiver_task = await _held_task()
    query_started = asyncio.Event()
    release_query = asyncio.Event()

    class _BlockingClaudeClient(_ClaudeClient):
        async def query(self, text, *, session_id: str) -> None:
            if hasattr(text, "__aiter__"):
                frames = [frame async for frame in text]
                assert len(frames) == 1
                text = frames[0]["message"]["content"]
            self.queries.append((text, session_id))
            query_started.set()
            await release_query.wait()

    client = _BlockingClaudeClient()
    agent = object.__new__(ClaudeAgent)
    agent.claude_sessions = {"runtime-key": client}
    agent.receiver_tasks = {"runtime-key": receiver_task}
    agent.session_handler = _ClaudeSessionHandler("runtime-key")
    agent._pending_requests = {"runtime-key": [primary]}
    controller = _controller_with_active_gate(agent, primary, gate_task)
    try:
        identity = active_steer_identity(controller, "claude", "avibe-session")
        assert identity is not None
        caller = asyncio.create_task(
            steer_active_turn(controller, "claude", _steer_request(identity[1]))
        )
        await query_started.wait()

        caller.cancel()
        await asyncio.sleep(0)
        assert not caller.done()

        release_query.set()
        with pytest.raises(asyncio.CancelledError):
            await caller

        assert agent._steering_generation("runtime-key") == 1
        assert agent._pending_steering_input_state("runtime-key") == "accepted"
        assert agent.claude_sessions["runtime-key"] is client
        assert agent.receiver_tasks["runtime-key"] is receiver_task
        assert agent._pending_requests["runtime-key"] == [primary]
        assert not receiver_task.done()
    finally:
        await _cancel_tasks(gate_task, receiver_task)


@pytest.mark.anyio
async def test_claude_rejects_stale_receiver_generation_and_unavailable_runtime() -> None:
    primary = _primary_request(backend="claude")
    gate_task = await _held_task()
    receiver_task = await _held_task()
    client = _ClaudeClient()
    agent = object.__new__(ClaudeAgent)
    agent.claude_sessions = {"runtime-key": client}
    agent.receiver_tasks = {"runtime-key": receiver_task}
    agent.session_handler = _ClaudeSessionHandler("runtime-key")
    agent._pending_requests = {"runtime-key": [primary]}
    controller = _controller_with_active_gate(agent, primary, gate_task)
    try:
        stale = await steer_active_turn(controller, "claude", _steer_request("stale-receiver"))
        assert stale.outcome is SteerOutcome.NOT_ACTIVE
        assert client.queries == [("primary", "runtime-key")]

        agent.session_handler.active_sessions.clear()
        unavailable = await steer_active_turn(controller, "claude", _steer_request("stale-receiver"))
        assert unavailable.outcome is SteerOutcome.REFUSED
        assert unavailable.reason == "runtime_unavailable"
    finally:
        await _cancel_tasks(gate_task, receiver_task)


def _opencode_agent(primary: AgentRequest, task: asyncio.Task, server: _OpenCodeServer | None):
    agent = object.__new__(OpenCodeAgent)
    agent._active_requests = {primary.base_session_id: task}
    agent._session_manager = _OpenCodeSessionManager(
        primary.base_session_id,
        "opencode-session",
        primary.working_path,
    )
    serve_opencode_agent(agent, server)
    if server is not None:
        agent._session_generations[primary.base_session_id] = server
    agent._user_stopped_sessions = set()
    agent._steering_states = {
        primary.base_session_id: _OpenCodeSteerState(
            task=task,
            base_session_id=primary.base_session_id,
            target_session_id="avibe-session",
            logical_turn_id="logical-turn",
            native_session_id="opencode-session",
            directory=primary.working_path,
            agent="build",
            model={"providerID": "openai", "modelID": "gpt-5"},
            reasoning_effort="high",
            system="primary system prompt",
            baseline_message_ids=set(),
            generation=server,
        )
    }
    return agent


@pytest.mark.anyio
async def test_opencode_steers_existing_runner_without_abort_or_new_turn(native_input) -> None:
    metadata, prefix = native_input
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer()
    agent = _opencode_agent(primary, gate_task, server)
    agent.config = SimpleNamespace(include_time_info=True, include_user_info=True)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    try:
        identity = active_steer_identity(controller, "opencode", "avibe-session")
        assert identity is not None

        request = _steer_request(identity[1], input_metadata=metadata)
        receipt = await steer_active_turn(controller, "opencode", request)
        assert request.text == STEER_TEXT

        assert receipt.outcome is SteerOutcome.ACCEPTED
        state = agent._steering_states[primary.base_session_id]
        assert state.awaiting_user_text == prefix + STEER_TEXT
        assert state.awaiting_prompt_accepted is True
        assert state.awaiting_prompt_activity_deadline is not None
        assert state.awaiting_prompt_activity_deadline > time.monotonic()
        assert state.awaiting_active_status_observed is False
        assert server.prompt_calls == [
            {
                "session_id": "opencode-session",
                "directory": primary.working_path,
                "text": prefix + STEER_TEXT,
                "agent": "build",
                "model": {"providerID": "openai", "modelID": "gpt-5"},
                "reasoning_effort": "high",
                "system": "primary system prompt",
                "tools": {"question": False, "skill": False},
            }
        ]
        assert server.abort_calls == []
        assert len(agent._active_requests) == 1
        assert not gate_task.done()
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_opencode_keeps_reconciliation_armed_after_post_write_idle() -> None:
    """HFR-434: a transient post-write idle stays reconcilable, not refused."""
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer(
        status_responses=[{"type": "busy"}, {"type": "idle"}],
    )
    agent = _opencode_agent(primary, gate_task, server)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    state = agent._steering_states[primary.base_session_id]
    try:
        identity = active_steer_identity(controller, "opencode", "avibe-session")
        assert identity is not None

        receipt = await steer_active_turn(
            controller,
            "opencode",
            _steer_request(identity[1]),
        )

        assert receipt.outcome is SteerOutcome.UNKNOWN
        assert receipt.reason == "native_turn_start_pending"
        assert state.awaiting_user_text == STEER_TEXT
        assert state.awaiting_after_message_ids == {"primary-user"}
        assert state.awaiting_prompt_accepted is True
        assert state.awaiting_prompt_activity_deadline is not None
        assert server.abort_calls == []
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_message_delivery_021_opencode_preserves_native_order_and_recovers_exact_part() -> None:
    """Scenario: MESSAGE-DELIVERY-021."""
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer(
        messages=[
            {
                "info": {"id": "primary-user", "role": "user"},
                "parts": [{"type": "text", "text": "primary"}],
            },
            {
                "info": {
                    "id": "primary-assistant",
                    "role": "assistant",
                    "parentID": "primary-user",
                    "time": {"completed": 1},
                    "finish": "stop",
                },
                "parts": [{"type": "text", "text": "primary result"}],
            },
        ]
    )
    agent = _opencode_agent(primary, gate_task, server)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    attempt_id = ATTEMPT_ID
    try:
        identity = active_steer_identity(controller, "opencode", "avibe-session")
        assert identity is not None
        receipt = await steer_active_turn(
            controller,
            "opencode",
            SteerRequest(
                target_session_id="avibe-session",
                expected_logical_turn_id=identity[0],
                expected_native_turn_id=identity[1],
                text=STEER_TEXT,
                attempt_id=attempt_id,
            ),
        )
        assert receipt.outcome is SteerOutcome.ACCEPTED
        assert server.prompt_calls[0]["attempt_id"] == ATTEMPT_ID
        assert "message_id" not in server.prompt_calls[0]
        inserted_user = server.messages[-1]
        server.messages.append(
            {
                "info": {
                    "id": "steer-assistant-1",
                    "role": "assistant",
                    "parentID": inserted_user["info"]["id"],
                    "time": {"completed": 2},
                    "finish": "stop",
                },
                "parts": [{"type": "text", "text": "steer result"}],
            }
        )

        assert [message["info"]["id"] for message in server.messages] == [
            "primary-user",
            "primary-assistant",
            "steer-user-1",
            "steer-assistant-1",
        ]
        assert inserted_user["parts"] == [
            {
                "type": "text",
                "text": STEER_TEXT,
                "id": "prt_1234567890abcdef1234567890abcdef",
            }
        ]
        assert server.messages[-1]["info"]["parentID"] == "steer-user-1"

        reconciled = await reconcile_steer_attempt(
            controller,
            "opencode",
            SteerReconcileRequest(
                target_session_id="avibe-session",
                expected_logical_turn_id=identity[0],
                expected_native_turn_id=identity[1],
                attempt_id=attempt_id,
            ),
        )

        assert reconciled.outcome is SteerOutcome.ACCEPTED
        assert reconciled.details["native_message_id"] == "steer-user-1"
        assert len(server.prompt_calls) == 1
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_opencode_stop_waits_for_in_flight_steering_write() -> None:
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    prompt_started = asyncio.Event()
    release_prompt = asyncio.Event()
    server = _OpenCodeServer(prompt_started=prompt_started, release_prompt=release_prompt)
    agent = _opencode_agent(primary, gate_task, server)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    controller.emit_agent_message = AsyncMock()
    removed_polls: list[str] = []
    agent.sessions = SimpleNamespace(
        get_all_active_polls=lambda: {"opencode-session": object()},
        remove_active_poll=removed_polls.append,
    )
    state = agent._steering_states[primary.base_session_id]
    try:
        identity = active_steer_identity(controller, "opencode", "avibe-session")
        assert identity is not None
        steer_task = asyncio.create_task(
            steer_active_turn(controller, "opencode", _steer_request(identity[1]))
        )
        await prompt_started.wait()

        stop_task = asyncio.create_task(agent.handle_stop(primary))
        await asyncio.sleep(0)
        assert server.abort_calls == []
        assert not gate_task.done()

        release_prompt.set()
        receipt = await steer_task
        stopped = await stop_task

        assert receipt.outcome is SteerOutcome.ACCEPTED
        assert stopped is True
        assert state.closing is True
        assert server.abort_calls == [("opencode-session", primary.working_path)]
        assert gate_task.cancelled()
        assert server.inactive_runs == ["opencode-session"]
        assert removed_polls == ["opencode-session"]
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_opencode_replacement_waits_for_in_flight_steering_write() -> None:
    primary = _primary_request(backend="opencode")
    replacement = _primary_request(backend="opencode")
    gate_task = await _held_task()
    prompt_started = asyncio.Event()
    release_prompt = asyncio.Event()
    server = _OpenCodeServer(prompt_started=prompt_started, release_prompt=release_prompt)
    agent = _opencode_agent(primary, gate_task, server)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    session_lock = asyncio.Lock()

    class _ReplacementSessionManager(_OpenCodeSessionManager):
        def get_session_lock(self, _base_session_id):
            return session_lock

        async def wait_for_session_idle(self, *_args):
            return None

        def pop_request_session(self, _base_session_id):
            return None

    agent._session_manager = _ReplacementSessionManager(
        primary.base_session_id,
        "opencode-session",
        primary.working_path,
    )
    agent.controller = controller
    agent._process_message = AsyncMock(return_value=None)
    try:
        identity = active_steer_identity(controller, "opencode", "avibe-session")
        assert identity is not None
        steer_task = asyncio.create_task(
            steer_active_turn(controller, "opencode", _steer_request(identity[1]))
        )
        await prompt_started.wait()

        replacement_task = asyncio.create_task(agent.handle_message(replacement))
        await asyncio.sleep(0)
        assert server.abort_calls == []
        assert not gate_task.done()

        release_prompt.set()
        receipt = await steer_task
        await replacement_task

        assert receipt.outcome is SteerOutcome.ACCEPTED
        assert server.abort_calls == [("opencode-session", primary.working_path)]
        assert gate_task.cancelled()
        agent._process_message.assert_awaited_once_with(replacement)
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
@pytest.mark.parametrize("status", [400, 409])
@pytest.mark.parametrize("reconciliation_fails", [False, True])
async def test_opencode_definitive_start_rejection_reconciles_before_poll_cleanup(
    monkeypatch,
    status: int,
    reconciliation_fails: bool,
) -> None:
    primary = _primary_request(backend="opencode")
    primary.context.platform_specific["delivery_start_attempt_id"] = ATTEMPT_ID
    events: list[str] = []

    class _Server:
        async def ensure_running(self):
            return None

        async def ensure_directory_ready(self, directory):
            return None

        async def list_messages(self, session_id, directory):
            return []

        async def prompt_async(self, **kwargs):
            events.append("prompt")
            raise OpenCodePromptRejectedError(status, "prompt refused")

        async def abort_session(self, session_id, directory):
            events.append("abort")
            return True

        async def mark_run_active(self, session_id):
            return None

        async def mark_run_inactive(self, session_id):
            return None

        def get_default_agent_from_config(self):
            return None

        def get_agent_model_from_config(self, agent):
            return None

        def get_agent_reasoning_effort_from_config(self, agent):
            return None

    class _SessionManager:
        async def ensure_working_dir(self, path):
            return None

        async def get_or_create_session_id(self, request, server):
            return "opencode-session"

        def set_request_session(self, base_session_id, session_id, directory, session_key):
            return None

        def set_agent_session_id(self, base_session_id, agent_session_id):
            return None

        def mark_initialized(self, session_id):
            return False

    class _Sessions:
        def add_active_poll(self, **kwargs):
            events.append("persist_poll")

        def remove_active_poll(self, session_id):
            events.append("remove_poll")

    def reconcile_start_attempt_not_written(turn_id, attempt_id, *, backend):
        events.append(f"reconcile:{turn_id}:{attempt_id}:{backend}")
        if reconciliation_fails:
            raise RuntimeError("storage unavailable")
        return True

    def settle_start_attempt_invalid_input(turn_id, attempt_id, *, backend):
        events.append(f"invalid:{turn_id}:{attempt_id}:{backend}")
        if reconciliation_fails:
            raise RuntimeError("storage unavailable")
        return True

    server = _Server()
    controller = SimpleNamespace(
        config=SimpleNamespace(
            platform="avibe",
            reply_enhancements=False,
            remote_access=None,
            language="en",
            opencode=SimpleNamespace(
                default_model=None,
                default_provider=None,
                default_reasoning_effort=None,
            ),
        ),
        model_hub_runtime=None,
        processing_indicator=SimpleNamespace(snapshot_request=lambda request: {}),
        get_opencode_overrides=lambda context: (None, None, None),
        session_turns=SimpleNamespace(
            reconcile_start_attempt_not_written=reconcile_start_attempt_not_written,
            settle_start_attempt_invalid_input=settle_start_attempt_invalid_input,
        ),
    )
    agent = object.__new__(OpenCodeAgent)
    agent.controller = controller
    agent.config = controller.config
    agent.sessions = _Sessions()
    agent._session_manager = _SessionManager()
    agent._poll_loop = SimpleNamespace()
    agent._steering_states = {}
    agent._active_requests = {}
    serve_opencode_agent(agent, server)
    agent._delete_ack = AsyncMock()
    agent._remove_ack_reaction = AsyncMock()
    agent._prepare_message_with_files = lambda request: request.message
    agent.record_model_hub_native_failure = AsyncMock()
    monkeypatch.setattr(
        "modules.agents.opencode.agent.build_system_prompt_injection",
        lambda **kwargs: "system prompt",
    )
    monkeypatch.setattr(
        "modules.agents.opencode.agent.bind_caller_context_session",
        lambda *args, **kwargs: None,
    )
    backend_failure = AsyncMock()
    monkeypatch.setattr(
        "modules.agents.opencode.agent.emit_backend_failure",
        backend_failure,
    )

    await agent._process_message(primary)

    expected_reconciliation = (
        f"invalid:logical-turn:{ATTEMPT_ID}:opencode"
        if status == 400
        else f"reconcile:logical-turn:{ATTEMPT_ID}:opencode"
    )
    assert events[:3] == [
        "persist_poll",
        "prompt",
        expected_reconciliation,
    ]
    assert "abort" not in events
    assert ("remove_poll" in events) is not reconciliation_fails
    backend_failure.assert_awaited_once()


@pytest.mark.anyio
async def test_opencode_ambiguous_start_failure_preserves_recovery_poll(
    monkeypatch,
) -> None:
    primary = _primary_request(backend="opencode")
    primary.context.platform_specific["delivery_start_attempt_id"] = ATTEMPT_ID
    events: list[str] = []

    class _Server:
        async def ensure_running(self):
            return None

        async def ensure_directory_ready(self, directory):
            return None

        async def list_messages(self, session_id, directory):
            return []

        async def prompt_async(self, **kwargs):
            events.append("prompt")
            raise OSError("connection lost after prompt write")

        async def abort_session(self, session_id, directory):
            events.append("abort")
            raise OSError("abort status unknown")

        async def mark_run_active(self, session_id):
            return None

        async def mark_run_inactive(self, session_id):
            return None

        def get_default_agent_from_config(self):
            return None

        def get_agent_model_from_config(self, agent):
            return None

        def get_agent_reasoning_effort_from_config(self, agent):
            return None

    class _SessionManager:
        async def ensure_working_dir(self, path):
            return None

        async def get_or_create_session_id(self, request, server):
            return "opencode-session"

        def set_request_session(self, base_session_id, session_id, directory, session_key):
            return None

        def set_agent_session_id(self, base_session_id, agent_session_id):
            return None

        def mark_initialized(self, session_id):
            return False

    class _Sessions:
        active = False

        def add_active_poll(self, **kwargs):
            self.active = True
            events.append("persist_poll")

        def remove_active_poll(self, session_id):
            self.active = False
            events.append("remove_poll")

    server = _Server()
    controller = SimpleNamespace(
        config=SimpleNamespace(
            platform="avibe",
            reply_enhancements=False,
            remote_access=None,
            language="en",
            opencode=SimpleNamespace(
                default_model=None,
                default_provider=None,
                default_reasoning_effort=None,
            ),
        ),
        model_hub_runtime=None,
        processing_indicator=SimpleNamespace(snapshot_request=lambda request: {}),
        get_opencode_overrides=lambda context: (None, None, None),
    )
    agent = object.__new__(OpenCodeAgent)
    agent.controller = controller
    agent.config = controller.config
    agent.sessions = _Sessions()
    agent._session_manager = _SessionManager()
    agent._poll_loop = SimpleNamespace()
    agent._steering_states = {}
    agent._active_requests = {}
    serve_opencode_agent(agent, server)
    agent._delete_ack = AsyncMock()
    agent._remove_ack_reaction = AsyncMock()
    agent._prepare_message_with_files = lambda request: request.message
    agent.record_model_hub_native_failure = AsyncMock()
    monkeypatch.setattr(
        "modules.agents.opencode.agent.build_system_prompt_injection",
        lambda **kwargs: "system prompt",
    )
    binding_tokens: list[str] = []

    def bind_caller_context(*args, **kwargs):
        binding_tokens.append(kwargs["binding_token"])
        return True

    unbound: list[tuple[str, str]] = []
    monkeypatch.setattr(
        "modules.agents.opencode.agent.bind_caller_context_session",
        bind_caller_context,
    )
    monkeypatch.setattr(
        "modules.agents.opencode.agent.unbind_caller_context_session",
        lambda session_id, *, binding_token: unbound.append((session_id, binding_token)),
    )
    backend_failure = AsyncMock()
    monkeypatch.setattr(
        "modules.agents.opencode.agent.emit_backend_failure",
        backend_failure,
    )

    await agent._process_message(primary)

    assert events == ["persist_poll", "prompt", "abort"]
    assert agent.sessions.active is True
    assert len(binding_tokens) == 1
    assert unbound == []
    backend_failure.assert_awaited_once()


@pytest.mark.anyio
async def test_opencode_question_abort_claims_terminal_owner_before_steering() -> None:
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer(
        messages=[
            {
                "info": {"id": "assistant-tool", "role": "assistant"},
                "parts": [
                    {
                        "type": "tool",
                        "tool": "question",
                        "state": {"status": "pending"},
                    }
                ],
            }
        ]
    )
    agent = _opencode_agent(primary, gate_task, server)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    state = agent._steering_states[primary.base_session_id]
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    try:
        messages = await poll_server.list_messages("opencode-session", primary.working_path)
        receipt = await steer_active_turn(
            controller,
            "opencode",
            _steer_request(state.native_turn_id),
        )
        await poll_server.abort_session("opencode-session", primary.working_path)

        assert messages[-1]["info"]["id"] == "assistant-tool"
        assert state.closing is True
        assert receipt.outcome is SteerOutcome.NOT_ACTIVE
        assert server.prompt_calls == []
        assert server.abort_calls == [("opencode-session", primary.working_path)]
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_opencode_poll_owner_observes_accepted_steer_before_terminalizing() -> None:
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer(
        messages=[
            {
                "info": {
                    "id": "primary-assistant",
                    "role": "assistant",
                    "time": {"completed": 1},
                    "finish": "stop",
                },
                "parts": [{"type": "text", "text": "first response"}],
            }
        ]
    )
    agent = _opencode_agent(primary, gate_task, server)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    state = agent._steering_states[primary.base_session_id]
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    poll_task = None
    try:
        poll_task = asyncio.create_task(
            poll_server.list_messages("opencode-session", primary.working_path)
        )
        while server.list_calls == 0:
            await asyncio.sleep(0)
        identity = active_steer_identity(controller, "opencode", "avibe-session")
        assert identity is not None
        receipt = await steer_active_turn(controller, "opencode", _steer_request(identity[1]))
        await asyncio.sleep(0.15)

        # The poll owner now receives the in-progress snapshot once the steered
        # user message is visible while the native session is busy, so the poll
        # loop keeps streaming live activity instead of blocking on busy.
        intermediate = await asyncio.wait_for(poll_task, timeout=1)
        assert intermediate[-1]["info"]["role"] == "user"
        assert state.closing is False
        server.messages.append(
            {
                "info": {
                    "id": "steered-assistant",
                    "role": "assistant",
                    "time": {"completed": 2},
                    "finish": "stop",
                },
                "parts": [{"type": "text", "text": "second response"}],
            }
        )
        server.status = {"type": "idle"}
        messages = await asyncio.wait_for(
            poll_server.list_messages("opencode-session", primary.working_path),
            timeout=1,
        )

        assert receipt.outcome is SteerOutcome.ACCEPTED
        assert messages[-1]["info"]["id"] == "steered-assistant"
        assert state.closing is True
        assert agent._active_requests == {primary.base_session_id: gate_task}
    finally:
        await _cancel_tasks(*(task for task in (poll_task, gate_task) if task is not None))


@pytest.mark.anyio
async def test_opencode_regular_turn_streams_snapshot_while_busy() -> None:
    """A plain turn (start-armed, like ``_process_message``) must hand the
    in-progress snapshot back to the poll loop while the native session is
    busy, so live tool activity streams instead of blocking until idle."""
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer(
        messages=[
            {
                "info": {"id": "baseline-user", "role": "user"},
                "parts": [{"type": "text", "text": "earlier prompt"}],
            },
            {
                "info": {"id": "primary-user", "role": "user"},
                "parts": [{"type": "text", "text": "primary"}],
            },
            {
                "info": {
                    "id": "running-assistant",
                    "role": "assistant",
                },
                "parts": [
                    {
                        "type": "tool",
                        "tool": "bash",
                        "callID": "call-bash",
                        "state": {"status": "running", "input": {"command": "ls"}},
                    }
                ],
            },
        ],
        status={"type": "busy"},
    )
    agent = _opencode_agent(primary, gate_task, server)
    state = agent._steering_states[primary.base_session_id]
    state.awaiting_after_message_ids = {"baseline-user"}
    state.awaiting_user_text = "primary"
    state.awaiting_prompt_accepted = True
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    try:
        intermediate = await asyncio.wait_for(
            poll_server.list_messages("opencode-session", primary.working_path),
            timeout=1,
        )

        assert intermediate[-1]["info"]["id"] == "running-assistant"
        assert state.awaiting_active_status_observed is True
        assert state.closing is False

        server.messages.append(
            {
                "info": {
                    "id": "final-assistant",
                    "role": "assistant",
                    "time": {"completed": 2},
                    "finish": "stop",
                },
                "parts": [{"type": "text", "text": "final response"}],
            }
        )
        server.status = {"type": "idle"}
        final = await asyncio.wait_for(
            poll_server.list_messages("opencode-session", primary.working_path),
            timeout=1,
        )

        assert final[-1]["info"]["id"] == "final-assistant"
        assert state.closing is True
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_opencode_regular_turn_waits_for_unconfirmed_start() -> None:
    """While the inserted user message is not yet visible, a busy session must
    keep waiting within the start-confirmation deadline (the 204-then-busy
    race guard), not hand an empty snapshot back to the poll loop."""
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer(
        messages=[
            {
                "info": {"id": "primary-user", "role": "user"},
                "parts": [{"type": "text", "text": "primary"}],
            }
        ],
        status={"type": "busy"},
    )
    agent = _opencode_agent(primary, gate_task, server)
    state = agent._steering_states[primary.base_session_id]
    state.awaiting_after_message_ids = {"primary-user"}
    state.awaiting_user_text = "primary"
    state.awaiting_prompt_accepted = True
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    poll_task = None
    try:
        poll_task = asyncio.create_task(
            poll_server.list_messages("opencode-session", primary.working_path)
        )
        await asyncio.sleep(0.15)

        assert not poll_task.done()
        assert state.awaiting_active_status_observed is False

        server.messages.append(
            {
                "info": {"id": "steer-user-1", "role": "user"},
                "parts": [{"type": "text", "text": "primary"}],
            }
        )
        intermediate = await asyncio.wait_for(poll_task, timeout=1)

        assert intermediate[-1]["info"]["id"] == "steer-user-1"
        assert state.awaiting_active_status_observed is True
    finally:
        await _cancel_tasks(*(task for task in (poll_task, gate_task) if task is not None))


@pytest.mark.anyio
async def test_opencode_restored_busy_snapshot_requires_post_boundary_evidence() -> None:
    """A restored boundary-sampled poll must not receive a busy snapshot that
    only contains boundary messages (the pre-restore final answer): the
    restored poll loop would treat it as the final response and drop the
    still-running poll."""
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer(
        messages=[
            {
                "info": {
                    "id": "old-final-assistant",
                    "role": "assistant",
                    "time": {"completed": 1},
                    "finish": "stop",
                },
                "parts": [{"type": "text", "text": "old answer"}],
            }
        ],
        status={"type": "busy"},
    )
    agent = _opencode_agent(primary, gate_task, server)
    state = agent._steering_states[primary.base_session_id]
    state.awaiting_after_message_ids = {"old-final-assistant"}
    state.awaiting_user_text = None
    state.restored = True
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    poll_task = None
    try:
        poll_task = asyncio.create_task(
            poll_server.list_messages("opencode-session", primary.working_path)
        )
        await asyncio.sleep(0.15)

        assert not poll_task.done()
        assert state.closing is False

        server.messages.append(
            {
                "info": {
                    "id": "running-assistant",
                    "role": "assistant",
                },
                "parts": [
                    {
                        "type": "tool",
                        "tool": "bash",
                        "callID": "call-bash",
                        "state": {"status": "running", "input": {"command": "ls"}},
                    }
                ],
            }
        )
        snapshot = await asyncio.wait_for(poll_task, timeout=1)

        assert snapshot[-1]["info"]["id"] == "running-assistant"
        assert state.closing is False
    finally:
        await _cancel_tasks(*(task for task in (poll_task, gate_task) if task is not None))


@pytest.mark.anyio
async def test_opencode_restored_empty_boundary_still_requires_new_evidence() -> None:
    """When the sampled reconciliation boundary is empty (only pre-prompt
    baseline messages existed at sample time), a busy snapshot holding only
    the baseline final answer must still be gated: an empty boundary is not
    automatic evidence."""
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer(
        messages=[
            {
                "info": {
                    "id": "old-final-assistant",
                    "role": "assistant",
                    "time": {"completed": 1},
                    "finish": "stop",
                },
                "parts": [{"type": "text", "text": "old answer"}],
            }
        ],
        status={"type": "busy"},
    )
    agent = _opencode_agent(primary, gate_task, server)
    state = agent._steering_states[primary.base_session_id]
    state.baseline_message_ids = {"old-final-assistant"}
    state.awaiting_after_message_ids = set()
    state.awaiting_user_text = None
    state.restored = True
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    poll_task = None
    try:
        poll_task = asyncio.create_task(
            poll_server.list_messages("opencode-session", primary.working_path)
        )
        await asyncio.sleep(0.15)

        assert not poll_task.done()
        assert state.closing is False

        server.messages.append(
            {
                "info": {
                    "id": "running-assistant",
                    "role": "assistant",
                },
                "parts": [
                    {
                        "type": "tool",
                        "tool": "bash",
                        "callID": "call-bash",
                        "state": {"status": "running", "input": {"command": "ls"}},
                    }
                ],
            }
        )
        snapshot = await asyncio.wait_for(poll_task, timeout=1)

        assert snapshot[-1]["info"]["id"] == "running-assistant"
        assert state.closing is False
    finally:
        await _cancel_tasks(*(task for task in (poll_task, gate_task) if task is not None))


@pytest.mark.anyio
async def test_opencode_retry_keeps_completed_error_snapshots_gated() -> None:
    """A completed assistant error must stay gated while the native session
    still reports busy/retry: handing it to the poll loop would emit a
    terminal failure (or a competing "continue") while OpenCode's own retry
    is still active."""
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer(
        messages=[
            {
                "info": {"id": "primary-user", "role": "user"},
                "parts": [{"type": "text", "text": "primary"}],
            },
            {
                "info": {
                    "id": "failed-assistant",
                    "role": "assistant",
                    "time": {"completed": 1},
                    "error": {"name": "ProviderError", "data": {"message": "boom"}},
                },
                "parts": [],
            },
        ],
        status={"type": "retry"},
    )
    agent = _opencode_agent(primary, gate_task, server)
    state = agent._steering_states[primary.base_session_id]
    state.awaiting_after_message_ids = set()
    state.awaiting_user_text = "primary"
    state.awaiting_prompt_accepted = True
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    poll_task = None
    try:
        poll_task = asyncio.create_task(
            poll_server.list_messages("opencode-session", primary.working_path)
        )
        await asyncio.sleep(0.15)

        assert not poll_task.done()
        assert state.awaiting_active_status_observed is True
        assert state.closing is False

        server.messages.append(
            {
                "info": {
                    "id": "retried-assistant",
                    "role": "assistant",
                    "time": {"completed": 2},
                    "finish": "stop",
                },
                "parts": [{"type": "text", "text": "recovered"}],
            }
        )
        server.status = {"type": "busy"}
        snapshot = await asyncio.wait_for(poll_task, timeout=1)

        assert snapshot[-1]["info"]["id"] == "retried-assistant"
        assert state.closing is True
    finally:
        await _cancel_tasks(*(task for task in (poll_task, gate_task) if task is not None))


@pytest.mark.anyio
async def test_opencode_idle_post_boundary_error_clears_awaiting_boundary() -> None:
    """A completed retry error must reach the poll owner, not a synthetic idle failure."""

    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer(
        messages=[
            {
                "info": {"id": "primary-user", "role": "user"},
                "parts": [{"type": "text", "text": "continue"}],
            },
            {
                "info": {
                    "id": "retry-error",
                    "role": "assistant",
                    "time": {"completed": 1},
                    "error": {"name": "UnknownError", "data": {"message": "tls"}},
                },
                "parts": [],
            },
        ],
        status={"type": "idle"},
    )
    agent = _opencode_agent(primary, gate_task, server)
    state = agent._steering_states[primary.base_session_id]
    state.awaiting_after_message_ids = {"older-error"}
    state.awaiting_user_text = "continue"
    state.awaiting_active_status_observed = True
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    try:
        snapshot = await asyncio.wait_for(
            poll_server.list_messages("opencode-session", primary.working_path),
            timeout=1,
        )
        assert snapshot[-1]["info"]["id"] == "retry-error"
        assert snapshot[-1]["info"]["error"]["name"] == "UnknownError"
        assert state.awaiting_after_message_ids is None
        assert state.closing is False
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_opencode_refuses_after_poll_owner_claims_terminal_result() -> None:
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer(
        messages=[
            {
                "info": {
                    "id": "primary-assistant",
                    "role": "assistant",
                    "time": {"completed": 1},
                    "finish": "stop",
                },
                "parts": [{"type": "text", "text": "done"}],
            }
        ],
        status={"type": "idle"},
    )
    agent = _opencode_agent(primary, gate_task, server)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    state = agent._steering_states[primary.base_session_id]
    native_turn_id = state.native_turn_id
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    try:
        await poll_server.list_messages("opencode-session", primary.working_path)
        receipt = await steer_active_turn(controller, "opencode", _steer_request(native_turn_id))

        assert state.closing is True
        assert receipt.outcome is SteerOutcome.NOT_ACTIVE
        assert server.prompt_calls == []
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_opencode_ambiguous_write_reconciles_unchanged_messages_when_idle() -> None:
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer(
        error=TimeoutError("response timed out"),
        messages=[
            {
                "info": {
                    "id": "primary-assistant",
                    "role": "assistant",
                    "time": {"completed": 1},
                    "finish": "stop",
                },
                "parts": [{"type": "text", "text": "done"}],
            }
        ],
        status_responses=[{"type": "busy"}, {"type": "idle"}],
    )
    agent = _opencode_agent(primary, gate_task, server)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    state = agent._steering_states[primary.base_session_id]
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    try:
        identity = active_steer_identity(controller, "opencode", "avibe-session")
        assert identity is not None
        receipt = await steer_active_turn(controller, "opencode", _steer_request(identity[1]))
        messages = await asyncio.wait_for(
            poll_server.list_messages("opencode-session", primary.working_path),
            timeout=1,
        )

        assert receipt.outcome is SteerOutcome.UNKNOWN
        assert messages[-1]["info"]["id"] == "primary-assistant"
        assert state.awaiting_after_message_ids is None
        assert state.closing is True
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_opencode_insert_reconciliation_survives_visible_user_until_idle() -> None:
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer(
        messages=[
            {
                "info": {
                    "id": "primary-assistant",
                    "role": "assistant",
                    "time": {"completed": 1},
                    "finish": "stop",
                },
                "parts": [{"type": "text", "text": "done"}],
            }
        ],
        status={"type": "busy"},
    )
    agent = _opencode_agent(primary, gate_task, server)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    state = agent._steering_states[primary.base_session_id]
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    try:
        identity = active_steer_identity(controller, "opencode", "avibe-session")
        assert identity is not None
        receipt = await steer_active_turn(controller, "opencode", _steer_request(identity[1]))
        assert server.messages[-1]["info"]["role"] == "user"

        server.messages.append(
            {
                "info": {
                    "id": "steered-tool-assistant",
                    "role": "assistant",
                    "time": {"completed": 2},
                    "finish": "tool-calls",
                },
                "parts": [],
            }
        )
        server.status = {"type": "idle"}
        messages = await poll_server.list_messages("opencode-session", primary.working_path)

        assert receipt.outcome is SteerOutcome.ACCEPTED
        assert messages[-1]["info"]["error"]["name"] == "NativeSessionEndedBeforeResult"
        assert state.awaiting_after_message_ids is None
        assert state.closing is True
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_opencode_accepted_prompt_waits_for_delayed_busy_registration() -> None:
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()

    class _DelayedStartServer(_OpenCodeServer):
        async def list_messages(self, session_id: str, directory: str) -> list[dict]:
            if self.list_calls == 2:
                self.messages.append(
                    {
                        "info": {
                            "id": "follow-up-assistant",
                            "role": "assistant",
                            "time": {"completed": 2},
                            "finish": "stop",
                        },
                        "parts": [{"type": "text", "text": "answered"}],
                    }
                )
            return await super().list_messages(session_id, directory)

    server = _DelayedStartServer(
        messages=[
            {
                "info": {
                    "id": "primary-assistant",
                    "role": "assistant",
                    "time": {"completed": 1},
                    "finish": "stop",
                },
                "parts": [{"type": "text", "text": "primary"}],
            },
            {
                "info": {"id": "follow-up-user", "role": "user"},
                "parts": [{"type": "text", "text": "follow-up"}],
            },
        ],
        status_responses=[None, {"type": "idle"}, {"type": "busy"}, {"type": "idle"}],
    )
    agent = _opencode_agent(primary, gate_task, server)
    state = agent._steering_states[primary.base_session_id]
    state.baseline_message_ids = {"primary-assistant"}
    state.awaiting_after_message_ids = {"primary-assistant"}
    state.awaiting_user_text = "follow-up"
    state.awaiting_prompt_accepted = True
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    try:
        messages = await asyncio.wait_for(
            poll_server.list_messages("opencode-session", primary.working_path),
            timeout=1,
        )

        # The busy snapshot is handed back once the inserted user message is
        # visible; the third list lands the completed final assistant.
        assert messages[-1]["info"]["id"] == "follow-up-assistant"
        assert state.terminal_status_failure_messages is None
        assert state.awaiting_after_message_ids is None
        assert state.closing is True
        assert server.list_calls == 3
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_opencode_idle_waits_for_delayed_terminal_message_visibility() -> None:
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()

    class _DelayedFinalServer(_OpenCodeServer):
        async def list_messages(self, session_id: str, directory: str) -> list[dict]:
            if self.list_calls == 2:
                self.messages.append(
                    {
                        "info": {
                            "id": "follow-up-assistant",
                            "role": "assistant",
                            "time": {"completed": 2},
                            "finish": "stop",
                        },
                        "parts": [{"type": "text", "text": "answered"}],
                    }
                )
            return await super().list_messages(session_id, directory)

    server = _DelayedFinalServer(
        messages=[
            {
                "info": {"id": "follow-up-user", "role": "user"},
                "parts": [{"type": "text", "text": "follow-up"}],
            }
        ],
        status_responses=[{"type": "busy"}, {"type": "idle"}, {"type": "idle"}],
    )
    agent = _opencode_agent(primary, gate_task, server)
    state = agent._steering_states[primary.base_session_id]
    state.awaiting_after_message_ids = set()
    state.awaiting_user_text = "follow-up"
    state.awaiting_prompt_accepted = True
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    try:
        intermediate = await asyncio.wait_for(
            poll_server.list_messages("opencode-session", primary.working_path),
            timeout=1,
        )

        # Busy + inserted user visible → in-progress snapshot streams back.
        assert intermediate[-1]["info"]["id"] == "follow-up-user"
        assert state.awaiting_active_status_observed is True
        assert state.closing is False

        messages = await asyncio.wait_for(
            poll_server.list_messages("opencode-session", primary.working_path),
            timeout=1,
        )

        assert messages[-1]["info"]["id"] == "follow-up-assistant"
        assert state.terminal_status_failure_messages is None
        assert state.awaiting_after_message_ids is None
        assert state.closing is True
        assert server.list_calls == 3
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_opencode_accepted_prompt_stays_owned_until_delayed_result() -> None:
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()

    class _DelayedAcceptedPromptServer(_OpenCodeServer):
        async def list_messages(self, session_id: str, directory: str) -> list[dict]:
            if self.list_calls == 1:
                self.messages.extend(
                    [
                        {
                            "info": {"id": "follow-up-user", "role": "user"},
                            "parts": [{"type": "text", "text": "follow-up"}],
                        },
                        {
                            "info": {
                                "id": "follow-up-assistant",
                                "role": "assistant",
                                "time": {"completed": 2},
                                "finish": "stop",
                            },
                            "parts": [{"type": "text", "text": "answered"}],
                        },
                    ]
                )
            return await super().list_messages(session_id, directory)

    server = _DelayedAcceptedPromptServer(status={"type": "idle"})
    agent = _opencode_agent(primary, gate_task, server)
    state = agent._steering_states[primary.base_session_id]
    state.awaiting_after_message_ids = set()
    state.awaiting_user_text = "follow-up"
    state.awaiting_prompt_accepted = True
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    try:
        messages = await asyncio.wait_for(
            poll_server.list_messages("opencode-session", primary.working_path),
            timeout=1,
        )

        assert messages[-1]["info"]["id"] == "follow-up-assistant"
        assert state.terminal_status_failure_messages is None
        assert state.awaiting_after_message_ids is None
        assert state.closing is True
        assert server.list_calls == 2
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_opencode_accepted_prompt_without_activity_is_bounded() -> None:
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer(status={"type": "idle"})
    agent = _opencode_agent(primary, gate_task, server)
    state = agent._steering_states[primary.base_session_id]
    state.awaiting_after_message_ids = set()
    state.awaiting_user_text = "follow-up"
    state.awaiting_prompt_accepted = True
    state.awaiting_prompt_activity_deadline = time.monotonic() - 1
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    try:
        messages = await poll_server.list_messages(
            "opencode-session",
            primary.working_path,
        )

        assert messages[-1]["info"]["error"]["name"] == (
            "NativeSessionEndedBeforeResult"
        )
        assert state.awaiting_after_message_ids is None
        assert state.closing is True
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_opencode_requires_final_assistant_after_inserted_user() -> None:
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()

    class _RacingOpenCodeServer(_OpenCodeServer):
        async def prompt_async(self, **kwargs) -> None:
            self.prompt_calls.append(kwargs)
            self.messages.extend(
                [
                    {
                        "info": {
                            "id": "raced-primary-assistant",
                            "role": "assistant",
                            "time": {"completed": 1},
                            "finish": "stop",
                        },
                        "parts": [{"type": "text", "text": "primary"}],
                    },
                    {
                        "info": {"id": "steer-user", "role": "user"},
                        "parts": [{"type": "text", "text": kwargs["text"]}],
                    },
                ]
            )

    server = _RacingOpenCodeServer(status={"type": "busy"})
    agent = _opencode_agent(primary, gate_task, server)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    state = agent._steering_states[primary.base_session_id]
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    try:
        identity = active_steer_identity(controller, "opencode", "avibe-session")
        assert identity is not None
        receipt = await steer_active_turn(controller, "opencode", _steer_request(identity[1]))
        server.status = {"type": "idle"}

        messages = await poll_server.list_messages("opencode-session", primary.working_path)

        assert receipt.outcome is SteerOutcome.ACCEPTED
        assert messages[-1]["info"]["error"]["name"] == "NativeSessionEndedBeforeResult"
        assert state.closing is True
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_opencode_poll_keeps_owner_until_failed_status_probe_recovers() -> None:
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer(
        messages=[
            {
                "info": {
                    "id": "primary-assistant",
                    "role": "assistant",
                    "time": {"completed": 1},
                    "finish": "stop",
                },
                "parts": [{"type": "text", "text": "done"}],
            }
        ],
        status={"type": "idle"},
        status_error=ConnectionError("status unavailable"),
    )
    agent = _opencode_agent(primary, gate_task, server)
    state = agent._steering_states[primary.base_session_id]
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    poll_task = asyncio.create_task(
        poll_server.list_messages("opencode-session", primary.working_path)
    )
    try:
        while server.list_calls < 2:
            await asyncio.sleep(0.05)
        assert not poll_task.done()
        assert state.closing is False

        server.status_error = None
        messages = await asyncio.wait_for(poll_task, timeout=1)

        assert messages[-1]["info"]["id"] == "primary-assistant"
        assert state.closing is True
    finally:
        await _cancel_tasks(poll_task, gate_task)


@pytest.mark.anyio
async def test_opencode_status_reconciliation_failures_are_bounded() -> None:
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer(
        messages=[
            {
                "info": {
                    "id": "primary-assistant",
                    "role": "assistant",
                    "time": {"completed": 1},
                    "finish": "stop",
                },
                "parts": [{"type": "text", "text": "done"}],
            }
        ],
        status_error=ConnectionError("status unavailable"),
    )
    agent = _opencode_agent(primary, gate_task, server)
    state = agent._steering_states[primary.base_session_id]
    state.awaiting_after_message_ids = {"primary-assistant"}
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    try:
        messages = await asyncio.wait_for(
            poll_server.list_messages("opencode-session", primary.working_path),
            timeout=1,
        )
        first_failure_id = messages[-1]["info"]["id"]
        await poll_server.prompt_async(
            session_id="opencode-session",
            directory=primary.working_path,
            text="continue",
        )
        repeated = await poll_server.list_messages("opencode-session", primary.working_path)

        assert server.list_calls == 3
        assert state.closing is True
        assert repeated[-1]["info"]["id"] != first_failure_id
        assert repeated[-1]["info"]["error"] == {
            "name": "StatusReconciliationError",
            "data": {"message": "status unavailable"},
        }
        assert server.prompt_calls == []
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_opencode_normal_poll_delivers_terminal_reconciliation_failure(
    monkeypatch,
) -> None:
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer(
        messages=[
            {
                "info": {
                    "id": "primary-assistant",
                    "role": "assistant",
                    "time": {"completed": 1},
                    "finish": "stop",
                },
                "parts": [{"type": "text", "text": "done"}],
            }
        ],
        status_error=ConnectionError("status unavailable"),
    )
    agent = _opencode_agent(primary, gate_task, server)
    agent.controller = SimpleNamespace(config=SimpleNamespace(language="zh"))
    agent.opencode_config = SimpleNamespace(error_retry_limit=1)
    agent.record_model_hub_native_failure = AsyncMock()
    emit_failure = AsyncMock()
    monkeypatch.setattr("modules.agents.opencode.poll_loop.emit_backend_failure", emit_failure)

    original_sleep = asyncio.sleep

    async def _fast_sleep(_delay: float) -> None:
        await original_sleep(0)

    monkeypatch.setattr("modules.agents.opencode.poll_loop.asyncio.sleep", _fast_sleep)
    state = agent._steering_states[primary.base_session_id]
    state.awaiting_after_message_ids = {"primary-assistant"}
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    try:
        result = await asyncio.wait_for(
            OpenCodePollLoop(agent).run_prompt_poll(
                primary,
                poll_server,
                "opencode-session",
                agent_to_use="build",
                model_dict={"providerID": "openai", "modelID": "gpt-5"},
                reasoning_effort="high",
                baseline_message_ids=set(),
            ),
            timeout=1,
        )

        assert result == (None, False)
        assert server.prompt_calls == []
        emit_failure.assert_awaited_once()
        assert emit_failure.await_args.kwargs["failure_id"].endswith(":1")
        assert emit_failure.await_args.kwargs["display_text"] == (
            "OpenCode 错误:StatusReconciliationError - status unavailable"
        )
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_opencode_final_output_survives_unavailable_status_probe() -> None:
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer(
        messages=[
            {
                "info": {
                    "id": "primary-assistant",
                    "role": "assistant",
                    "time": {"completed": 1},
                    "finish": "stop",
                },
                "parts": [{"type": "text", "text": "done"}],
            }
        ],
        status_error=ConnectionError("status unavailable"),
    )
    agent = _opencode_agent(primary, gate_task, server)
    state = agent._steering_states[primary.base_session_id]
    state.awaiting_after_message_ids = set()
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    try:
        messages = await asyncio.wait_for(
            poll_server.list_messages("opencode-session", primary.working_path),
            timeout=1,
        )

        assert messages[-1]["info"]["id"] == "primary-assistant"
        assert state.terminal_status_failure_messages is None
        assert state.closing is True
        assert server.list_calls == 3
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_restored_opencode_status_reconciliation_becomes_terminal_snapshot() -> None:
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer(
        messages=[
            {
                "info": {
                    "id": "primary-assistant",
                    "role": "assistant",
                    "time": {"completed": 1},
                    "finish": "stop",
                },
                "parts": [{"type": "text", "text": "done"}],
            },
            {
                "info": {"id": "steer-user", "role": "user", "time": {}},
                "parts": [{"type": "text", "text": "follow-up"}],
            },
        ],
        status_error=ConnectionError("status unavailable"),
    )
    agent = _opencode_agent(primary, gate_task, server)
    state = agent._steering_states[primary.base_session_id]
    state.restored = True
    state.awaiting_after_message_ids = {"primary-assistant"}
    poll_server = _SteeringAwareOpenCodeServer(server, state)
    try:
        messages = await asyncio.wait_for(
            poll_server.list_messages("opencode-session", primary.working_path),
            timeout=1,
        )
        repeated = await poll_server.list_messages(
            "opencode-session",
            primary.working_path,
        )

        assert state.closing is True
        assert server.list_calls == 3
        assert repeated == messages
        assert messages[-1]["info"]["finish"] == "tool-calls"
        assert messages[-1]["info"]["error"] == {
            "name": "StatusReconciliationError",
            "data": {"message": "status unavailable"},
        }
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
@pytest.mark.parametrize(
    ("error", "expected"),
    [
        (OpenCodePromptRejectedError(409, "busy input refused"), SteerOutcome.REFUSED),
        (OpenCodePromptRejectedError(404, "session missing"), SteerOutcome.NOT_ACTIVE),
        (TimeoutError("response timed out"), SteerOutcome.UNKNOWN),
        (aiohttp.ServerDisconnectedError("response disconnected"), SteerOutcome.UNKNOWN),
    ],
)
async def test_opencode_maps_async_prompt_failures(error: Exception, expected: SteerOutcome) -> None:
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer(error=error)
    agent = _opencode_agent(primary, gate_task, server)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    try:
        identity = active_steer_identity(controller, "opencode", "avibe-session")
        assert identity is not None
        receipt = await steer_active_turn(controller, "opencode", _steer_request(identity[1]))
        assert receipt.outcome is expected
        assert server.abort_calls == []
        assert len(server.prompt_calls) == 1
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_opencode_connector_refusal_preserves_reconciliation_boundary() -> None:
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    connector_error = aiohttp.ClientConnectorError(
        ConnectionKey("127.0.0.1", 4096, False, False, None, None, None),
        OSError("connect failed"),
    )
    server = _OpenCodeServer(
        error=connector_error,
        messages=[
            {
                "info": {
                    "id": "primary-assistant",
                    "role": "assistant",
                    "time": {"completed": 1},
                    "finish": "stop",
                },
                "parts": [{"type": "text", "text": "done"}],
            }
        ],
    )
    agent = _opencode_agent(primary, gate_task, server)
    state = agent._steering_states[primary.base_session_id]
    state.awaiting_after_message_ids = set()
    controller = _controller_with_active_gate(agent, primary, gate_task)
    try:
        identity = active_steer_identity(controller, "opencode", "avibe-session")
        assert identity is not None

        receipt = await steer_active_turn(controller, "opencode", _steer_request(identity[1]))

        assert receipt.outcome is SteerOutcome.REFUSED
        assert receipt.reason == "runtime_unavailable"
        assert state.awaiting_after_message_ids == set()
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_opencode_rejects_stale_runner_and_unavailable_runtime() -> None:
    primary = _primary_request(backend="opencode")
    gate_task = await _held_task()
    server = _OpenCodeServer()
    agent = _opencode_agent(primary, gate_task, server)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    try:
        stale = await steer_active_turn(controller, "opencode", _steer_request("stale-runner"))
        assert stale.outcome is SteerOutcome.NOT_ACTIVE
        assert server.prompt_calls == []

        # The native turn has no generation that could take the steer.
        agent._steering_states[primary.base_session_id].generation = None
        identity = agent.steering_native_turn_id(
            SimpleNamespace(runtime_key="runtime-key", agent_request=primary)
        )
        unavailable = await steer_active_turn(controller, "opencode", _steer_request(identity))
        assert unavailable.outcome is SteerOutcome.REFUSED
        assert unavailable.reason == "runtime_unavailable"
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_shared_guard_rejects_stale_logical_or_missing_active_turn() -> None:
    primary = _primary_request(backend="codex")
    gate_task = await _held_task()
    transport = _CodexTransport()
    agent = init_generation_state(object.__new__(CodexAgent))
    agent._turn_registry = _CodexTurnRegistry(primary.base_session_id, "codex-turn")
    agent._session_mgr = _CodexSessionManager(primary.base_session_id, "codex-thread", primary.working_path)
    install_codex_transport(agent, primary.working_path, transport, sessions={primary.base_session_id: "codex-thread"}, last_activity=0.0)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    try:
        stale = await steer_active_turn(
            controller,
            "codex",
            _steer_request("codex-turn", logical_turn_id="stale-logical"),
        )
        assert stale.outcome is SteerOutcome.NOT_ACTIVE
        assert transport.calls == []

        controller.agent_service._turn_gates.clear()
        missing = await steer_active_turn(controller, "codex", _steer_request("codex-turn"))
        assert missing.outcome is SteerOutcome.NOT_ACTIVE
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_shared_guard_requires_the_avibe_session_identity() -> None:
    primary = _primary_request(session_id="avibe-session", backend="codex")
    primary.base_session_id = "backend-anchor"
    gate_task = await _held_task()
    transport = _CodexTransport()
    agent = init_generation_state(object.__new__(CodexAgent))
    agent._turn_registry = _CodexTurnRegistry(primary.base_session_id, "codex-turn")
    agent._session_mgr = _CodexSessionManager(primary.base_session_id, "codex-thread", primary.working_path)
    install_codex_transport(agent, primary.working_path, transport, sessions={primary.base_session_id: "codex-thread"}, last_activity=0.0)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    request = _steer_request("codex-turn")
    request = SteerRequest(
        target_session_id="backend-anchor",
        expected_logical_turn_id=request.expected_logical_turn_id,
        expected_native_turn_id=request.expected_native_turn_id,
        text=request.text,
    )
    try:
        receipt = await steer_active_turn(controller, "codex", request)
        assert receipt.outcome is SteerOutcome.NOT_ACTIVE
        assert transport.calls == []
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_shared_service_uses_the_active_runtime_generation_after_registry_refresh() -> None:
    primary = _primary_request(backend="codex")
    gate_task = await _held_task()
    active_transport = _CodexTransport()
    active_agent = init_generation_state(object.__new__(CodexAgent))
    active_agent._turn_registry = _CodexTurnRegistry(primary.base_session_id, "codex-turn")
    active_agent._session_mgr = _CodexSessionManager(
        primary.base_session_id,
        "codex-thread",
        primary.working_path,
    )
    install_codex_transport(active_agent, primary.working_path, active_transport, sessions={primary.base_session_id: "codex-thread"}, last_activity=0.0)
    controller = _controller_with_active_gate(active_agent, primary, gate_task)

    replacement_agent = init_generation_state(object.__new__(CodexAgent))
    replacement_agent._turn_registry = _CodexTurnRegistry(primary.base_session_id, "replacement-turn")
    replacement_agent._session_mgr = _CodexSessionManager(
        primary.base_session_id,
        "replacement-thread",
        primary.working_path,
    )
    controller.agent_service.agents["codex"] = replacement_agent
    try:
        identity = active_steer_identity(controller, "codex", "avibe-session")
        assert identity == ("logical-turn", "codex-turn")
        receipt = await steer_active_turn(controller, "codex", _steer_request("codex-turn"))
        assert receipt.outcome is SteerOutcome.ACCEPTED
        assert [method for method, _params in active_transport.calls] == ["turn/steer"]
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_shared_guard_disambiguates_concurrent_gates_by_expected_turn_identity() -> None:
    first = _primary_request(backend="codex")
    second = _primary_request(backend="codex")
    second.context.platform_specific["turn_token"] = "logical-turn-2"
    second.context.platform_specific["agent_runtime_turn_token"] = "runtime-token-2"
    first_task = await _held_task()
    second_task = await _held_task()

    first_transport = _CodexTransport(response={"turnId": "codex-turn-1"})
    first_agent = init_generation_state(object.__new__(CodexAgent))
    first_agent._turn_registry = _CodexTurnRegistry(first.base_session_id, "codex-turn-1")
    first_agent._session_mgr = _CodexSessionManager(first.base_session_id, "codex-thread-1", first.working_path)
    install_codex_transport(first_agent, first.working_path, first_transport, sessions={first.base_session_id: "codex-thread"}, last_activity=0.0)

    second_transport = _CodexTransport(response={"turnId": "codex-turn-2"})
    second_agent = init_generation_state(object.__new__(CodexAgent))
    second_agent._turn_registry = _CodexTurnRegistry(second.base_session_id, "codex-turn-2")
    second_agent._session_mgr = _CodexSessionManager(
        second.base_session_id,
        "codex-thread-2",
        second.working_path,
    )
    install_codex_transport(second_agent, second.working_path, second_transport, sessions={second.base_session_id: "codex-thread"}, last_activity=0.0)

    gates = {
        "main": SimpleNamespace(
            backend="codex",
            token="runtime-token",
            runtime_started=True,
            task=first_task,
            request=first,
            context=first.context,
            agent=first_agent,
        ),
        "named-subagent": SimpleNamespace(
            backend="codex",
            token="runtime-token-2",
            runtime_started=True,
            task=second_task,
            request=second,
            context=second.context,
            agent=second_agent,
        ),
    }
    controller = SimpleNamespace(
        agent_service=SimpleNamespace(agents={"codex": first_agent}, _turn_gates=gates)
    )
    first_agent.controller = controller
    second_agent.controller = controller
    try:
        assert active_steer_identity(controller, "codex", "avibe-session") is None
        identity = active_steer_identity(
            controller,
            "codex",
            "avibe-session",
            expected_logical_turn_id="logical-turn-2",
        )
        receipt = await steer_active_turn(
            controller,
            "codex",
            _steer_request("codex-turn-2", logical_turn_id="logical-turn-2"),
        )

        assert identity == ("logical-turn-2", "codex-turn-2")
        assert receipt.outcome is SteerOutcome.ACCEPTED
        assert first_transport.calls == []
        assert [method for method, _params in second_transport.calls] == ["turn/steer"]
    finally:
        await _cancel_tasks(first_task, second_task)


@pytest.mark.anyio
async def test_shared_service_prefers_explicit_session_target_over_legacy_id() -> None:
    primary = _primary_request(session_id="current-session", backend="codex")
    primary.context.platform_specific["agent_session_id"] = "stale-session"
    gate_task = await _held_task()
    transport = _CodexTransport()
    agent = init_generation_state(object.__new__(CodexAgent))
    agent._turn_registry = _CodexTurnRegistry(primary.base_session_id, "codex-turn")
    agent._session_mgr = _CodexSessionManager(
        primary.base_session_id,
        "codex-thread",
        primary.working_path,
    )
    install_codex_transport(agent, primary.working_path, transport, sessions={primary.base_session_id: "codex-thread"}, last_activity=0.0)
    controller = _controller_with_active_gate(agent, primary, gate_task)
    try:
        assert active_steer_identity(controller, "codex", "stale-session") is None
        assert active_steer_identity(controller, "codex", "current-session") == (
            "logical-turn",
            "codex-turn",
        )
    finally:
        await _cancel_tasks(gate_task)


@pytest.mark.anyio
async def test_shared_service_refuses_an_unavailable_backend() -> None:
    controller = SimpleNamespace(agent_service=SimpleNamespace(agents={}, _turn_gates={}))
    receipt = await steer_active_turn(controller, "claude", _steer_request("native-turn"))
    assert receipt.outcome is SteerOutcome.REFUSED
    assert receipt.reason == "runtime_unavailable"


@pytest.mark.anyio
async def test_opencode_coordinator_error_aborts_through_steering_owner(
    monkeypatch, native_input, managers,
) -> None:
    """Failed initial binding retries; steering owns abort ordering."""
    from core.session_turns import DeliveryRequest

    manager, _fresh, engine, _other, _starts = managers
    _seed_session(engine, "avibe-session")
    monkeypatch.setattr("storage.db.get_cached_sqlite_engine", lambda: engine)
    durable = await manager.deliver(
        DeliveryRequest(session_id="avibe-session", priority="p3", content="delegate", author_id="local"),
        context=_context("avibe-session"),
    )
    attempts = 0
    retry_succeeded = asyncio.Event()
    loop = asyncio.get_running_loop()
    monkeypatch.setattr("modules.agents.opencode.agent._CALLER_CONTEXT_BINDING_RETRY_SECONDS", 0)
    metadata, prefix = native_input
    primary = _primary_request(backend="opencode")
    primary.context.platform_specific["turn_token"] = durable.turn_id
    primary.input_metadata = metadata
    poll_started = asyncio.Event()
    fail_poll = asyncio.Event()
    steer_started = asyncio.Event()
    release_steer = asyncio.Event()
    events: list[str] = []

    class _Server:
        prompt_count = 0

        def caller_context_binding_path(self):
            return "/old-avibe-home/runtime/opencode_caller_context.json"

        async def ensure_running(self):
            return None

        async def ensure_directory_ready(self, directory):
            return None

        async def list_messages(self, session_id, directory):
            return [{"info": {"id": "primary-user", "role": "user"}, "parts": []}]

        async def get_session_status(self, session_id, directory):
            return {"type": "busy"}

        async def prompt_async(self, **kwargs):
            self.prompt_count += 1
            if self.prompt_count == 1:
                assert kwargs["text"] == prefix + primary.message
                events.append("primary")
                return
            steer_started.set()
            await release_steer.wait()
            events.append("steer")

        async def abort_session(self, session_id, directory):
            events.append("abort")
            return True

        async def mark_run_active(self, session_id):
            return None

        async def mark_run_inactive(self, session_id):
            return None

        def get_default_agent_from_config(self):
            return None

        def get_agent_model_from_config(self, agent):
            return None

        def get_agent_reasoning_effort_from_config(self, agent):
            return None

    class _SessionManager:
        request_session = None

        async def ensure_working_dir(self, path):
            return None

        async def get_or_create_session_id(self, request, server):
            return "opencode-session"

        def set_request_session(self, base_session_id, session_id, directory, session_key):
            self.request_session = (session_id, directory, session_key)

        def set_agent_session_id(self, base_session_id, agent_session_id):
            return None

        def get_request_session(self, base_session_id):
            return self.request_session

        def mark_initialized(self, session_id):
            return False

    class _Sessions:
        def add_active_poll(self, **kwargs):
            snapshot = kwargs["processing_indicator"]["opencode_caller_context_env"]
            assert "AVIBE_SESSION_ID" in snapshot
            return None

        def remove_active_poll(self, session_id):
            return None

    class _PollLoop:
        async def run_prompt_poll(self, *args, **kwargs):
            poll_started.set()
            await fail_poll.wait()
            raise RuntimeError("poll coordinator failed")

    server = _Server()
    controller = SimpleNamespace(
        config=SimpleNamespace(
            platform="avibe",
            reply_enhancements=False,
            remote_access=None,
            language="en",
            opencode=SimpleNamespace(
                default_model=None,
                default_provider=None,
                default_reasoning_effort=None,
            ),
        ),
        model_hub_runtime=None,
        processing_indicator=SimpleNamespace(snapshot_request=lambda request: {}),
        get_opencode_overrides=lambda context: (None, None, None),
    )
    agent = object.__new__(OpenCodeAgent)
    agent.controller = controller
    agent.config = controller.config
    agent.sessions = _Sessions()
    agent._session_manager = _SessionManager()
    agent._poll_loop = _PollLoop()
    agent._steering_states = {}
    agent._active_requests = {}
    serve_opencode_agent(agent, server)
    agent._delete_ack = AsyncMock()
    agent._remove_ack_reaction = AsyncMock()
    agent._prepare_message_with_files = lambda request: request.message
    agent.mark_runtime_turn_started = lambda context, **kwargs: None
    agent.record_model_hub_native_failure = AsyncMock()
    monkeypatch.setattr(
        "modules.agents.opencode.agent.build_system_prompt_injection",
        lambda **kwargs: "system prompt",
    )
    binding_tokens: list[str] = []
    binding_paths: list[str] = []

    def bind_caller_context(*args, **kwargs):
        nonlocal attempts
        attempts += 1
        if attempts == 1:
            raise OSError("initial binding write failed")
        assert kwargs["extra_env"]["AVIBE_SESSION_ID"] == "avibe-session"
        loop.call_soon_threadsafe(retry_succeeded.set)
        binding_tokens.append(kwargs["binding_token"])
        binding_paths.append(kwargs["path"])
        return True

    unbound: list[tuple[str, str, str]] = []
    monkeypatch.setattr(
        "modules.agents.opencode.agent.bind_caller_context_session",
        bind_caller_context,
    )
    monkeypatch.setattr(
        "modules.agents.opencode.agent.unbind_caller_context_session",
        lambda session_id, *, binding_token, path: unbound.append(
            (session_id, binding_token, path)
        ),
    )
    backend_failure = AsyncMock()
    monkeypatch.setattr(
        "modules.agents.opencode.agent.emit_backend_failure",
        backend_failure,
    )

    process_task = asyncio.create_task(agent._process_message(primary))
    agent._active_requests[primary.base_session_id] = process_task
    await poll_started.wait()
    await asyncio.wait_for(retry_succeeded.wait(), timeout=5)
    state = agent._steering_states[primary.base_session_id]
    assert state.awaiting_user_text == prefix + primary.message
    assert state.awaiting_prompt_accepted is True
    assert state.awaiting_prompt_activity_deadline is not None
    assert state.awaiting_prompt_activity_deadline > time.monotonic()
    assert state.awaiting_active_status_observed is False
    target = ActiveSteerTarget(
        runtime_key=primary.base_session_id,
        logical_turn_id=durable.turn_id,
        context=primary.context,
        agent_request=primary,
        agent=agent,
    )
    request = _steer_request(state.native_turn_id)
    steer_task = asyncio.create_task(agent.steer_active_turn(request, target))
    await steer_started.wait()
    fail_poll.set()
    await asyncio.sleep(0)
    assert events == ["primary"]

    release_steer.set()
    receipt = await steer_task
    await process_task

    assert receipt.outcome is SteerOutcome.ACCEPTED
    assert events == ["primary", "steer", "abort"]
    assert attempts == 2
    assert len(binding_tokens) == 1
    assert binding_paths == ["/old-avibe-home/runtime/opencode_caller_context.json"]
    assert unbound == [
        (
            "opencode-session",
            binding_tokens[0],
            "/old-avibe-home/runtime/opencode_caller_context.json",
        )
    ]
    backend_failure.assert_awaited_once()