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.

324 KB
Raw Blame
"""Tests for ``core.internal_server`` — the controller-side Unix socket
ASGI app that exposes ``POST /internal/dispatch_async`` (fire-and-forget turn
dispatch) plus the turn-control surface (cancel / send-now / turn-state) for
the Web UI / CLI callers.

We exercise three layers:

1. The app's request/response shape via ``httpx.ASGITransport`` (no
   actual socket; locks the contract independent of uvicorn).
2. The fire-and-forget dispatch lifecycle: the turn is held open (in_flight)
   and its ``turn.start`` / ``turn.end`` published on the bus, the reply
   itself arriving over ``message.new`` rather than the response.
3. The boot-time socket file lifecycle (default path + chmod).
"""

from __future__ import annotations

import asyncio
import ast
import builtins
import contextlib
import inspect
import socket
import sys
import tempfile
import time
import threading
import types
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, Mock, call

import httpx
import pytest
from sqlalchemy import select, update

sys.path.insert(0, str(Path(__file__).resolve().parents[1]))

from core import internal_server, session_turns
from core.controller import Controller
from core.message_context import build_context_turn_sink_key, resolve_turn_sink_key
from core.vibe_agents import VibeAgentStore
from core.run_settlement import SETTLED_BY_STOPPED, SETTLED_BY_TERMINAL_RESULT
from core.services.agent_steering import SteerOutcome, result as steer_result
from core.services.dispatch import (
    SOURCE_HUMAN,
    SOURCE_SCHEDULED,
    TurnDispatchOutcome,
    dispatch_turn,
)
from modules.im import MessageContext
from storage import message_deliveries, resource_access_service
from vibe.authorization import AuthorizationContext


# ---------------------------------------------------------------------
# Helpers
# ---------------------------------------------------------------------

def _build_controller_double(handler=None):
    """A MagicMock controller whose ``message_handler.handle_user_message``
    can be patched to emit chunks via the real ``_stream_chunk`` hook.

    It carries a *real* turn-sink registry (not MagicMock auto-attrs) so
    ``dispatch_turn`` and ``_stream_chunk`` interoperate exactly as in
    production: dispatch_turn registers the sink, the handler's emits
    resolve it by session key, and a result emit releases the dispatch.
    """

    controller = MagicMock()
    controller.memory_read_scope_for_cli_session = lambda session_id: controller.memory_scope_for_cli_session(session_id)
    controller.message_handler = MagicMock()

    async def _handle_user_message(
        context,
        text,
        *,
        lifecycle_snapshot=None,
    ):
        payload = context.platform_specific or {}
        assert "_turn_lifecycle_admission" not in payload
        assert "_turn_lifecycle_snapshot" not in payload
        del lifecycle_snapshot
        if handler is not None:
            return await handler(context, text)
        return None

    controller.message_handler.handle_user_message = AsyncMock(
        side_effect=_handle_user_message,
    )

    sinks: dict = {}
    controller.active_turn_sinks = sinks
    controller._get_session_key = lambda ctx: f"{getattr(ctx, 'platform', None)}::{getattr(ctx, 'channel_id', None)}"
    # MUST be set explicitly: a MagicMock would auto-generate this attribute and hand
    # dispatch_turn a bogus key, so every sink lookup would miss and a refused-turn
    # test would hang in ``done.wait()`` instead of failing.
    controller._get_turn_sink_key = lambda ctx: build_context_turn_sink_key(
        ctx, session_key=controller._get_session_key(ctx)
    )

    def _register(session_key, *, on_chunk, done_event, turn_token=None, context=None):
        sinks[session_key] = {"on_chunk": on_chunk, "done_event": done_event, "turn_token": turn_token}

    controller.register_turn_sink = _register

    def _pop(session_key, done_event=None):
        s = sinks.get(session_key)
        if s is None:
            return
        if done_event is not None and s.get("done_event") is not done_event:
            return
        sinks.pop(session_key, None)

    controller.pop_turn_sink = _pop
    controller.get_turn_sink = lambda session_key: sinks.get(session_key)
    controller._session_id_from_context = lambda ctx: str(
        (getattr(ctx, "platform_specific", None) or {}).get("workbench_session_id")
        or (getattr(ctx, "platform_specific", None) or {}).get("agent_session_id")
        or ""
    ) or None

    def _mark_turn_complete(ctx, *, settled_by=None):
        manager = getattr(controller, "session_turns", None)
        if manager is not None:
            spec = getattr(ctx, "platform_specific", None) or {}
            logical_turn_id = str(spec.get("turn_token") or "")
            target = spec.get("agent_session_target") or {}
            backend = str(target.get("agent_backend") or "claude")
            if logical_turn_id:
                manager.on_native_start(
                    ctx,
                    backend=backend,
                    runtime_key=f"runtime:{logical_turn_id}",
                    runtime_turn_id=f"runtime-turn:{logical_turn_id}",
                )
        sink = sinks.get(resolve_turn_sink_key(controller, ctx))
        if sink and settled_by:
            sink.setdefault("settled_by", settled_by)
        if sink and sink.get("done_event") is not None:
            sink["done_event"].set()

    controller.mark_turn_complete = _mark_turn_complete

    # Cancel reuses the IM /stop path to interrupt the backend turn.
    controller.command_handler = MagicMock()
    controller.command_handler.handle_stop = AsyncMock(return_value=True)

    # ``_t`` returns the key verbatim so refusal chunks stay JSON-serializable
    # (a bare MagicMock would blow up ``json.dumps`` in ``_sse_event``).
    controller._t = lambda key, **kwargs: key
    controller.config = SimpleNamespace()
    # Like ``Controller.__init__``: ``create_app`` installs the real owners.
    controller.computer_script_sessions = None
    controller.computer_script_interactions = None
    return controller


def _seed_project_workdir(conn, scope_id: str, workdir: Path, *, now: str = "2026-05-31T00:00:00Z") -> None:
    from storage.models import scope_settings

    conn.execute(
        scope_settings.insert().values(
            scope_id=scope_id,
            enabled=1,
            role=None,
            workdir=str(workdir),
            agent_name=None,
            agent_backend=None,
            agent_variant=None,
            model=None,
            reasoning_effort=None,
            require_mention=None,
            settings_version=1,
            settings_json="{}",
            created_at=now,
            updated_at=now,
        )
    )


def _seed_remote_worker(*, backend: str = "claude") -> None:
    store = VibeAgentStore()
    try:
        agent = store.get("worker")
        if agent is None:
            agent = store.create(name="worker", backend=backend)
        with store.engine.begin() as conn:
            resource_access_service.ensure_resource_policy(
                conn,
                resource_kind="agent",
                resource_id=agent.id,
                organization_id="org-1",
                owner_user_id="remote-user",
                owner_email="[email protected]",
                access_level="public",
            )
    finally:
        store.close()


def _authorized_remote_message_metadata() -> dict:
    return resource_access_service.metadata_with_resource_user_context(
        {},
        AuthorizationContext(
            subject="remote-user",
            email="[email protected]",
            instance_role="editor",
            instance_access_source="organization_group",
            organization_id="org-1",
            organization_member_id="member-remote-user",
            organization_role="member",
            group_ids=frozenset({"group-engineering"}),
            claims_issued_at=int(time.time()),
            is_remote=True,
        ),
    )


def _reserve_submission(
    conn,
    *,
    scope_id: str | None,
    session_id: str,
    text: str,
    author: str = "user",
    source: str = "user",
    message_type: str = "user",
    author_name: str | None = None,
    content: dict | None = None,
    metadata: dict | None = None,
    native_message_id: str | None = None,
    message_kind: str | None = None,
    author_id: str | None = None,
):
    delivery_id = message_deliveries.new_delivery_id()
    row = message_deliveries.insert_delivery(
        conn,
        delivery_id=delivery_id,
        session_id=session_id,
        priority="p3",
        state="reserved",
        snapshot=message_deliveries.message_snapshot(
            scope_id=scope_id,
            session_id=session_id,
            platform="avibe",
            author=author,
            source=source,
            message_type=message_type,
            text=text,
            content=content,
            metadata=metadata,
            author_id=author_id,
            author_name=author_name,
            native_message_id=native_message_id,
            message_kind=message_kind,
        ),
        dispatch_text=text,
        dedupe_key=(
            f"avibe:{native_message_id}" if native_message_id else None
        ),
        history_event={"kind": "test_admission", "priority": "p3"},
    )
    return message_deliveries.delivery_payload(row)


def _create_test_session(tmp_path: Path, *, native_id: str, backend: str = "claude"):
    from core.services import sessions as sessions_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope

    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn,
            platform="avibe",
            scope_type="project",
            native_id=native_id,
            now="2026-05-31T00:00:00Z",
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session = sessions_service.create_session(
            conn,
            scope_id=scope_id,
            agent_backend=backend,
            agent_name="worker",
        )
    return engine, session


def _create_active_test_turn(
    tmp_path: Path,
    *,
    native_id: str,
    backend: str = "claude",
):
    engine, session = _create_test_session(tmp_path, native_id=native_id, backend=backend)
    with engine.begin() as conn:
        delivery = _reserve_submission(
            conn,
            scope_id=session["scope_id"],
            session_id=session["id"],
            text="active owner",
        )
        turn_id = message_deliveries.new_turn_id()
        message_deliveries.insert_turn(
            conn,
            turn_id=turn_id,
            session_id=session["id"],
            initial_delivery_id=delivery["id"],
            state="starting",
            backend=backend,
        )
        claimed = message_deliveries.open_start_attempt(
            conn,
            delivery["id"],
            expected_version=1,
            turn_id=turn_id,
            attempt_id=message_deliveries.new_attempt_id(),
        )
        assert claimed is not None
        bound = message_deliveries.bind_native_start(
            conn,
            turn_id,
            expected_version=int(message_deliveries.get_turn(conn, turn_id)["version"]),
            runtime_key=f"runtime:{session['id']}",
            runtime_turn_id=f"runtime-turn:{turn_id}",
            native_turn_id=f"native:{turn_id}",
        )
        assert bound is not None
        accepted = message_deliveries.materialize_start_acceptance(
            conn,
            turn_id=turn_id,
            evidence={"kind": "test_native_acceptance"},
        )
        assert accepted
    return engine, session, turn_id


def _bind_test_native_start(engine, context: MessageContext) -> str:
    """Simulate the narrow backend start binding bypassed by dispatch doubles."""

    turn_id = str((context.platform_specific or {}).get("turn_token") or "")
    assert turn_id
    with engine.begin() as conn:
        turn = message_deliveries.get_turn(conn, turn_id)
        assert turn is not None
        if turn["state"] == "starting":
            turn = message_deliveries.bind_native_start(
                conn,
                turn_id,
                expected_version=int(turn["version"]),
                runtime_key=f"runtime:{turn_id}",
                runtime_turn_id=f"runtime-turn:{turn_id}",
                native_turn_id=f"native:{turn_id}",
            )
            assert turn is not None
        delivery = message_deliveries.delivery_for_turn(conn, turn_id)
        assert delivery is not None
        if delivery["state"] != "accepted":
            accepted = message_deliveries.materialize_start_acceptance(
                conn,
                turn_id=turn_id,
                evidence={"kind": "test_native_acceptance"},
            )
            assert accepted
    return turn_id


def test_controller_double_omits_retired_turn_lifecycle_admission() -> None:
    async def _exercise() -> None:
        context = MessageContext(
            user_id="U",
            channel_id="C",
            platform="avibe",
            platform_specific={},
        )

        async def handler(received_context, _text):
            assert "_turn_lifecycle_admission" not in (
                received_context.platform_specific or {}
            )

        controller = _build_controller_double(handler=handler)
        await controller.message_handler.handle_user_message(context, "hello")

    asyncio.run(_exercise())


def test_running_agents_snapshot_bounds_ownership_candidates(monkeypatch) -> None:
    controller = _build_controller_double()
    captured = []

    def _snapshot(_controller, *, ownership_candidate_run_ids=None):
        captured.append(ownership_candidate_run_ids)
        return {"ok": True, "agents": [], "owned_run_ids": []}

    monkeypatch.setattr("core.services.running_agents.snapshot_running_agents", _snapshot)
    app = internal_server.create_app(controller)

    async def _exercise():
        transport = httpx.ASGITransport(app=app)
        async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
            valid = await client.post(
                "/internal/running-agents/snapshot",
                json={"run_ids": ["run-a", "run-b"]},
            )
            oversized = await client.post(
                "/internal/running-agents/snapshot",
                json={"run_ids": [f"run-{index}" for index in range(102)]},
            )
        return valid, oversized

    valid, oversized = asyncio.run(_exercise())

    assert valid.status_code == 200
    assert oversized.status_code == 400
    assert oversized.json()["error"] == "invalid_run_candidates"
    assert captured == [["run-a", "run-b"]]


# ---------------------------------------------------------------------
# Public surface
# ---------------------------------------------------------------------


def test_default_socket_path_lives_under_state_dir(monkeypatch, tmp_path):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    monkeypatch.delenv("VIBE_INTERNAL_DISPATCH_SOCKET", raising=False)
    path = internal_server.default_socket_path()
    assert path.name == "dispatch.sock"
    assert tmp_path in path.parents


def test_default_socket_path_honors_env_override(monkeypatch, tmp_path):
    target = tmp_path / "runtime" / "dispatch.sock"
    monkeypatch.setenv("VIBE_INTERNAL_DISPATCH_SOCKET", str(target))

    assert internal_server.default_socket_path() == target


def test_bind_socket_prebinds_unix_listener():
    # macOS has a short sockaddr_un limit, and pytest tmp paths can exceed it.
    with tempfile.TemporaryDirectory(prefix="vr-") as tmp:
        target = Path(tmp) / "dispatch.sock"
        listener, bound = internal_server._bind_socket(target)

        try:
            assert bound == target.resolve()
            assert target.exists()
            assert listener.family == socket.AF_UNIX
            assert listener.type == socket.SOCK_STREAM
        finally:
            listener.close()
            target.unlink(missing_ok=True)


def test_create_app_exposes_minimal_endpoints():
    app = internal_server.create_app(_build_controller_double())
    routes = {(r.path, tuple(sorted(r.methods))) for r in app.routes if hasattr(r, "methods")}
    # All interactive sources use the fire-and-forget turn entry.
    assert ("/internal/health", ("GET",)) in routes
    assert ("/internal/dispatch_async", ("POST",)) in routes
    assert ("/internal/reconcile-platforms", ("POST",)) in routes
    assert ("/internal/reconcile-agent-backends", ("POST",)) in routes
    assert ("/internal/model-hub", ("POST",)) in routes
    assert ("/internal/cancel/{session_id}", ("POST",)) in routes
    assert ("/internal/dispatch", ("POST",)) not in routes
    assert ("/internal/events", ("GET",)) in routes
    assert ("/internal/events", ("POST",)) in routes


# ---------------------------------------------------------------------
# ASGI round-trips
# ---------------------------------------------------------------------


async def _health_round_trip():
    app = internal_server.create_app(_build_controller_double())
    transport = httpx.ASGITransport(app=app)
    async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
        resp = await client.get("/internal/health")
    return resp


def test_health_endpoint(monkeypatch):
    monkeypatch.delenv("AVIBE_DESKTOP_RUNTIME_ID", raising=False)
    resp = asyncio.run(_health_round_trip())
    assert resp.status_code == 200
    assert resp.json() == {"ok": True, "service": "vibe-remote-internal", "version": 1}


def test_health_endpoint_reports_the_controller_runtime_identity(monkeypatch):
    monkeypatch.setenv("AVIBE_DESKTOP_RUNTIME_ID", "a" * 64)

    resp = asyncio.run(_health_round_trip())

    assert resp.status_code == 200
    assert resp.json() == {
        "ok": True,
        "service": "vibe-remote-internal",
        "version": 1,
        "desktop_runtime_id": "a" * 64,
    }


@pytest.mark.parametrize("env_value", [None, "1"])
def test_model_hub_rpc_uses_controller_owned_service(monkeypatch, env_value):
    if env_value is None:
        monkeypatch.delenv("VIBE_MODEL_HUB_ENABLED", raising=False)
    else:
        monkeypatch.setenv("VIBE_MODEL_HUB_ENABLED", env_value)
    controller = _build_controller_double()
    controller.model_hub_service = MagicMock()
    controller.model_hub_service.list_sources.return_value = [{"id": "src_owned"}]
    app = internal_server.create_app(controller)

    async def _go():
        transport = httpx.ASGITransport(app=app)
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            return await client.post(
                "/internal/model-hub",
                json={"operation": "list_sources", "payload": {}},
            )

    response = asyncio.run(_go())

    assert response.status_code == 200
    assert response.json() == {"ok": True, "result": [{"id": "src_owned"}]}
    controller.model_hub_service.list_sources.assert_called_once_with()


def test_model_hub_rpc_is_stably_disabled_without_touching_service(monkeypatch):
    monkeypatch.setenv("VIBE_MODEL_HUB_ENABLED", "0")
    controller = _build_controller_double()
    controller.model_hub_service = MagicMock()
    app = internal_server.create_app(controller)

    async def _go():
        transport = httpx.ASGITransport(app=app)
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            return await client.post(
                "/internal/model-hub",
                json={"operation": "list_sources", "payload": {}},
            )

    response = asyncio.run(_go())

    assert response.status_code == 404
    assert response.json() == {
        "ok": False,
        "contract_version": 1,
        "error": "feature_disabled",
    }
    assert controller.model_hub_service.mock_calls == []


def test_model_hub_dependency_rpc_remains_available_when_feature_is_disabled(monkeypatch):
    from core.handlers.model_hub.adapter import (
        EngineEnsureResult,
        EngineHealth,
        EngineStatus,
    )

    monkeypatch.setenv("VIBE_MODEL_HUB_ENABLED", "0")
    controller = _build_controller_double()
    controller.model_hub_service = None
    controller.model_hub_engine_adapter = SimpleNamespace(
        ensure_installed=AsyncMock(
            return_value=EngineEnsureResult(
                status=EngineStatus(
                    health=EngineHealth.NOT_STARTED,
                    installed_version="v7.2.149",
                    verified=True,
                    listen_host="127.0.0.1",
                    listen_port=None,
                    last_check_iso="2026-09-05T00:00:00Z",
                    host_platform="linux-amd64",
                ),
                changed=True,
            )
        )
    )
    app = internal_server.create_app(controller)

    async def _go():
        transport = httpx.ASGITransport(app=app)
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            return await client.post(
                "/internal/model-hub",
                json={
                    "operation": "runtime_ensure_dependency",
                    "payload": {"force": True, "offline": True},
                },
            )

    response = asyncio.run(_go())

    assert response.status_code == 200
    result = response.json()["result"]
    assert result["enabled"] is False
    assert result["changed"] is True
    assert result["status"]["installed_version"] == "v7.2.149"
    controller.model_hub_engine_adapter.ensure_installed.assert_awaited_once_with(
        force=True,
        offline=True,
    )


async def _publish_event_round_trip():
    from core import inbox_events

    app = internal_server.create_app(_build_controller_double())
    transport = httpx.ASGITransport(app=app)
    sub_id, queue = inbox_events.bus.subscribe()
    try:
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            resp = await client.post(
                "/internal/events",
                json={
                    "type": "vaults.updated",
                    "data": {"scope": "request", "request_id": "vreq_1", "request_status": "pending"},
                },
            )
            queue_resp = await client.post(
                "/internal/events",
                json={
                    "type": "queue.updated",
                    "data": {"session_id": "ses_queue"},
                },
            )
            definitions_resp = await client.post(
                "/internal/events",
                json={
                    "type": "definitions.updated",
                    "data": {"definition_type": "scheduled"},
                },
            )
            bad_resp = await client.post("/internal/events", json={"type": "unsupported", "data": {}})
        events = [
            await asyncio.wait_for(queue.get(), timeout=1.0),
            await asyncio.wait_for(queue.get(), timeout=1.0),
            await asyncio.wait_for(queue.get(), timeout=1.0),
        ]
        return resp, queue_resp, definitions_resp, bad_resp, events
    finally:
        inbox_events.bus.unsubscribe(sub_id)


def test_publish_event_endpoint_emits_allowlisted_bus_event():
    resp, queue_resp, definitions_resp, bad_resp, events = asyncio.run(
        _publish_event_round_trip()
    )
    assert resp.status_code == 200
    assert resp.json() == {"ok": True}
    assert queue_resp.status_code == 200
    assert queue_resp.json() == {"ok": True}
    assert definitions_resp.status_code == 200
    assert definitions_resp.json() == {"ok": True}
    assert bad_resp.status_code == 400
    assert events == [
        (
            "vaults.updated",
            {"scope": "request", "request_id": "vreq_1", "request_status": "pending"},
        ),
        ("queue.updated", {"session_id": "ses_queue"}),
        ("definitions.updated", {"definition_type": "scheduled"}),
    ]


def test_internal_events_end_a_subscriber_whose_queue_overflowed(monkeypatch):
    """The controller feed drops its reader rather than serving it a hole.

    This is the first bounded queue on the controller → UI-server → browser
    path, and a discard here is the most invisible of the three: the UI server's
    broker never sees the event, so every id downstream stays contiguous and
    every socket keeps heartbeating. Ending the stream is what turns the loss
    into a signal -- the bridge reconnects, the reconnect flips
    ``workbench.events.bridge.status``, and browsers reconcile once. Announcing
    the hole down this same stream cannot work: the queue is still full, so the
    next iteration finds another discard and announces again, starving the
    payload frames the warning was about.
    """

    from core import inbox_events

    subscriptions: list[tuple[int, asyncio.Queue]] = []
    real_subscribe = inbox_events.bus.subscribe

    def tracking_subscribe():
        # The controller handshake carries no sub_id (the browser feed's does),
        # so the test learns it the only other way available to a caller.
        subscription = real_subscribe()
        subscriptions.append(subscription)
        return subscription

    monkeypatch.setattr(inbox_events.bus, "subscribe", tracking_subscribe)
    baseline_subscribers = inbox_events.bus.subscriber_count()

    def decode(chunk) -> str:
        return chunk.decode("utf-8") if isinstance(chunk, bytes) else chunk

    async def collect_until_end() -> tuple[str, int, list[str], bool, int]:
        app = internal_server.create_app(_build_controller_double())
        route = next(
            candidate
            for candidate in app.routes
            if getattr(candidate, "path", None) == "/internal/events"
            and "GET" in (getattr(candidate, "methods", None) or set())
        )
        response = await route.endpoint()
        iterator = response.body_iterator.__aiter__()
        frames: list[str] = []
        ended = False
        try:
            handshake = decode(await iterator.__anext__())
            sub_id, queue = subscriptions[-1]
            # Park the stream inside its read loop before overflowing the queue,
            # so what this asserts is a discard the reader has to notice on a
            # later iteration -- not one already covered by the handshake it
            # just delivered.
            pending = asyncio.create_task(iterator.__anext__())
            await asyncio.sleep(0)

            for index in range(queue.maxsize + 3):
                inbox_events.bus.publish("runs.updated", {"run_id": f"run_{index}"})
            # One yield runs the whole batch of ``call_soon_threadsafe``
            # handoffs, so every discard has happened by the time the count is
            # read.
            await asyncio.sleep(0)
            dropped = inbox_events.bus.dropped_count(sub_id)

            # Bounded well below the ``maxsize`` frames still sitting in the
            # queue: a stream that kept serving them would run out of the budget
            # rather than end, which is the failure this asserts against.
            for _ in range(5):
                awaitable = pending if pending is not None else iterator.__anext__()
                pending = None
                try:
                    frames.append(decode(await asyncio.wait_for(awaitable, timeout=2)))
                except StopAsyncIteration:
                    ended = True
                    break
        finally:
            await iterator.aclose()
        # Read after the generator has exited: its ``finally`` unsubscribes, and
        # a subscription that no longer exists is owed nothing.
        return handshake, dropped, frames, ended, inbox_events.bus.subscriber_count()

    handshake, dropped, frames, ended, subscribers_after = asyncio.run(collect_until_end())

    assert "event: connected" in handshake
    assert dropped == 3
    assert ended is True
    # The queue still held ``maxsize`` events, so anything but a short tail here
    # means the reader kept relaying frames across the gap.
    assert len(frames) <= 1
    assert subscribers_after == baseline_subscribers


def test_reconcile_platforms_endpoint_calls_controller(monkeypatch):
    controller = _build_controller_double()
    calls = []

    async def reconcile_platforms(config):
        calls.append(config)
        return {"ok": True, "added": ["discord"]}

    controller.reconcile_platforms = reconcile_platforms
    monkeypatch.setattr("config.v2_config.V2Config.load", lambda: "v2-config")
    monkeypatch.setattr("config.v2_compat.to_app_config", lambda config: f"compat:{config}")
    app = internal_server.create_app(controller)

    async def _go():
        transport = httpx.ASGITransport(app=app)
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            return await client.post("/internal/reconcile-platforms")

    resp = asyncio.run(_go())

    assert resp.status_code == 200
    assert resp.json() == {"ok": True, "added": ["discord"]}
    assert calls == ["compat:v2-config"]


def test_reconcile_platforms_endpoint_reports_controller_failure(monkeypatch):
    controller = _build_controller_double()

    async def reconcile_platforms(config):
        raise RuntimeError("IM thread for discord did not stop within timeout")

    controller.reconcile_platforms = reconcile_platforms
    monkeypatch.setattr("config.v2_config.V2Config.load", lambda: "v2-config")
    monkeypatch.setattr("config.v2_compat.to_app_config", lambda config: f"compat:{config}")
    app = internal_server.create_app(controller)

    async def _go():
        transport = httpx.ASGITransport(app=app)
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            return await client.post("/internal/reconcile-platforms")

    resp = asyncio.run(_go())

    assert resp.status_code == 500
    assert resp.json() == {"ok": False, "error": "IM thread for discord did not stop within timeout"}


def test_invalidate_activity_streaming_endpoint_clears_controller_cache(monkeypatch):
    controller = _build_controller_double()
    calls: list[bool] = []
    monkeypatch.setattr(
        "core.message_mirror.reset_activity_flag_cache",
        lambda: calls.append(True),
    )
    app = internal_server.create_app(controller)

    async def _go():
        transport = httpx.ASGITransport(app=app)
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            return await client.post("/internal/invalidate-activity-streaming")

    resp = asyncio.run(_go())

    assert resp.status_code == 200
    assert resp.json() == {"ok": True}
    assert calls == [True]


def test_reconcile_agent_backends_endpoint_calls_controller():
    controller = _build_controller_double()
    calls = []

    async def reconcile_agent_backends(backends):
        calls.append(backends)
        return {
            "ok": True,
            "backends": backends,
            "states": {backend: "restarted" for backend in backends},
        }

    controller.reconcile_agent_backends = reconcile_agent_backends
    app = internal_server.create_app(controller)

    async def _go():
        transport = httpx.ASGITransport(app=app)
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            return await client.post(
                "/internal/reconcile-agent-backends",
                json={"backends": ["codex", "opencode"]},
            )

    resp = asyncio.run(_go())

    assert resp.status_code == 200
    assert resp.json()["states"] == {
        "codex": "restarted",
        "opencode": "restarted",
    }
    assert calls == [["codex", "opencode"]]


def test_reconcile_agent_backends_endpoint_rejects_invalid_shape():
    app = internal_server.create_app(_build_controller_double())

    async def _go():
        transport = httpx.ASGITransport(app=app)
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            return await client.post(
                "/internal/reconcile-agent-backends",
                json={"backends": "codex"},
            )

    resp = asyncio.run(_go())

    assert resp.status_code == 400
    assert resp.json() == {
        "ok": False,
        "error": "backends must be a list of strings",
    }


def test_backend_auth_endpoint_uses_controller_owned_service():
    controller = _build_controller_double()
    test_web_auth = AsyncMock(return_value={"ok": True, "excerpt": "hello"})
    controller.agent_auth_service = SimpleNamespace(test_web_auth=test_web_auth)
    app = internal_server.create_app(controller)

    async def _go():
        transport = httpx.ASGITransport(app=app)
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            return await client.post(
                "/internal/backend-auth/test",
                json={"backend": "Codex", "model": "gpt-5.4-mini"},
            )

    resp = asyncio.run(_go())

    assert resp.status_code == 200
    assert resp.json() == {"ok": True, "excerpt": "hello"}
    test_web_auth.assert_awaited_once_with("codex", model="gpt-5.4-mini")


def test_backend_auth_endpoint_rejects_invalid_shape():
    app = internal_server.create_app(_build_controller_double())

    async def _go():
        transport = httpx.ASGITransport(app=app)
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            return await client.post(
                "/internal/backend-auth/test",
                json={"backend": "codex", "model": ["gpt-5.4-mini"]},
            )

    resp = asyncio.run(_go())

    assert resp.status_code == 400
    assert resp.json() == {"ok": False, "error": "model must be a string"}


async def _dispatch_round_trip(body: dict) -> httpx.Response:
    app = internal_server.create_app(_build_controller_double())
    transport = httpx.ASGITransport(app=app)
    async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
        return await client.post("/internal/dispatch_async", json=body)


def test_dispatch_rejects_missing_text():
    # Payload validation runs before any turn/queue work, so a bad request 400s
    # the same way on the fire-and-forget endpoint.
    resp = asyncio.run(_dispatch_round_trip({"session_id": "s1"}))
    assert resp.status_code == 400
    payload = resp.json()
    assert payload["ok"] is False
    assert "text" in payload["error"]


@pytest.mark.parametrize("text", ["", "保留这条用户输入"])
@pytest.mark.parametrize("untrusted_field", ["type", "author", "source", "metadata"])
def test_dispatch_resume_permission_comes_only_from_durable_provenance(
    monkeypatch, tmp_path, text, untrusted_field,
):
    """Caller-forged resume fields cannot admit empty input or suppress real input.

    Adapter-only tests do not exercise the internal HTTP validator, which must
    replace every provenance field rather than merge a caller's claimed trust.
    """
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(tmp_path, native_id="resume_authority", backend="vibey")
    provenance = {
        "type": "agent_initiated", "author": "harness", "source": "harness",
        "metadata": {"vibey_resume": True},
    }
    provenance[untrusted_field] = {} if untrusted_field == "metadata" else "user"
    with engine.begin() as conn:
        reserved = _reserve_submission(
            conn, scope_id=session["scope_id"], session_id=session["id"], text=text,
            message_type=provenance["type"], author=provenance["author"],
            source=provenance["source"], metadata=provenance["metadata"],
        )
    observed = []
    controller = _build_controller_double()
    app = internal_server.create_app(controller)

    async def capture_run(_sid, context, dispatched, **_kwargs):
        observed.append((dispatched, context.platform_specific["vibey_resume"]))
        _bind_test_native_start(engine, context)

    controller.session_turns._run = capture_run

    async def dispatch():
        async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://testserver") as client:
            return await client.post("/internal/dispatch_async", json={
                "session_id": session["id"], "user_message_id": reserved["id"],
                "text": "", "type": "agent_initiated", "author": "harness", "source": "harness",
                "vibey_resume": True, "metadata": {"vibey_resume": True},
            })

    response = asyncio.run(dispatch())
    if text:
        assert response.status_code == 202
        assert observed == [(text, False)]
    else:
        assert response.status_code == 400
        assert response.json()["error"] == "text or files is required"
        assert observed == []


def test_dispatch_rejects_missing_session_id():
    resp = asyncio.run(_dispatch_round_trip({"text": "hi"}))
    assert resp.status_code == 400
    assert "session_id" in resp.json()["error"]


def test_register_turn_sink_ignores_duplicate_and_pop_is_identity_guarded():
    """Streaming turns are serialized per session (dispatch_turn rejects a
    concurrent one). As defense in depth, register_turn_sink must NOT clobber
    an in-flight sink, and pop_turn_sink must only remove the sink whose
    done_event matches the caller's — so no stale turn can satisfy or evict
    another turn's sink. The sink registry is owned by SessionTurnManager (the
    Controller methods are thin delegations)."""
    mgr = session_turns.SessionTurnManager()
    first = asyncio.Event()
    mgr.register_turn_sink("avibe::s", on_chunk=AsyncMock(), done_event=first)
    second = asyncio.Event()
    mgr.register_turn_sink("avibe::s", on_chunk=AsyncMock(), done_event=second)

    # The in-flight sink is kept; the duplicate is dropped and NOT released.
    assert mgr.active_turn_sinks["avibe::s"]["done_event"] is first
    assert not first.is_set()

    # pop is identity-guarded: a non-matching done_event is a no-op.
    mgr.pop_turn_sink("avibe::s", second)
    assert "avibe::s" in mgr.active_turn_sinks
    mgr.pop_turn_sink("avibe::s", first)
    assert "avibe::s" not in mgr.active_turn_sinks


def test_dispatch_rejects_concurrent_same_session_turn():
    """dispatch_turn serializes per session: when a streaming turn is already
    in flight (a sink is registered), a second streaming dispatch is refused
    with a terminal error chunk and never starts a competing agent turn —
    so two streams can't race over one session and cross-feed."""
    chunks: list[dict] = []

    async def on_chunk(env):
        chunks.append(env)

    handler_calls: list = []

    async def handler(ctx, text):
        handler_calls.append(text)

    controller = _build_controller_double(handler=handler)
    controller._t = lambda key, **kw: f"i18n:{key}"
    ctx = MessageContext(user_id="U", channel_id="C", platform="avibe")
    # Simulate a streaming turn already in flight for this session.
    controller.register_turn_sink(
        controller._get_session_key(ctx), on_chunk=AsyncMock(), done_event=asyncio.Event()
    )

    asyncio.run(dispatch_turn(controller, ctx, "second", on_chunk=on_chunk))

    assert handler_calls == [], "a concurrent turn must not start the agent"
    assert any(c.get("kind") == "error" for c in chunks), "a terminal error chunk must be emitted"


def test_dispatch_forwards_session_routing_into_platform_specific(monkeypatch, tmp_path):
    """Regression for the Codex P1: ``/internal/dispatch_async`` must hand the
    workbench session's agent / model / effort to ``MessageHandler`` via
    ``platform_specific["agent_session_target"]`` + ``vibe_agent_name``
    so the Chat header's chosen agent is actually used instead of the
    controller's default routing.
    """

    from core.services import sessions as sessions_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn,
            platform="avibe",
            scope_type="project",
            native_id="proj_routing",
            now="2026-05-26T13:00:00Z",
        )
        _seed_project_workdir(conn, scope_id, tmp_path, now="2026-05-26T13:00:00Z")
        session = sessions_service.create_session(
            conn,
            scope_id=scope_id,
            agent_backend="claude",
            agent_name="contract-bot",
            model="claude-sonnet-4-6",
            reasoning_effort="high",
            metadata={
                "created_via": "session_fork",
                "fork_source_session_id": "ses-source",
                "fork_source_native_session_id": "thread-source",
                "fork_source_backend": "claude",
            },
        )
        delivery = _reserve_submission(
            conn,
            scope_id=scope_id,
            session_id=session["id"],
            text="hi",
        )
    session_id = session["id"]

    captured: dict = {}

    async def capture(ctx, text):
        captured["platform_specific"] = dict(ctx.platform_specific or {})
        # Release the held turn the way a real result emit would so the
        # fire-and-forget dispatch settles promptly.
        controller.mark_turn_complete(ctx)

    controller = _build_controller_double(handler=capture)
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            resp = await client.post(
                "/internal/dispatch_async",
                json={
                    "session_id": session_id,
                    "text": "hi",
                    "user_message_id": delivery["id"],
                },
            )
            assert resp.status_code == 202
        # Fire-and-forget: wait for the background turn to run + capture.
        for _ in range(200):
            if "platform_specific" in captured and session_id not in app.state.in_flight_dispatches:
                break
            await asyncio.sleep(0.02)

    asyncio.run(_go())
    payload = captured["platform_specific"]
    assert payload.get("workbench_session_id") == session_id
    assert payload.get("vibe_agent_name") == "contract-bot"
    target = payload.get("agent_session_target") or {}
    assert target.get("agent_name") == "contract-bot"
    assert target.get("agent_backend") == "claude"
    assert target.get("model") == "claude-sonnet-4-6"
    assert target.get("reasoning_effort") == "high"
    # session_anchor is carried so resume binds by the stored anchor after a
    # restart instead of a computed avibe_<id> (Codex P2). Workbench sessions
    # self-anchor to their id.
    assert target.get("session_anchor") == session_id
    assert target.get("metadata", {}).get("fork_source_native_session_id") == "thread-source"


def test_dispatch_async_starts_turn_and_returns_202(monkeypatch, tmp_path):
    """The fire-and-forget path starts the turn and returns 202 immediately.
    It still holds the turn open (via a no-op on_chunk) so ``in_flight`` is set
    for the turn's lifetime, then released when the turn completes — the reply
    itself reaches the browser over ``message.new``, not this response.

    It also publishes the session-level ``turn.start`` / ``turn.end`` lifecycle
    on the inbox bus (the browser's working-indicator signal)."""
    from core import inbox_events
    from storage.importer import ensure_sqlite_state

    # dispatch_async reads the queue (to preserve order after a Stop), so it needs
    # an initialized state DB even on the empty-queue happy path.
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(tmp_path, native_id="proj_dispatch_start")
    with engine.begin() as conn:
        delivery = _reserve_submission(
            conn,
            scope_id=session["scope_id"],
            session_id=session["id"],
            text="hi",
        )
    session_id = session["id"]

    started = asyncio.Event()

    async def handler(ctx, text):
        started.set()
        # Release the held turn the way a real result emit would.
        controller.mark_turn_complete(ctx)
        return None

    controller = _build_controller_double(handler=handler)
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        sub_id, queue = inbox_events.bus.subscribe()
        events: list[str] = []
        try:
            async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
                resp = await client.post(
                    "/internal/dispatch_async",
                    json={
                        "session_id": session_id,
                        "text": "hi",
                        "user_message_id": delivery["id"],
                    },
                )
            await asyncio.wait_for(started.wait(), timeout=3)
            for _ in range(100):
                if session_id not in app.state.in_flight_dispatches:
                    break
                await asyncio.sleep(0.02)
            # Materialization also emits message.new; collect until the
            # lifecycle closes instead of assuming adjacent bus events.
            for _ in range(12):
                try:
                    evt, _data = await asyncio.wait_for(queue.get(), timeout=1.0)
                    events.append(evt)
                    if evt == "turn.end":
                        break
                except asyncio.TimeoutError:
                    break
        finally:
            inbox_events.bus.unsubscribe(sub_id)
        return resp, events

    resp, events = asyncio.run(_go())
    assert resp.status_code == 202
    assert resp.json()["ok"] is True
    controller.message_handler.handle_user_message.assert_awaited()
    assert session_id not in app.state.in_flight_dispatches, "slot released after the turn"
    assert [event for event in events if event.startswith("turn.")] == [
        "turn.start",
        "turn.end",
    ], "publishes session turn lifecycle on the bus"


def test_dispatch_async_stop_receipt_waits_for_terminal_evidence(monkeypatch, tmp_path):
    """There is NO turn-duration timeout (Phase 1a): a turn whose backend never
    emits a terminal result stays in_flight indefinitely — the slot is freed ONLY
    by a real terminal result or a cancel, never by any timer. A long-running
    agent can run for hours and must keep its Stop control the whole time.

    We patch ``dispatch_turn`` to a coroutine that just sleeps (never fires the
    turn's done_event), confirm the session is still held in_flight after a beat,
    then cancel to clean up.
    """
    from storage.importer import ensure_sqlite_state

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(tmp_path, native_id="proj_dispatch_long")
    with engine.begin() as conn:
        delivery = _reserve_submission(
            conn,
            scope_id=session["scope_id"],
            session_id=session["id"],
            text="hi",
        )
    session_id = session["id"]

    started = asyncio.Event()

    async def _never_settles(
        ctrl, ctx, text, *, source=SOURCE_HUMAN, on_chunk=None, **_kwargs
    ):
        # Model a long agent turn: the backend accepted the prompt but hasn't
        # produced its terminal result yet. dispatch_turn would normally hold on
        # ``await done.wait()`` with no timeout — emulate that by just sleeping so
        # the turn never settles on its own.
        started.set()
        await asyncio.sleep(60)
        return TurnDispatchOutcome(error=None, settled_by=SETTLED_BY_TERMINAL_RESULT)

    monkeypatch.setattr(session_turns, "dispatch_turn_with_outcome", _never_settles)

    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)
    captured: dict = {}

    async def _go():
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            resp = await client.post(
                "/internal/dispatch_async",
                json={
                    "session_id": session_id,
                    "text": "hi",
                    "user_message_id": delivery["id"],
                },
            )
            assert resp.status_code == 202
            await asyncio.wait_for(started.wait(), timeout=3)
            # Give any (nonexistent) timer ample time to fire, then confirm the slot
            # is STILL held — no timer auto-freed it.
            await asyncio.sleep(0.1)
            entry = app.state.in_flight_dispatches.get(session_id)
            captured["held"] = entry is not None and not entry.task.done()
            # Only a real cancel frees the slot — clean up so the loop tears down.
            resp_cancel = await client.post(f"/internal/cancel/{session_id}")
            captured["cancel_status"] = resp_cancel.status_code
            await asyncio.sleep(0.05)
            captured["held_after_stop_receipt"] = (
                session_id in app.state.in_flight_dispatches
            )
            turn = app.state.in_flight_dispatches[session_id]
            turn.task.cancel()
            await asyncio.gather(turn.task, return_exceptions=True)

    asyncio.run(_go())
    assert captured["held"] is True, "a turn with no terminal result is NOT auto-freed by any timer"
    assert captured["cancel_status"] == 200, "the user's Stop ends the wedged turn"
    assert captured["held_after_stop_receipt"] is True


def test_dispatch_async_enqueues_during_busy_turn(monkeypatch, tmp_path):
    """A dispatch for a session that already has a turn in flight ENQUEUES
    (send-while-busy) instead of refusing: it atomically re-types the
    pre-persisted user row as queued and returns 202 {queued}, and never starts
    a competing agent turn. The row flushes when the running turn ends."""
    from core.services import sessions as sessions_service

    from storage import message_deliveries, messages_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn, platform="avibe", scope_type="project", native_id="proj_enq", now="2026-05-31T00:00:00Z"
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session = sessions_service.create_session(
            conn, scope_id=scope_id, agent_backend="claude", agent_name="worker"
        )
        owner = _reserve_submission(
            conn,
            scope_id=scope_id,
            session_id=session["id"],
            text="active owner",
        )
        owner_turn_id = message_deliveries.new_turn_id()
        message_deliveries.insert_turn(
            conn,
            turn_id=owner_turn_id,
            session_id=session["id"],
            initial_delivery_id=owner["id"],
            state="active",
            backend="claude",
        )
        user_row = _reserve_submission(
            conn,
            scope_id=scope_id,
            session_id=session["id"],
            text="while busy",
        )
    session_id = session["id"]

    from core.inbox_events import bus

    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        async def _busy():
            await asyncio.sleep(60)

        task = asyncio.create_task(_busy())
        app.state.in_flight_dispatches[session_id] = session_turns.Turn(
            task=task,
            context=MessageContext(user_id="U", channel_id="C", platform="avibe"),
            logical_turn_id=owner_turn_id,
        )
        sub_id, events = bus.subscribe()
        try:
            async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
                resp = await client.post(
                    "/internal/dispatch_async",
                    json={"session_id": session_id, "text": "while busy", "user_message_id": user_row["id"]},
                )
        finally:
            task.cancel()
        # bus.publish defers delivery via loop.call_soon_threadsafe; yield so the
        # scheduled puts land before we drain.
        await asyncio.sleep(0.05)
        published = []
        while not events.empty():
            published.append(events.get_nowait())
        bus.unsubscribe(sub_id)
        return resp, published

    resp, published = asyncio.run(_go())
    assert resp.status_code == 202
    assert resp.json()["queued"] is True
    controller.message_handler.handle_user_message.assert_not_awaited()
    # Enqueue surfaces the queue growth immediately so the UI reflects it without
    # waiting for the flush (queue.updated-on-enqueue, #3336001455).
    assert ("queue.updated", {"session_id": session_id}) in published
    with engine.connect() as conn:
        # The row was atomically re-typed to queued (now out of the transcript).
        assert [q["text"] for q in message_deliveries.list_queued(conn, session_id)] == ["while busy"]
        transcript = messages_service.list_session_messages(conn, session_id=session_id, types=("user",))
    assert transcript["messages"] == []


@pytest.mark.parametrize(
    ("case", "message_kind", "metadata"),
    [
        ("answer", "original", None),
        ("invalidated", "original", None),
        ("quick_reply", "quick_reply", {"quick_reply_for": "msg_older_prompt"}),
        ("forwarded", "forwarded", None),
    ],
)
def test_dispatch_async_answers_a_pending_script_confirm_before_queuing(
    monkeypatch, tmp_path, case, message_kind, metadata
):
    """A direct Web reply during the script's own Turn reaches ``avibe.confirm``.

    The script blocks the running Turn, so an answer that queued behind it
    would deadlock until the script deadline. A "yes" that is not a direct
    original reply (a quick reply to another prompt, a forward), or any reply
    after the confirm is gone, is an ordinary send-while-busy message.
    """
    from core.computer_script_interactions import ComputerScriptInteractionError
    from core.services import sessions as sessions_service
    from storage import messages_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn, platform="avibe", scope_type="project", native_id="proj_confirm", now="2026-05-31T00:00:00Z"
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session = sessions_service.create_session(
            conn, scope_id=scope_id, agent_backend="claude", agent_name="worker"
        )
        owner = _reserve_submission(
            conn, scope_id=scope_id, session_id=session["id"], text="run the script"
        )
        owner_turn_id = message_deliveries.new_turn_id()
        message_deliveries.insert_turn(
            conn,
            turn_id=owner_turn_id,
            session_id=session["id"],
            initial_delivery_id=owner["id"],
            state="active",
            backend="claude",
        )
        reply = _reserve_submission(
            conn,
            scope_id=scope_id,
            session_id=session["id"],
            text="yes",
            author_id="owner",
            message_kind=message_kind,
            metadata=metadata,
        )
    session_id = session["id"]

    controller = _build_controller_double()
    notices: list[str] = []

    async def emit_agent_message(_context, _message_type, text, **_kwargs):
        notices.append(text)
        return f"notice-{len(notices)}"

    controller.emit_agent_message = emit_agent_message
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        task = asyncio.create_task(asyncio.sleep(60))
        controller.session_turns.in_flight[session_id] = session_turns.Turn(
            task=task,
            context=MessageContext(
                user_id="owner",
                channel_id=session_id,
                platform="avibe",
                platform_specific={"agent_session_id": session_id},
            ),
            logical_turn_id=owner_turn_id,
        )
        token = controller.computer_script_sessions.open(session_id, 30)["connection_token"]
        confirm = asyncio.create_task(
            controller.computer_script_interactions.confirm(token, "Send it?")
        )
        await asyncio.sleep(0)
        if case == "invalidated":
            controller.computer_script_interactions.invalidate_token(token, "script_turn_ended")
        try:
            async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
                resp = await asyncio.wait_for(
                    client.post(
                        "/internal/dispatch_async",
                        json={"session_id": session_id, "text": "yes", "user_message_id": reply["id"]},
                    ),
                    timeout=5,
                )
            if case in {"quick_reply", "forwarded"}:
                await asyncio.sleep(0)
                assert not confirm.done()
                confirm.cancel()
            outcome = await asyncio.wait_for(asyncio.gather(confirm, return_exceptions=True), 5)
        finally:
            controller.computer_script_sessions.close_all()
            task.cancel()
            await asyncio.gather(task, return_exceptions=True)
        return resp, outcome[0]

    resp, outcome = asyncio.run(_go())
    assert resp.status_code == 202
    controller.message_handler.handle_user_message.assert_not_awaited()
    with engine.connect() as conn:
        queued = [q["text"] for q in message_deliveries.list_queued(conn, session_id)]
        delivery = message_deliveries.get_delivery(conn, reply["id"])
        transcript = messages_service.list_session_messages(conn, session_id=session_id, types=("user",))
    assert transcript["messages"] == []
    if case == "answer":
        assert outcome["effect"] == "confirmed"
        assert resp.json()["queued"] is False
        assert delivery["state"] == "retired"
        assert queued == []
        assert notices[-1] == "computer.cli.confirm.approved"
    else:
        if case == "invalidated":
            assert isinstance(outcome, ComputerScriptInteractionError)
            assert outcome.code == "script_turn_ended"
        else:
            assert isinstance(outcome, asyncio.CancelledError)
        assert resp.json()["queued"] is True
        assert queued == ["yes"]


def test_dispatch_async_replay_of_queued_delivery_is_idempotent(monkeypatch, tmp_path):
    from storage import message_deliveries, messages_service

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(tmp_path, native_id="proj_replay_queued")
    with engine.begin() as conn:
        row = message_deliveries.enqueue_queued(
            conn,
            scope_id=session["scope_id"],
            session_id=session["id"],
            text="same show event",
        )

    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        async with httpx.AsyncClient(
            transport=transport,
            base_url="http://testserver",
        ) as client:
            return await client.post(
                "/internal/dispatch_async",
                json={
                    "session_id": session["id"],
                    "text": "same show event",
                    "user_message_id": row["id"],
                },
            )

    response = asyncio.run(_go())

    assert response.status_code == 202
    assert response.json()["duplicate"] is True
    assert response.json()["queued"] is True
    controller.message_handler.handle_user_message.assert_not_awaited()
    with engine.connect() as conn:
        transcript = messages_service.list_session_messages(
            conn,
            session_id=session["id"],
        )["messages"]
    assert transcript == []


def test_dispatch_async_starts_authorized_remote_reservation(
    monkeypatch,
    tmp_path,
):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(
        tmp_path,
        native_id="proj_remote_dispatch_reservation",
    )
    _seed_remote_worker()
    with engine.begin() as conn:
        remote = _reserve_submission(
            conn,
            scope_id=session["scope_id"],
            session_id=session["id"],
            text="remote reserved input",
            metadata=_authorized_remote_message_metadata(),
        )

    controller = None

    async def handler(context, _text):
        controller.mark_turn_complete(context)

    controller = _build_controller_double(handler)
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        async with httpx.AsyncClient(
            transport=transport,
            base_url="http://testserver",
        ) as client:
            return await client.post(
                "/internal/dispatch_async",
                json={
                    "session_id": session["id"],
                    "text": "remote reserved input",
                    "user_message_id": remote["id"],
                },
            )

    response = asyncio.run(_go())

    assert response.status_code == 202
    assert response.json()["ok"] is True
    controller.message_handler.handle_user_message.assert_awaited_once()
    with engine.connect() as conn:
        stored = message_deliveries.get_delivery(conn, remote["id"])
    assert stored is not None
    assert stored["state"] == "accepted"


def test_dispatch_async_restores_message_kind_from_reserved_delivery(
    monkeypatch,
    tmp_path,
):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(
        tmp_path,
        native_id="proj_durable_message_kind",
    )
    with engine.begin() as conn:
        reserved = _reserve_submission(
            conn,
            scope_id=session["scope_id"],
            session_id=session["id"],
            text="durable quick reply",
            message_kind="quick_reply",
        )

    observed: list[MessageContext] = []
    dispatch_kinds: list[object] = []
    build_dispatch_payload = internal_server._build_dispatch_payload

    async def observe_dispatch_payload(payload):
        dispatch_kinds.append(payload.get("message_kind"))
        return await build_dispatch_payload(payload)

    monkeypatch.setattr(
        internal_server,
        "_build_dispatch_payload",
        observe_dispatch_payload,
    )
    controller = None

    async def handler(context, _text):
        observed.append(context)
        controller.mark_turn_complete(context)

    controller = _build_controller_double(handler)
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        async with httpx.AsyncClient(
            transport=transport,
            base_url="http://testserver",
        ) as client:
            return await client.post(
                "/internal/dispatch_async",
                json={
                    "session_id": session["id"],
                    "text": "stale request text",
                    "user_message_id": reserved["id"],
                    "message_kind": "original",
                },
            )

    response = asyncio.run(_go())

    assert response.status_code == 202
    assert dispatch_kinds == ["quick_reply"]
    assert len(observed) == 1
    assert observed[0].message_kind == "quick_reply"
    assert observed[0].is_original_human_text is False


def test_dispatch_async_persists_acceptance_before_a_lost_response_replay(
    monkeypatch,
    tmp_path,
):
    from core.inbox_events import bus
    from core.services import sessions as sessions_service
    from storage import messages_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn,
            platform="avibe",
            scope_type="project",
            native_id="proj_lost_acceptance_response",
            now="2026-05-31T00:00:00Z",
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session = sessions_service.create_session(
            conn,
            scope_id=scope_id,
            agent_backend="claude",
            agent_name="worker",
        )
        row = _reserve_submission(
            conn,
            scope_id=scope_id,
            session_id=session["id"],
            author="harness",
            source="harness",
            message_type="harness",
            text="Dispatch exactly once.",
        )

    controller = None
    dispatched_text: list[str] = []

    async def handler(context, text):
        dispatched_text.append(text)
        controller.mark_turn_complete(context)

    controller = _build_controller_double(handler)
    published: list[tuple[str, dict]] = []
    monkeypatch.setattr(
        bus,
        "publish",
        lambda event_type, data: published.append((event_type, data)),
    )
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)
    payload = {
        "session_id": session["id"],
        "text": "stale caller text must not replace the reservation",
        "user_message_id": row["id"],
    }

    async def _go():
        async with httpx.AsyncClient(
            transport=transport,
            base_url="http://testserver",
        ) as client:
            first = await client.post("/internal/dispatch_async", json=payload)
            for _ in range(200):
                if session["id"] not in app.state.in_flight_dispatches:
                    break
                await asyncio.sleep(0.01)
            replay = await client.post("/internal/dispatch_async", json=payload)
        return first, replay

    first, replay = asyncio.run(_go())

    assert first.status_code == 202
    assert first.json()["delivery_state"] in {"claimed", "accepted"}
    assert replay.status_code == 202
    assert replay.json()["duplicate"] is True
    assert dispatched_text == ["Dispatch exactly once."]
    controller.message_handler.handle_user_message.assert_awaited_once()
    with engine.connect() as conn:
        settled = messages_service.get_message(conn, row["id"], session_id=session["id"])
    assert settled is not None
    assert settled["type"] == messages_service.HARNESS_TYPE
    assert [
        data["id"]
        for event_type, data in published
        if event_type == "message.new"
    ] == [row["id"]]


def test_dispatch_async_rejects_archived_session_after_reservation_reclaimed(
    monkeypatch,
    tmp_path,
):
    from core.services import sessions as sessions_service
    from storage import messages_service, workbench_sessions_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn,
            platform="avibe",
            scope_type="project",
            native_id="proj_archived_dispatch",
            now="2026-05-31T00:00:00Z",
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session = sessions_service.create_session(
            conn,
            scope_id=scope_id,
            agent_backend="claude",
            agent_name="worker",
        )
        row = _reserve_submission(
            conn,
            scope_id=scope_id,
            session_id=session["id"],
            author="harness",
            source="harness",
            message_type="harness",
            text="Do not dispatch after archive.",
        )
    with engine.begin() as conn:
        workbench_sessions_service.archive_session(conn, session["id"])

    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        async with httpx.AsyncClient(
            transport=transport,
            base_url="http://testserver",
        ) as client:
            return await client.post(
                "/internal/dispatch_async",
                json={
                    "session_id": session["id"],
                    "text": "Do not dispatch after archive.",
                    "user_message_id": row["id"],
                },
            )

    response = asyncio.run(_go())

    assert response.status_code == 409
    assert response.json()["code"] == "session_archived"
    controller.message_handler.handle_user_message.assert_not_awaited()


def test_dispatch_async_archive_after_start_does_not_reclaim_may_have_written_delivery(
    monkeypatch,
    tmp_path,
):
    from core.services import sessions as sessions_service
    from storage import messages_service, workbench_sessions_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn,
            platform="avibe",
            scope_type="project",
            native_id="proj_archive_during_submit",
            now="2026-05-31T00:00:00Z",
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session = sessions_service.create_session(
            conn,
            scope_id=scope_id,
            agent_backend="claude",
            agent_name="worker",
        )
        row = _reserve_submission(
            conn,
            scope_id=scope_id,
            session_id=session["id"],
            author="harness",
            source="harness",
            message_type="harness",
            text="Archive before acceptance.",
        )

    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    real_submit = controller.session_turns.submit

    async def submit_then_archive(*args, **kwargs):
        submission = await real_submit(*args, **kwargs)
        with engine.begin() as conn:
            workbench_sessions_service.archive_session(conn, session["id"])
        return submission

    monkeypatch.setattr(controller.session_turns, "submit", submit_then_archive)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        async with httpx.AsyncClient(
            transport=transport,
            base_url="http://testserver",
        ) as client:
            response = await client.post(
                "/internal/dispatch_async",
                json={
                    "session_id": session["id"],
                    "text": "Archive before acceptance.",
                    "user_message_id": row["id"],
                },
            )
        for _ in range(100):
            if session["id"] not in app.state.in_flight_dispatches:
                break
            await asyncio.sleep(0.01)
        return response

    response = asyncio.run(_go())

    assert response.status_code == 202
    controller.command_handler.handle_stop.assert_not_awaited()
    with engine.connect() as conn:
        delivery = message_deliveries.get_delivery(conn, row["id"])
    assert delivery is not None
    assert delivery["state"] not in {"retired", "queued", "reserved"}


def test_slow_live_show_post_cli_timeout_waits_without_duplicate_submit(
    monkeypatch,
    tmp_path,
    capsys,
):
    import json
    import threading

    from core.services import sessions as sessions_service
    from core.show_session_events import ShowSessionEventStore
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope
    from vibe import cli, internal_client, ui_server

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn,
            platform="avibe",
            scope_type="project",
            native_id="proj_show_cli_timeout",
            now="2026-05-31T00:00:00Z",
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session = sessions_service.create_session(
            conn,
            scope_id=scope_id,
            agent_backend="claude",
            agent_name="worker",
        )

    turn_started = threading.Event()

    async def handler(_context, _text):
        turn_started.set()

    controller = _build_controller_double(handler)
    internal_app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=internal_app)
    manager = controller.session_turns
    real_submit = manager.submit
    submissions = []

    async def tracked_submit(*args, **kwargs):
        submissions.append((args, kwargs))
        return await real_submit(*args, **kwargs)

    monkeypatch.setattr(manager, "submit", tracked_submit)
    dispatch_entered = threading.Event()
    release_dispatch = threading.Event()
    request_thread: threading.Thread | None = None
    request_errors: list[BaseException] = []

    async def slow_dispatch(payload, **_kwargs):
        dispatch_entered.set()
        assert await asyncio.to_thread(release_dispatch.wait, 2)
        async with httpx.AsyncClient(
            transport=transport,
            base_url="http://testserver",
        ) as client:
            response = await client.post("/internal/dispatch_async", json=payload)
        return {"status_code": response.status_code, "body": response.json()}

    monkeypatch.setattr(internal_client, "dispatch_async", slow_dispatch)

    def timeout_after_live_request(request, **_kwargs):
        nonlocal request_thread
        posted = json.loads(request.data.decode("utf-8"))

        def run_live_request():
            try:
                store = ShowSessionEventStore()
                try:
                    event = store.append(
                        session["id"],
                        posted,
                        reserve_dispatch=True,
                    )
                finally:
                    store.close()
                asyncio.run(ui_server._run_show_event_dispatch(event))
            except BaseException as exc:  # pragma: no cover - thread relay
                request_errors.append(exc)

        request_thread = threading.Thread(target=run_live_request)
        request_thread.start()
        assert dispatch_entered.wait(1)
        threading.Timer(0.1, release_dispatch.set).start()
        raise TimeoutError("CLI deadline elapsed")

    monkeypatch.setattr(cli.urllib.request, "urlopen", timeout_after_live_request)
    monkeypatch.setattr(
        cli,
        "_local_show_events_url",
        lambda session_id: f"http://127.0.0.1:5123/api/show/sessions/{session_id}/events",
    )
    monkeypatch.setattr(
        ui_server,
        "record_local_show_event",
        lambda *args, **kwargs: pytest.fail("ambiguous timeout must not use local fallback"),
    )
    event_input = {
        "id": "show_evt_slow_live_cli",
        "type": "human.annotation.created",
        "annotation": {
            "intent": "comment",
            "comment": "Wait for the original live request.",
            "dispatch": True,
        },
    }
    args = cli.build_parser().parse_args(
        [
            "show",
            "event",
            "--session-id",
            session["id"],
            "--event-json",
            json.dumps(event_input),
            "--json",
        ]
    )

    assert cli.cmd_show(args) == 0
    assert request_thread is not None
    request_thread.join(2)
    assert not request_thread.is_alive()
    assert request_errors == []
    assert len(submissions) == 1
    assert turn_started.wait(1)
    controller.message_handler.handle_user_message.assert_awaited_once()
    assert json.loads(capsys.readouterr().out)["event_id"] == event_input["id"]


@pytest.mark.parametrize(
    ("comment", "anchor", "expected_display"),
    [
        (
            "Deliver after the active turn.",
            None,
            {"direction": "user", "action": "created"},
        ),
        (
            "",
            {"text": "Busy annotation quote"},
            {
                "direction": "user",
                "action": "created",
                "quote": "Busy annotation quote",
            },
        ),
    ],
)
def test_dispatch_async_defers_show_annotation_and_runs_it_after_active_turn(
    monkeypatch,
    tmp_path,
    comment,
    anchor,
    expected_display,
):
    from core.services import sessions as sessions_service
    from core.show_session_events import ShowSessionEventStore
    from storage import messages_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn,
            platform="avibe",
            scope_type="project",
            native_id="proj_show_queue",
            now="2026-05-31T00:00:00Z",
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session = sessions_service.create_session(
            conn,
            scope_id=scope_id,
            agent_backend="claude",
            agent_name="worker",
        )
        first_delivery = _reserve_submission(
            conn,
            scope_id=scope_id,
            session_id=session["id"],
            text="active turn",
        )
    session_id = session["id"]

    first_started = asyncio.Event()
    release_first = asyncio.Event()
    seen_texts: list[str] = []

    async def handler(ctx, text):
        seen_texts.append(text)
        if text == "active turn":
            first_started.set()
            await release_first.wait()
        controller.mark_turn_complete(ctx)

    controller = _build_controller_double(handler=handler)
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            first = await client.post(
                "/internal/dispatch_async",
                json={
                    "session_id": session_id,
                    "text": "active turn",
                    "user_message_id": first_delivery["id"],
                },
            )
            assert first.status_code == 202
            await asyncio.wait_for(first_started.wait(), timeout=3)

            store = ShowSessionEventStore()
            try:
                annotation = store.append(
                    session_id,
                    {
                        "type": "human.annotation.created",
                        "annotation": {
                            "intent": "comment",
                            "comment": comment,
                            "dispatch": True,
                            **({"anchor": anchor} if anchor else {}),
                        },
                    },
                    reserve_dispatch=True,
                )
            finally:
                store.close()
            assert annotation["message"] is None
            assert annotation["delivery"]["state"] == "reserved"
            enriched_dispatch_text = annotation["delivery"]["dispatch_text"]
            assert f"Show event id: {annotation['id']}" in enriched_dispatch_text
            queued = await client.post(
                "/internal/dispatch_async",
                json={
                    "session_id": session_id,
                    "text": enriched_dispatch_text,
                    "user_message_id": annotation["delivery_id"],
                    "show_event_id": annotation["id"],
                },
            )
            assert queued.status_code == 202
            assert queued.json()["queued"] is True
            with engine.connect() as conn:
                pending = message_deliveries.get_delivery(
                    conn,
                    annotation["delivery_id"],
                )
                assert pending is not None
                assert pending["priority"] == "p1"
                assert pending["state"] == "pending_steer"
                payload = message_deliveries.delivery_payload(pending)
                assert payload["text"] == annotation["transcript_text"]
                assert pending["dispatch_text"] == enriched_dispatch_text
                visible = messages_service.list_session_messages(
                    conn,
                    session_id=session_id,
                    limit=50,
                    types=messages_service.TRANSCRIPT_TYPES,
                    tail=True,
                )
            assert visible["messages"] == []
            assert seen_texts == ["active turn"]

            release_first.set()
            for _ in range(200):
                if len(seen_texts) == 2 and session_id not in app.state.in_flight_dispatches:
                    break
                await asyncio.sleep(0.02)
            return annotation, enriched_dispatch_text

    annotation, enriched_dispatch_text = asyncio.run(_go())
    assert seen_texts == ["active turn", enriched_dispatch_text]
    with engine.connect() as conn:
        from storage.models import show_session_events

        assert message_deliveries.list_queued(conn, session_id) == []
        visible = messages_service.list_session_messages(
            conn,
            session_id=session_id,
            limit=50,
            types=messages_service.TRANSCRIPT_TYPES,
            tail=True,
        )
        linked_message_id = conn.execute(
            select(show_session_events.c.message_id).where(show_session_events.c.id == annotation["id"])
        ).scalar_one()
    assert [message["text"] for message in visible["messages"]] == [
        "active turn",
        annotation["transcript_text"],
    ]
    delivered = visible["messages"][-1]
    assert delivered["type"] == messages_service.ANNOTATION_TYPE
    assert delivered["author"] == messages_service.HARNESS_TYPE
    assert delivered["source"] == messages_service.HARNESS_TYPE
    assert delivered["author_name"] == "show_annotation"
    assert delivered["content"]["annotation"] == expected_display
    assert delivered["id"] == annotation["delivery_id"]
    assert delivered["metadata"]["source"] == "show_page"
    assert delivered["metadata"]["show_event_id"] == annotation["id"]
    assert linked_message_id == delivered["id"]


def test_startup_recovered_annotation_retries_reserved_dispatch_text(
    monkeypatch,
    tmp_path,
):
    from core.services import sessions as sessions_service
    from core.show_session_events import ShowSessionEventStore
    from storage import messages_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope
    from vibe import ui_server

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn,
            platform="avibe",
            scope_type="project",
            native_id="proj_show_sweep_flush",
            now="2026-05-31T00:00:00Z",
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session = sessions_service.create_session(
            conn,
            scope_id=scope_id,
            agent_backend="claude",
            agent_name="worker",
        )
    store = ShowSessionEventStore()
    try:
        annotation = store.append(
            session["id"],
            {
                "type": "human.annotation.created",
                "annotation": {
                    "intent": "comment",
                    "comment": "Recover and deliver this.",
                    "dispatch": True,
                    "anchor": {
                        "kind": "element",
                        "selector": "#summary",
                        "text": "Quarterly summary",
                    },
                },
            },
            reserve_dispatch=True,
        )
    finally:
        store.close()
    expected_dispatch = annotation["delivery"]["dispatch_text"]

    controller = _build_controller_double()
    internal_app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=internal_app)
    manager = controller.session_turns
    manager._build_context = lambda sid: MessageContext(
        user_id="U",
        channel_id="C",
        platform="avibe",
        platform_specific={"agent_session_id": sid},
    )
    dispatched = []

    async def capture_run(
        sid,
        context,
        text,
        *,
        source=SOURCE_HUMAN,
        logical_turn_id=None,
        **_kwargs,
    ):
        dispatched.append((sid, context.message_id, text, source))
        _bind_test_native_start(engine, context)
        manager._terminalize_durable_turn(
            logical_turn_id,
            "completed",
            settled_by=SETTLED_BY_TERMINAL_RESULT,
            evidence_kind="test_terminal",
        )

    manager._run = capture_run

    async def dispatch_through_controller(payload, **_kwargs):
        async with httpx.AsyncClient(
            transport=transport,
            base_url="http://testserver",
        ) as client:
            response = await client.post("/internal/dispatch_async", json=payload)
            await asyncio.sleep(0)
        return {"status_code": response.status_code, "body": response.json()}

    monkeypatch.setattr(
        "vibe.internal_client.dispatch_async",
        dispatch_through_controller,
    )
    outcome = asyncio.run(ui_server._run_show_event_dispatch(annotation))
    assert outcome == ui_server._ShowEventDispatchOutcome.ACCEPTED

    with engine.connect() as conn:
        queued = message_deliveries.list_queued(conn, session["id"])
        transcript = messages_service.list_session_messages(
            conn,
            session_id=session["id"],
            limit=50,
            types=messages_service.TRANSCRIPT_TYPES,
            tail=True,
        )["messages"]
    assert queued == []
    assert dispatched[0][1] == annotation["delivery_id"]
    assert dispatched[0][2] == expected_dispatch
    assert "Anchor: #summary" in dispatched[0][2]
    assert f"Show event id: {annotation['id']}" in dispatched[0][2]
    assert transcript[0]["type"] == messages_service.ANNOTATION_TYPE
    assert transcript[0]["text"] == "Recover and deliver this."
    assert transcript[0]["content"]["annotation"]["quote"] == "Quarterly summary"


def test_idle_show_p1_admission_starts_before_recovery_drain(
    monkeypatch,
    tmp_path,
):
    from core.services import sessions as sessions_service
    from core.show_session_events import ShowSessionEventStore
    from storage import messages_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.models import show_session_events
    from storage.settings_service import upsert_scope

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn,
            platform="avibe",
            scope_type="project",
            native_id="proj_show_idle_queue",
            now="2026-05-31T00:00:00Z",
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session = sessions_service.create_session(
            conn,
            scope_id=scope_id,
            agent_backend="claude",
            agent_name="worker",
        )
        older = message_deliveries.enqueue_queued(
            conn,
            scope_id=scope_id,
            session_id=session["id"],
            text="older queued message",
        )
    store = ShowSessionEventStore()
    try:
        annotation = store.append(
            session["id"],
            {
                "type": "human.annotation.created",
                "annotation": {
                    "intent": "comment",
                    "comment": "Join and drain.",
                    "dispatch": True,
                },
            },
            reserve_dispatch=True,
        )
    finally:
        store.close()

    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    manager = controller.session_turns
    manager._build_context = lambda sid: MessageContext(
        user_id="U",
        channel_id="C",
        platform="avibe",
        platform_specific={"agent_session_id": sid},
    )
    runs = []

    async def capture_run(
        sid,
        context,
        text,
        *,
        source=SOURCE_HUMAN,
        logical_turn_id=None,
        **_kwargs,
    ):
        runs.append((sid, text, source))
        _bind_test_native_start(engine, context)

    manager._run = capture_run
    transport = httpx.ASGITransport(app=app)

    async def _go():
        async with httpx.AsyncClient(
            transport=transport,
            base_url="http://testserver",
        ) as client:
            return await client.post(
                "/internal/dispatch_async",
                json={
                    "session_id": session["id"],
                    "text": annotation["delivery"]["dispatch_text"],
                    "user_message_id": annotation["delivery_id"],
                    "show_event_id": annotation["id"],
                },
            )

    response = asyncio.run(_go())

    assert response.status_code == 202
    assert response.json()["queued"] is False
    assert response.json().get("drained") is None
    assert len(runs) == 1
    assert runs[0][1] == annotation["delivery"]["dispatch_text"]
    with engine.connect() as conn:
        queued = message_deliveries.list_queued(conn, session["id"])
        linked_message_id = conn.execute(
            select(show_session_events.c.message_id).where(
                show_session_events.c.id == annotation["id"]
            )
        ).scalar_one()
        visible = messages_service.list_session_messages(
            conn,
            session_id=session["id"],
            limit=50,
            types=messages_service.TRANSCRIPT_TYPES,
            tail=True,
        )["messages"]
    assert [row["id"] for row in queued] == [older["id"]]
    assert linked_message_id == annotation["delivery_id"]
    assert [row["text"] for row in visible] == [annotation["transcript_text"]]
    assert visible[0]["id"] == annotation["delivery_id"]
    assert visible[0]["type"] == messages_service.ANNOTATION_TYPE
    assert visible[0]["author_name"] == "show_annotation"
    assert visible[0]["native_message_id"] == f"show:{annotation['id']}"
    assert asyncio.run(manager.flush_queue(session["id"])) is False


def test_flush_promoted_user_row_uses_fresh_id_for_same_second_order(
    tmp_path,
    monkeypatch,
):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    monkeypatch.setattr(
        message_deliveries,
        "new_delivery_id",
        lambda: "msg_000000000000200aaaaaaaa",
    )
    session_id = _seed_avibe_session_with_queue([("queued follow-up", None)])

    from sqlalchemy import update

    from storage import messages_service
    from storage.db import create_sqlite_engine
    from storage.models import message_deliveries as delivery_rows, messages

    with create_sqlite_engine().begin() as conn:
        queued = message_deliveries.list_queued(conn, session_id)[0]
        queued_id = queued["id"]
        conn.execute(
            update(delivery_rows)
            .where(delivery_rows.c.id == queued["id"])
            .values(submitted_at="2026-06-22T00:00:37.000000Z")
        )
        generated_ids = iter(
            (
                "msg_000000000000100aaaaaaaa",
                "msg_000000000000300aaaaaaaa",
            )
        )
        monkeypatch.setattr(messages_service, "_new_message_id", lambda: next(generated_ids))
        monkeypatch.setattr(messages_service, "_utc_now_iso", lambda: "2026-06-22T00:00:37Z")
        monkeypatch.setattr(
            message_deliveries,
            "turn_now_iso",
            lambda: "2026-06-22T00:00:37.000000Z",
        )
        result = messages_service.append(
            conn,
            scope_id=queued["scope_id"],
            session_id=session_id,
            platform="avibe",
            author="agent",
            message_type="result",
            text="preceding result",
        )
        conn.execute(
            update(messages)
            .where(messages.c.id == result["id"])
            .values(
                created_at="2026-06-22T00:00:37.000000Z",
                updated_at="2026-06-22T00:00:37.000000Z",
            )
        )

    manager, _runs = _manager_capturing_runs()
    from core.inbox_events import bus

    published = []
    monkeypatch.setattr(
        bus,
        "publish",
        lambda event_type, data: published.append((event_type, data)),
    )

    async def append_fast_result(
        sid,
        context,
        text,
        *,
        source=SOURCE_HUMAN,
        logical_turn_id=None,
        delivery_id=None,
        **_kwargs,
    ):
        _bind_test_native_start(create_sqlite_engine(), context)
        with create_sqlite_engine().begin() as conn:
            accepted = message_deliveries.materialize_start_acceptance(
                conn,
                turn_id=logical_turn_id,
                evidence={"kind": "test_native_acceptance"},
            )
            assert accepted
            messages_service.append(
                conn,
                scope_id=context.platform_specific.get("scope_id"),
                session_id=sid,
                platform="avibe",
                author="agent",
                message_type="result",
                text="fast queued result",
            )
        manager._publish_materialized_delivery(delivery_id)

    async def fail_if_sleeping(_delay):
        pytest.fail("queue promotion must not wait for wall-clock time")

    monkeypatch.setattr(session_turns.asyncio, "sleep", fail_if_sleeping)
    manager._run = append_fast_result
    assert asyncio.run(manager.flush_queue(session_id)) is True

    with create_sqlite_engine().connect() as conn:
        transcript = messages_service.list_session_messages(
            conn,
            session_id=session_id,
            types=("user", "result"),
        )
    assert [(row["type"], row["text"]) for row in transcript["messages"]] == [
        ("result", "preceding result"),
        ("user", "queued follow-up"),
        ("result", "fast queued result"),
    ]
    assert [row["created_at"] for row in transcript["messages"]] == [
        "2026-06-22T00:00:37.000000Z",
        "2026-06-22T00:00:37.000000Z",
        "2026-06-22T00:00:37.000000Z",
    ]
    assert [row["id"] for row in transcript["messages"]] == [
        "msg_000000000000100aaaaaaaa",
        "msg_000000000000200aaaaaaaa",
        "msg_000000000000300aaaaaaaa",
    ]
    assert queued_id == "msg_000000000000200aaaaaaaa"
    assert [
        (event_type, data.get("id"))
        for event_type, data in published
        if event_type == "message.new"
    ] == [("message.new", "msg_000000000000200aaaaaaaa")]
    assert not hasattr(session_turns, "_timestamp_after_latest_session_message")
    assert not hasattr(session_turns, "_wait_until_message_timestamp")


def test_flush_materializes_exact_head_and_links_delivery_dependencies(
    tmp_path,
    monkeypatch,
):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    session_id = _seed_avibe_session_with_queue(
        [
            ("canonical queued message", None),
            ("merged queued message", None),
        ]
    )

    from storage import messages_service
    from storage.db import create_sqlite_engine
    from storage.models import show_session_events

    engine = create_sqlite_engine()
    with engine.begin() as conn:
        queued = message_deliveries.list_queued(conn, session_id)
        head_id = queued[0]["id"]
        second_id = queued[1]["id"]
        for index, delivery_id in enumerate((head_id, second_id), start=1):
            conn.execute(
                show_session_events.insert().values(
                    id=f"show_evt_repoint_{index}",
                    session_id=session_id,
                    event_type="human.annotation.created",
                    actor="human",
                    scope="page",
                    anchor_json="{}",
                    payload_json="{}",
                    transcript_text=f"annotation {index}",
                    message_id=None,
                    delivery_id=delivery_id,
                    created_at=f"2026-06-22T00:00:0{index}Z",
                )
            )

    manager, _runs = _manager_accepting_runs()
    assert asyncio.run(manager.flush_queue(session_id)) is True

    with engine.connect() as conn:
        visible = messages_service.list_session_messages(
            conn,
            session_id=session_id,
            types=("user",),
        )["messages"]
        event_message_ids = conn.execute(
            select(show_session_events.c.message_id).order_by(
                show_session_events.c.id
            )
        ).scalars().all()
        queued_ids = [row["id"] for row in message_deliveries.list_queued(conn, session_id)]

    assert len(visible) == 1
    assert visible[0]["id"] == head_id
    assert event_message_ids == [head_id, head_id]
    assert queued_ids == []


def test_flush_claims_compatible_user_rows_as_one_turn_and_one_message(
    tmp_path,
    monkeypatch,
):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    session_id = _seed_avibe_session_with_queue(
        [
            ("first show annotation", None),
            ("second show annotation", None),
        ]
    )

    from storage import messages_service
    from storage.db import create_sqlite_engine
    from storage.models import show_session_events

    engine = create_sqlite_engine()
    with engine.begin() as conn:
        queued = message_deliveries.list_queued(conn, session_id)
        for index, row in enumerate(queued, start=1):
            event_id = f"show_evt_identity_{index}"
            conn.execute(
                show_session_events.insert().values(
                    id=event_id,
                    session_id=session_id,
                    event_type="human.annotation.created",
                    actor="human",
                    scope="default",
                    anchor_json="{}",
                    payload_json="{}",
                    transcript_text=row["text"],
                    message_id=None,
                    delivery_id=row["id"],
                    created_at=f"2026-06-22T00:00:0{index}Z",
                )
            )

    manager, runs = _manager_accepting_runs()
    assert asyncio.run(manager.flush_queue(session_id)) is True

    with engine.connect() as conn:
        visible = messages_service.list_session_messages(
            conn,
            session_id=session_id,
            types=("user",),
        )["messages"]
        event_links = conn.execute(
            select(show_session_events.c.id, show_session_events.c.message_id).order_by(
                show_session_events.c.id
            )
        ).all()

    assert [text for text, _source, _context in runs] == [
        "first show annotation\nsecond show annotation"
    ]
    assert len(visible) == 1
    assert event_links == [
        ("show_evt_identity_1", visible[0]["id"]),
        ("show_evt_identity_2", visible[0]["id"]),
    ]


def test_async_dispatch_flushes_one_compatible_queue_segment_on_turn_end(monkeypatch, tmp_path):
    """Natural settlement combines the compatible FIFO segment into one Turn."""
    from core.services import sessions as sessions_service
    from storage import messages_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn, platform="avibe", scope_type="project", native_id="proj_flush", now="2026-05-31T00:00:00Z"
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session = sessions_service.create_session(
            conn, scope_id=scope_id, agent_backend="claude", agent_name="worker"
        )
        first = _reserve_submission(
            conn,
            scope_id=scope_id,
            session_id=session["id"],
            text="first turn",
        )
    session_id = session["id"]

    seen_texts: list[str] = []

    async def handler(ctx, text):
        seen_texts.append(text)
        # Simulate the user queueing two messages WHILE the first turn runs (the
        # real flow — queued rows only exist during an active turn).
        if text == "first turn":
            with engine.begin() as conn:
                message_deliveries.enqueue_queued(
                    conn,
                    scope_id=scope_id,
                    session_id=session_id,
                    platform="avibe",
                    author="user",
                    source="user",
                    text="q1",
                    author_id="remote:user-a",
                    metadata={"_web_push_user_key": "remote:user-a"},
                )
                message_deliveries.enqueue_queued(
                    conn,
                    scope_id=scope_id,
                    session_id=session_id,
                    platform="avibe",
                    author="user",
                    source="user",
                    text="q2",
                    author_id="remote:user-a",
                )
        controller.mark_turn_complete(ctx)  # release each turn immediately
        return None

    controller = _build_controller_double(handler=handler)
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            await client.post(
                "/internal/dispatch_async",
                json={
                    "session_id": session_id,
                    "text": "first turn",
                    "user_message_id": first["id"],
                },
            )
        # Wait for the first turn AND the flush turn to both drain the queue.
        for _ in range(200):
            if len(seen_texts) >= 2 and session_id not in app.state.in_flight_dispatches:
                break
            await asyncio.sleep(0.02)

    asyncio.run(_go())
    assert seen_texts == ["first turn", "q1\nq2"]
    with engine.connect() as conn:
        assert message_deliveries.list_queued(conn, session_id) == []
        transcript = messages_service.list_session_messages(
            conn,
            session_id=session_id,
            types=("user",),
            include_private_metadata=True,
        )
    assert [m["text"] for m in transcript["messages"]] == ["first turn", "q1\nq2"]
    assert transcript["messages"][1]["author_id"] == "remote:user-a"
    assert transcript["messages"][1]["metadata"]["_web_push_user_key"] == "remote:user-a"


def test_cancel_resumes_the_oldest_queued_segment(monkeypatch, tmp_path):
    """Once Stop makes the Session idle, its queued work starts immediately."""
    from core.services import sessions as sessions_service
    from storage import messages_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn, platform="avibe", scope_type="project", native_id="proj_noflush", now="2026-05-31T00:00:00Z"
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session = sessions_service.create_session(
            conn, scope_id=scope_id, agent_backend="claude", agent_name="worker"
        )
        first = _reserve_submission(
            conn,
            scope_id=scope_id,
            session_id=session["id"],
            text="first",
        )
    session_id = session["id"]

    started = asyncio.Event()
    stop_requested = asyncio.Event()
    terminal_ready = asyncio.Event()
    queued_started = asyncio.Event()
    tasks: list[asyncio.Task] = []
    seen: list[str] = []

    async def long_handler(ctx, text):
        _bind_test_native_start(engine, ctx)
        tasks.append(asyncio.current_task())
        seen.append(text)
        if text == "first":
            started.set()
            await stop_requested.wait()
            await terminal_ready.wait()
            Controller.mark_turn_complete(controller, ctx, settled_by=SETTLED_BY_STOPPED)
        else:
            Controller.mark_turn_complete(controller, ctx, settled_by=SETTLED_BY_TERMINAL_RESULT)
            queued_started.set()

    async def stop_backend(ctx):
        assert ctx is app.state.in_flight_dispatches[session_id].context
        stop_requested.set()
        return True

    controller = _build_controller_double(handler=long_handler)
    controller.command_handler.handle_stop = AsyncMock(side_effect=stop_backend)
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        try:
            async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
                response = await client.post(
                    "/internal/dispatch_async",
                    json={
                        "session_id": session_id,
                        "text": "first",
                        "user_message_id": first["id"],
                    },
                )
                assert response.status_code == 202
                await asyncio.wait_for(started.wait(), timeout=3)
                turn = app.state.in_flight_dispatches[session_id]
                # A receipt alone cannot retire the active owner or start q1.
                with engine.begin() as conn:
                    message_deliveries.enqueue_queued(conn, scope_id=scope_id, session_id=session_id, text="q1")
                response = await client.post(f"/internal/cancel/{session_id}")
                assert response.status_code == 200
                assert response.json()["status"] == "cancel_requested"
                controller.command_handler.handle_stop.assert_awaited_once_with(turn.context)
                assert stop_requested.is_set()
                assert not turn.task.done()
                assert app.state.in_flight_dispatches[session_id] is turn
                assert seen == ["first"]

                terminal_ready.set()
                await asyncio.wait_for(asyncio.shield(turn.task), timeout=3)
                await asyncio.wait_for(queued_started.wait(), timeout=3)
                await asyncio.wait_for(asyncio.shield(tasks[-1]), timeout=3)
                assert all(task.done() and not task.cancelled() for task in tasks)
                assert session_id not in app.state.in_flight_dispatches
                with engine.connect() as conn:
                    stopped_turn = message_deliveries.get_turn(conn, turn.logical_turn_id)
                assert stopped_turn["terminal_outcome"] == "canceled"
        finally:
            # Failure cleanup must not manufacture the completion asserted above.
            pending = set(tasks) | {entry.task for entry in app.state.in_flight_dispatches.values()}
            for task in pending:
                if not task.done():
                    task.cancel()
            await asyncio.gather(*pending, return_exceptions=True)

    asyncio.run(_go())
    with engine.connect() as conn:
        queued = message_deliveries.list_queued(conn, session_id)
        transcript = messages_service.list_session_messages(conn, session_id=session_id, types=("user",))
    assert seen == ["first", "q1"]
    assert queued == []
    assert [row["text"] for row in transcript["messages"]] == ["first", "q1"]


def test_turn_state_reflects_in_flight():
    """``/internal/turn-state`` reports whether a turn is running, so a freshly
    loaded / reconnected Chat page can restore its Stop state."""
    controller = _build_controller_double()
    controller.agent_service.runtime_turn_started.return_value = True
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            idle = (await client.get("/internal/turn-state/ses_ts")).json()
            # Simulate an in-flight turn.
            task = asyncio.create_task(asyncio.sleep(60))
            app.state.in_flight_dispatches["ses_ts"] = session_turns.Turn(
                task=task,
                context=MessageContext(
                    user_id="U",
                    channel_id="C",
                    platform="avibe",
                    platform_specific={"agent_session_target": {"agent_backend": "opencode"}},
                ),
            )
            busy = (await client.get("/internal/turn-state/ses_ts")).json()
            task.cancel()
            return idle, busy

    idle, busy = asyncio.run(_go())
    assert idle["in_flight"] is False
    assert busy["in_flight"] is True
    assert busy["native_turn_started"] is True
    assert busy["backend"] == "opencode"


def test_turn_state_repairs_a_stale_running_projection_without_waiting_for_the_writer(tmp_path, monkeypatch):
    """#2706: ``/internal/turn-state`` clears a stale ``running`` projection only after rechecking, under SQLite's
    writer, that no turn owns the session. The endpoint runs on the controller loop, and another process may hold that
    writer for the whole busy timeout, so the repair never waits for it: while the writer is held the read answers at
    once and leaves the projection for the next read, which repairs it."""
    import sqlite3
    import threading
    import time

    from storage.models import agent_sessions

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(tmp_path, native_id="proj_turn_state_repair")
    session_id = session["id"]
    with engine.begin() as conn:
        conn.execute(
            update(agent_sessions).where(agent_sessions.c.id == session_id).values(agent_status="running")
        )
    app = internal_server.create_app(_build_controller_double())
    transport = httpx.ASGITransport(app=app)
    held, release = threading.Event(), threading.Event()

    def another_process_holds_the_writer() -> None:
        holder = sqlite3.connect(engine.url.database, timeout=10)
        try:
            holder.execute("BEGIN IMMEDIATE")
            held.set()
            release.wait(2.0)
            holder.rollback()
        finally:
            holder.close()

    def stored_status() -> str:
        with engine.connect() as conn:
            return conn.execute(
                select(agent_sessions.c.agent_status).where(agent_sessions.c.id == session_id)
            ).scalar_one()

    async def _go():
        holder = threading.Thread(target=another_process_holds_the_writer)
        holder.start()
        assert await asyncio.to_thread(held.wait, 5)
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            started = time.monotonic()
            contended = (await client.get(f"/internal/turn-state/{session_id}")).json()
            answered_in = time.monotonic() - started
            status_while_held = stored_status()
            release.set()
            await asyncio.to_thread(holder.join, 5)
            repaired = (await client.get(f"/internal/turn-state/{session_id}")).json()
        return answered_in, contended, status_while_held, repaired

    answered_in, contended, status_while_held, repaired = asyncio.run(_go())
    assert answered_in < 0.5, f"the turn-state read waited {answered_in:.2f}s for SQLite's writer on the loop"
    assert contended["in_flight"] is False and contended["recovered_agent_status"] is False
    assert status_while_held == "running"
    assert repaired["recovered_agent_status"] is True
    assert stored_status() == "idle"


def test_turn_state_projects_a_restored_durable_owner_without_in_flight(
    tmp_path,
    monkeypatch,
):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    _engine, session, turn_id = _create_active_test_turn(
        tmp_path,
        native_id="restored-turn-state",
        backend="opencode",
    )
    app = internal_server.create_app(_build_controller_double())
    transport = httpx.ASGITransport(app=app)

    async def _go():
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            return (await client.get(f"/internal/turn-state/{session['id']}")).json()

    state = asyncio.run(_go())
    assert state["in_flight"] is True
    assert state["foreground"] == "running"
    assert state["native_turn_started"] is True
    assert state["native_turn_id"] == f"native:{turn_id}"
    assert state["backend"] == "opencode"
    assert state["owner"]["runtime_key"] == f"runtime:{session['id']}"
    assert state["owner"]["native_turn_started"] is True
    assert turn_id


def test_cancel_returns_404_when_session_not_in_flight(tmp_path, monkeypatch):
    from storage.importer import ensure_sqlite_state

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    app = internal_server.create_app(_build_controller_double())
    transport = httpx.ASGITransport(app=app)

    async def _go():
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            return await client.post("/internal/cancel/ses_unknown")

    resp = asyncio.run(_go())
    assert resp.status_code == 404
    body = resp.json()
    assert body["ok"] is False
    assert body["code"] == "not_in_flight"


def test_cancel_rejects_a_blank_explicit_run_id(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session, turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_blank_run_cancel",
    )
    session_id = session["id"]
    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        async with httpx.AsyncClient(
            transport=transport,
            base_url="http://testserver",
        ) as client:
            return await client.post(
                f"/internal/cancel/{session_id}",
                params={"run_id": "   "},
            )

    response = asyncio.run(_go())

    assert response.status_code == 400
    assert response.json() == {
        "ok": False,
        "code": "invalid_run_id",
        "session_id": session_id,
        "reason": "run_id_required",
    }
    controller.command_handler.handle_stop.assert_not_awaited()
    with engine.connect() as conn:
        turn = message_deliveries.get_turn(conn, turn_id)
    assert turn is not None
    assert turn["state"] == "active"
    assert turn["control_state"] is None


def test_cancel_releases_stale_turn_when_backend_not_active(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session, turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_stale_cancel",
    )
    session_id = session["id"]
    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)
    statuses = []
    notices = []
    controller.set_agent_status = lambda session_id, status: statuses.append((session_id, status))

    async def _go():
        task = asyncio.create_task(asyncio.sleep(60))
        context = MessageContext(
            user_id="U",
            channel_id="C",
            platform="avibe",
            platform_specific={"agent_session_id": session_id},
        )
        app.state.in_flight_dispatches[session_id] = session_turns.Turn(
            task=task,
            context=context,
            logical_turn_id=turn_id,
        )

        async def _not_active(_context):
            notices.append(_context.platform_specific.get("suppress_stop_no_active_notice"))
            _context.platform_specific["stop_failure_reason"] = "not_active"
            return False

        controller.command_handler.handle_stop = AsyncMock(side_effect=_not_active)
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            resp = await client.post(f"/internal/cancel/{session_id}")
        for _ in range(200):
            if session_id not in app.state.in_flight_dispatches:
                break
            await asyncio.sleep(0.02)
        return resp, task

    resp, task = asyncio.run(_go())
    assert resp.status_code == 200
    body = resp.json()
    assert body["status"] == "stale_released"
    assert body["reason"] == "not_active"
    assert task.cancelled()
    assert session_id not in app.state.in_flight_dispatches
    assert statuses == []
    from storage.models import agent_sessions

    with engine.connect() as conn:
        status = conn.execute(
            select(agent_sessions.c.agent_status).where(agent_sessions.c.id == session_id)
        ).scalar_one()
    assert status == "idle"
    assert notices == [True]


def test_cancel_accepts_terminal_settlement_that_races_the_stop_receipt(
    tmp_path,
    monkeypatch,
):
    """HFR-431: a successful Stop may emit terminal proof before its receipt lands."""

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    _engine, session, turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_terminal_stop_race",
    )
    session_id = session["id"]
    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        task = asyncio.create_task(asyncio.sleep(60))
        context = MessageContext(
            user_id="U",
            channel_id="C",
            platform="avibe",
            platform_specific={"agent_session_id": session_id},
        )
        app.state.in_flight_dispatches[session_id] = session_turns.Turn(
            task=task,
            context=context,
            logical_turn_id=turn_id,
        )

        async def _stop_and_settle(_context):
            terminal = controller.session_turns._terminalize_durable_turn(
                turn_id,
                "canceled",
                settled_by=SETTLED_BY_STOPPED,
                evidence_kind="test_stop_terminal",
            )
            assert terminal["changed"] is True
            return True

        controller.command_handler.handle_stop = AsyncMock(
            side_effect=_stop_and_settle
        )
        async with httpx.AsyncClient(
            transport=transport,
            base_url="http://testserver",
        ) as client:
            response = await client.post(f"/internal/cancel/{session_id}")
        task.cancel()
        await asyncio.gather(task, return_exceptions=True)
        return response

    response = asyncio.run(_go())
    assert response.status_code == 200
    assert response.json() == {
        "ok": True,
        "session_id": session_id,
        "status": "stale_released",
        "reason": "already_terminal",
    }


def test_cancel_waits_for_stale_dispatch_cleanup_before_releasing(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    _engine, session, turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_stale_cleanup",
    )
    session_id = session["id"]
    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)
    controller.set_agent_status = lambda session_id, status: None

    async def _go():
        done_event = asyncio.Event()
        sink_registered = asyncio.Event()
        cleanup_started = asyncio.Event()
        allow_cleanup = asyncio.Event()

        async def _stale_dispatch():
            controller.register_turn_sink(
                resolve_turn_sink_key(controller, context),
                on_chunk=AsyncMock(),
                done_event=done_event,
                turn_token="old-turn",
            )
            sink_registered.set()
            try:
                await asyncio.Event().wait()  # only the cancel ends this dispatch
            finally:
                cleanup_started.set()
                await allow_cleanup.wait()
                controller.pop_turn_sink(resolve_turn_sink_key(controller, context), done_event)

        context = MessageContext(
            user_id="U",
            channel_id="C",
            platform="avibe",
            platform_specific={"agent_session_id": session_id},
        )
        task = asyncio.create_task(_stale_dispatch())
        registered = asyncio.create_task(sink_registered.wait())
        await asyncio.wait({task, registered}, return_when=asyncio.FIRST_COMPLETED)
        assert registered.done(), task.result()  # a dispatch that died first surfaces its error
        app.state.in_flight_dispatches[session_id] = session_turns.Turn(
            task=task,
            context=context,
            logical_turn_id=turn_id,
        )

        async def _not_active(_context):
            _context.platform_specific["stop_failure_reason"] = "not_active"
            return False

        controller.command_handler.handle_stop = AsyncMock(side_effect=_not_active)
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            cancel_task = asyncio.create_task(client.post(f"/internal/cancel/{session_id}"))
            # Ordering, not latency: the endpoint's database work before it cancels
            # the dispatch may take any time, but it must not answer first.
            cleanup_seen = asyncio.create_task(cleanup_started.wait())
            first, _ = await asyncio.wait({cancel_task, cleanup_seen}, return_when=asyncio.FIRST_COMPLETED)
            assert cleanup_seen in first and cancel_task not in first, (
                "the cancel answered before it cancelled the stale dispatch"
            )
            await asyncio.sleep(0.02)
            assert not cancel_task.done()
            assert session_id in app.state.in_flight_dispatches
            allow_cleanup.set()
            resp = await cancel_task
        return resp, task

    # A hang guard only: the ordering above is decided by events, never by this bound.
    resp, task = asyncio.run(asyncio.wait_for(_go(), timeout=30))
    assert resp.status_code == 200
    assert resp.json()["status"] == "stale_released"
    assert task.cancelled()
    assert controller.active_turn_sinks == {}


def test_cancel_keeps_turn_when_backend_interrupt_failed(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    _engine, session, turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_failed_stop",
    )
    session_id = session["id"]
    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        task = asyncio.create_task(asyncio.sleep(60))
        context = MessageContext(
            user_id="U",
            channel_id="C",
            platform="avibe",
            platform_specific={"agent_session_id": session_id},
        )
        app.state.in_flight_dispatches[session_id] = session_turns.Turn(
            task=task,
            context=context,
            logical_turn_id=turn_id,
        )

        async def _interrupt_failed(_context):
            _context.platform_specific["stop_failure_reason"] = "interrupt_failed"
            return False

        controller.command_handler.handle_stop = AsyncMock(side_effect=_interrupt_failed)
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            resp = await client.post(f"/internal/cancel/{session_id}")
        held = session_id in app.state.in_flight_dispatches and not task.done()
        task.cancel()
        return resp, held

    resp, held = asyncio.run(_go())
    assert resp.status_code == 409
    body = resp.json()
    assert body["ok"] is False
    assert body["code"] == "stop_unknown"
    assert body["reason"] == "stop_unknown"
    assert held is True


def test_release_for_backend_refresh_cancels_matching_turn_and_sets_idle():
    controller = _build_controller_double()
    manager = session_turns.SessionTurnManager(controller)
    statuses = []
    controller.set_agent_status = lambda session_id, status: statuses.append((session_id, status))

    async def _go():
        async def _busy():
            await asyncio.sleep(60)

        task = asyncio.create_task(_busy())
        ctx = MessageContext(user_id="U", channel_id="ses_codex", platform="avibe")
        ctx.platform_specific = {
            "agent_session_id": "ses_codex",
            "agent_session_target": {"agent_backend": "codex"},
        }
        manager.in_flight["ses_codex"] = session_turns.Turn(task=task, context=ctx)
        manager.begin_backend_drain("codex")

        released = await manager.release_for_backend_refresh(
            backend="codex",
            base_session_ids={"ses_codex"},
        )
        try:
            await task
        except asyncio.CancelledError:
            pass
        return released, task.cancelled()

    released, cancelled = asyncio.run(_go())

    assert released == 1
    assert cancelled is True
    assert statuses == [("ses_codex", "idle")]
    assert manager._deferred_restart_sessions == {"codex": {"ses_codex"}}


@pytest.mark.parametrize(
    ("harness", "decided_by"),
    [(False, None), (True, None), (False, "stop"), (False, "result")],
    ids=["conversation", "harness-run", "stop-in-flight", "result-already-delivered"],
)
def test_release_for_backend_refresh_names_the_interruption(harness, decided_by):
    """MH-MIG-012: a forced runtime refresh settles the turn it interrupts as a
    backend refresh even when the backend swallows the cancellation and reports
    a result-less turn, and a conversation turn tells the user why it stopped.
    A Harness run reports its own interruption, so it gets no second notice; an
    outcome already decided, by a Stop in flight or a result the runner delivered
    before finishing its cleanup, keeps its own cause and gets none either."""
    controller = _build_controller_double()
    manager = session_turns.SessionTurnManager(controller)
    controller.set_agent_status = lambda *_args: None
    notices = []

    async def _emit(context, kind, text, **_kwargs):
        notices.append((context.channel_id, kind, text))
        return "notice-1"

    controller.emit_agent_message = _emit

    async def _go():
        ctx = MessageContext(user_id="U", channel_id="ses_opencode", platform="avibe")
        ctx.platform_specific = {
            "agent_session_id": "ses_opencode",
            "agent_session_target": {"agent_backend": "opencode"},
            **({"task_execution_id": "run-1"} if harness else {}),
        }
        sink_key = resolve_turn_sink_key(controller, ctx)
        controller.register_turn_sink(sink_key, on_chunk=None, done_event=asyncio.Event())
        if decided_by == "result":
            controller.get_turn_sink(sink_key)["settled_by"] = "terminal_result"

        async def _swallows_cancellation():
            try:
                await asyncio.sleep(60)
            except asyncio.CancelledError:
                # Like the OpenCode adapter: release the waiter as result-less.
                controller.mark_turn_complete(ctx, settled_by="no_terminal_result")

        task = asyncio.create_task(_swallows_cancellation())
        await asyncio.sleep(0)
        turn = session_turns.Turn(task=task, context=ctx, logical_turn_id="turn-1")
        if decided_by == "stop":
            turn.cancel_settled_by = "stopped"
        manager.in_flight["ses_opencode"] = turn
        await manager.release_for_backend_refresh(backend="opencode", base_session_ids={"ses_opencode"})
        for _ in range(5):
            await asyncio.sleep(0)
        return controller.get_turn_sink(sink_key), turn

    sink, turn = asyncio.run(_go())

    if decided_by is not None:
        assert turn.cancel_settled_by == ("stopped" if decided_by == "stop" else None)
        assert sink["settled_by"] != "backend_refresh"
        assert notices == []
        return
    assert sink["settled_by"] == "backend_refresh"
    if harness:
        assert notices == []
    else:
        assert len(notices) == 1
        channel, kind, text = notices[0]
        assert (channel, kind) == ("ses_opencode", "notify")
        assert text.startswith("⚠️ This turn was interrupted — its Agent runtime had to be replaced")


def test_runtime_gen_006_a_disabled_backend_tells_the_turn_it_was_turned_off():
    """RUNTIME-GEN-006: disabling a backend names itself as the cause.

    The turn settles as ``backend_disabled``, not as a runtime refresh, and the
    conversation is told which backend was turned off.
    """
    controller = _build_controller_double()
    manager = session_turns.SessionTurnManager(controller)
    controller.set_agent_status = lambda *_args: None
    notices = []

    async def _emit(context, kind, text, **_kwargs):
        notices.append((context.channel_id, kind, text))
        return "notice-1"

    controller.emit_agent_message = _emit

    async def _go():
        ctx = MessageContext(user_id="U", channel_id="ses_codex", platform="avibe")
        ctx.platform_specific = {
            "agent_session_id": "ses_codex",
            "agent_session_target": {"agent_backend": "codex"},
        }
        sink_key = resolve_turn_sink_key(controller, ctx)
        controller.register_turn_sink(sink_key, on_chunk=None, done_event=asyncio.Event())
        task = asyncio.create_task(asyncio.sleep(60))
        await asyncio.sleep(0)
        manager.in_flight["ses_codex"] = session_turns.Turn(task=task, context=ctx, logical_turn_id="turn-1")
        await manager.release_for_backend_refresh(
            backend="codex", base_session_ids={"ses_codex"}, settled_by="backend_disabled"
        )
        for _ in range(5):
            await asyncio.sleep(0)
        return controller.get_turn_sink(sink_key)

    sink = asyncio.run(_go())

    assert sink["settled_by"] == "backend_disabled"
    assert [(channel, kind) for channel, kind, _text in notices] == [("ses_codex", "notify")]
    assert notices[0][2].startswith("⏹ This turn was stopped because Codex was turned off.")


def test_release_for_backend_refresh_leaves_other_backend_turn_running():
    controller = _build_controller_double()
    manager = session_turns.SessionTurnManager(controller)
    statuses = []
    controller.set_agent_status = lambda session_id, status: statuses.append((session_id, status))

    async def _go():
        async def _busy():
            await asyncio.sleep(60)

        task = asyncio.create_task(_busy())
        ctx = MessageContext(user_id="U", channel_id="ses_claude", platform="avibe")
        ctx.platform_specific = {
            "agent_session_id": "ses_claude",
            "agent_session_target": {"agent_backend": "claude"},
        }
        manager.in_flight["ses_claude"] = session_turns.Turn(task=task, context=ctx)
        try:
            released = await manager.release_for_backend_refresh(
                backend="codex",
                base_session_ids={"ses_claude"},
            )
            return released, task.done()
        finally:
            task.cancel()
            try:
                await task
            except asyncio.CancelledError:
                pass

    released, done = asyncio.run(_go())

    assert released == 0
    assert done is False
    assert statuses == []


def test_backend_drain_queues_idle_session_without_dispatching(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(
        tmp_path,
        native_id="proj_backend_drain",
        backend="codex",
    )
    session_id = session["id"]
    controller = _build_controller_double()
    manager = session_turns.SessionTurnManager(controller)
    context = MessageContext(user_id="U", channel_id=session_id, platform="avibe")
    context.platform_specific = {
        "agent_session_id": session_id,
        "scope_id": session["scope_id"],
        "agent_session_target": {"agent_backend": "codex"},
    }

    async def _go():
        manager.begin_backend_drain("codex")
        return await manager.submit(session_id, context, "next")

    result = asyncio.run(_go())

    assert result == session_turns.TurnSubmissionResult(
        route="enqueued",
        queue_persisted=True,
    )
    with engine.connect() as conn:
        assert [row["text"] for row in message_deliveries.list_queued(conn, session_id)] == ["next"]
    assert manager.is_in_flight(session_id) is False
    assert manager._deferred_restart_sessions == {"codex": {session_id}}


def test_backend_drain_queues_pre_reserved_idle_submission_before_resume(
    tmp_path,
    monkeypatch,
):
    """A Web-reserved Delivery becomes claimable before the backend drain ends."""

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(
        tmp_path,
        native_id="proj_backend_drain_reserved",
        backend="codex",
    )
    session_id = session["id"]
    with engine.begin() as conn:
        reserved = _reserve_submission(
            conn,
            scope_id=session["scope_id"],
            session_id=session_id,
            text="reserved during refresh",
        )

    controller = _build_controller_double()
    manager = session_turns.SessionTurnManager(controller)
    manager._start_persisted_turn = AsyncMock(return_value=None)
    context = MessageContext(
        user_id="U",
        channel_id=session_id,
        platform="avibe",
        platform_specific={
            "agent_session_id": session_id,
            "scope_id": session["scope_id"],
            "delivery_id": reserved["id"],
            "agent_session_target": {"agent_backend": "codex"},
        },
    )

    async def _go():
        manager.begin_backend_drain("codex")
        admitted = await manager.submit(
            session_id,
            context,
            "reserved during refresh",
        )
        with engine.connect() as conn:
            queued = message_deliveries.get_delivery(conn, reserved["id"])
        await manager.end_backend_drain("codex")
        return admitted, queued

    admitted, queued = asyncio.run(_go())

    assert admitted == session_turns.TurnSubmissionResult(
        route="enqueued",
        queue_persisted=True,
    )
    assert queued is not None and queued["state"] == "queued"
    manager._start_persisted_turn.assert_awaited_once()


def test_backend_drain_exposes_failed_queue_persistence(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    _engine, session = _create_test_session(
        tmp_path,
        native_id="proj_backend_drain_failure",
        backend="codex",
    )
    session_id = session["id"]
    controller = _build_controller_double()
    manager = session_turns.SessionTurnManager(controller)
    context = MessageContext(user_id="U", channel_id=session_id, platform="avibe")
    context.platform_specific = {
        "agent_session_id": session_id,
        "scope_id": session["scope_id"],
        "agent_session_target": {"agent_backend": "codex"},
    }
    monkeypatch.setattr(
        manager,
        "_insert_delivery",
        Mock(side_effect=RuntimeError("queue persistence failed")),
    )

    async def _go():
        manager.begin_backend_drain("codex")
        return await manager.submit(session_id, context, "next")

    with pytest.raises(RuntimeError, match="queue persistence failed"):
        asyncio.run(_go())
    assert manager.is_in_flight(session_id) is False


def test_backend_drain_resolves_inherited_default_agent_backend(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    _engine, session = _create_test_session(
        tmp_path,
        native_id="proj_backend_drain_default",
        backend="codex",
    )
    session_id = session["id"]
    controller = _build_controller_double()
    controller.resolve_agent_for_context = Mock(return_value="codex")
    manager = session_turns.SessionTurnManager(controller)
    context = MessageContext(user_id="U", channel_id=session_id, platform="avibe")
    context.platform_specific = {
        "agent_session_id": session_id,
        "scope_id": session["scope_id"],
        "agent_session_target": {"agent_name": None, "agent_backend": None},
    }

    async def _go():
        manager.begin_backend_drain("codex")
        return await manager.submit(session_id, context, "next")

    assert asyncio.run(_go()) == session_turns.TurnSubmissionResult(
        route="enqueued",
        queue_persisted=True,
    )
    assert manager._deferred_restart_sessions == {"codex": {session_id}}


@pytest.mark.no_sqlite_template
def test_backend_drain_flushes_deferred_session_after_cutover():
    controller = _build_controller_double()
    manager = session_turns.SessionTurnManager(controller)
    manager.flush_queue = AsyncMock(return_value=True)
    manager.begin_backend_drain("codex")
    manager._deferred_restart_sessions["codex"].add("ses_codex")

    asyncio.run(manager.end_backend_drain("codex"))

    manager.flush_queue.assert_awaited_once_with("ses_codex")
    assert "codex" not in manager._draining_backends


def test_backend_drain_blocks_direct_queue_flush(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(
        tmp_path,
        native_id="proj_direct_drain",
        backend="codex",
    )
    session_id = session["id"]
    with engine.begin() as conn:
        message_deliveries.enqueue_queued(
            conn,
            scope_id=session["scope_id"],
            session_id=session_id,
            text="queued",
        )
    controller = _build_controller_double()
    context = MessageContext(user_id="U", channel_id=session_id, platform="avibe")
    context.platform_specific = {
        "agent_session_id": session_id,
        "agent_session_target": {"agent_backend": "codex"},
    }
    manager = session_turns.SessionTurnManager(controller, build_context=lambda _session_id: context)
    manager._run = AsyncMock()  # type: ignore[method-assign]
    manager.begin_backend_drain("codex")

    assert asyncio.run(manager.flush_queue(session_id)) is False
    manager._run.assert_not_awaited()
    with engine.connect() as conn:
        assert [row["text"] for row in message_deliveries.list_queued(conn, session_id)] == ["queued"]
    assert manager._deferred_restart_sessions == {"codex": {session_id}}


def test_stop_during_backend_drain_keeps_existing_queue_parked(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session, turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_stop_drain",
        backend="codex",
    )
    session_id = session["id"]
    with engine.begin() as conn:
        message_deliveries.enqueue_queued(
            conn,
            scope_id=session["scope_id"],
            session_id=session_id,
            text="queued",
        )
    controller = _build_controller_double()
    manager = session_turns.SessionTurnManager(controller)
    context = MessageContext(user_id="U", channel_id=session_id, platform="avibe")
    context.platform_specific = {
        "agent_session_id": session_id,
        "agent_session_target": {"agent_backend": "codex"},
    }

    async def _go():
        task = asyncio.create_task(asyncio.sleep(60))
        manager.in_flight[session_id] = session_turns.Turn(
            task=task,
            context=context,
            logical_turn_id=turn_id,
        )
        manager.begin_backend_drain("codex")
        manager._deferred_restart_sessions["codex"].add(session_id)
        result = await manager.cancel(session_id)
        held = not task.done()
        task.cancel()
        await asyncio.gather(task, return_exceptions=True)
        return result, held

    result, held = asyncio.run(_go())

    assert result["status"] == "cancel_requested"
    assert held is True
    with engine.connect() as conn:
        assert [row["text"] for row in message_deliveries.list_queued(conn, session_id)] == ["queued"]
    assert manager._deferred_restart_sessions == {"codex": {session_id}}


# ---------------------------------------------------------------------
# Dispatcher hook contract
# ---------------------------------------------------------------------


def test_dispatch_turn_registers_sink_for_dispatcher_hook():
    """Locks the contract between ``dispatch_turn`` and the dispatcher's
    ``_stream_chunk`` helper: the streaming ``on_chunk`` is registered as a
    per-session turn sink (resolvable by session key while the turn runs)
    and cleaned up afterward — not stashed on the per-turn context.
    """

    async def on_chunk(envelope):
        pass

    seen: dict = {}

    async def capture(ctx, text):
        sink = controller.get_turn_sink(resolve_turn_sink_key(controller, ctx))
        seen["on_chunk"] = sink["on_chunk"] if sink else None
        # Release the dispatch the way a real result emit would.
        if sink:
            sink["done_event"].set()

    controller = _build_controller_double(handler=capture)
    ctx = MessageContext(user_id="U", channel_id="C", platform="avibe")
    asyncio.run(dispatch_turn(controller, ctx, "ping", on_chunk=on_chunk))
    assert seen["on_chunk"] is on_chunk
    assert controller.get_turn_sink("avibe::C") is None, "sink cleaned up after the turn"


# ---------------------------------------------------------------------
# Scheduled / watch turn gate (controller.session_turn_gate)
# ---------------------------------------------------------------------


def test_scheduled_gate_idle_runs_turn_with_lifecycle(monkeypatch, tmp_path):
    """An IDLE scheduled run goes through ``_run_turn`` like a Chat turn: it
    registers ``in_flight`` + publishes ``turn.start`` / ``turn.end`` on the bus
    (so the Chat page shows the working indicator + Stop works) and calls
    ``dispatch_turn`` with ``source=SOURCE_SCHEDULED`` and the no-op chunk sink —
    NOT ``on_chunk=None``. The sink isn't about the browser (chunks are discarded;
    avibe renders from ``message.new``); it makes ``dispatch_turn`` HOLD the turn
    open until the backend's terminal result, which keeps ``in_flight`` populated
    for the scheduled turn's whole lifetime so a Chat send can't preempt a
    still-running scheduled turn (Codex P2)."""
    from core import inbox_events
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    _engine, session = _create_test_session(
        tmp_path,
        native_id="proj_scheduled_idle",
    )
    session_id = session["id"]

    captured: dict = {}
    started = asyncio.Event()

    async def _fake_dispatch_turn(
        ctrl,
        ctx,
        text,
        *,
        source=SOURCE_HUMAN,
        on_chunk=None,
        lifecycle_snapshot=None,
    ):
        captured["lifecycle_snapshot"] = lifecycle_snapshot
        captured["source"] = source
        captured["on_chunk"] = on_chunk
        captured["text"] = text
        captured["in_flight_while_running"] = session_id in app.state.in_flight_dispatches
        started.set()
        # The manager now branches on the outcome to settle a run whose turn ended
        # without a terminal result, so a double has to return one.
        return TurnDispatchOutcome(error=None, settled_by=SETTLED_BY_TERMINAL_RESULT)

    monkeypatch.setattr(session_turns, "dispatch_turn_with_outcome", _fake_dispatch_turn)

    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    ctx = MessageContext(
        user_id="workbench",
        channel_id=session_id,
        platform="avibe",
        platform_specific={
            "agent_session_id": session_id,
            "agent_session_target": {"agent_backend": "claude"},
        },
    )

    async def _go():
        sub_id, queue = inbox_events.bus.subscribe()
        events: list[str] = []
        try:
            await controller.session_turn_gate.submit_scheduled(session_id, ctx, "digest please")
            await asyncio.wait_for(started.wait(), timeout=3)
            for _ in range(100):
                if session_id not in app.state.in_flight_dispatches:
                    break
                await asyncio.sleep(0.02)
            for _ in range(2):
                try:
                    evt, _data = await asyncio.wait_for(queue.get(), timeout=1.0)
                    events.append(evt)
                except asyncio.TimeoutError:
                    break
        finally:
            inbox_events.bus.unsubscribe(sub_id)
        return events

    events = asyncio.run(_go())
    assert captured["source"] == SOURCE_SCHEDULED, "scheduled run dispatches on the scheduler path"
    assert captured["lifecycle_snapshot"] is None
    # A scheduled run passes the no-op chunk SINK (callable, NOT None) so dispatch_turn
    # HOLDS the turn open to its terminal result — same as a Chat turn — instead of an
    # async backend returning at prompt-submit and freeing the slot (Codex P2). The sink
    # discards chunks; the reply still surfaces over ``message.new``, not a live stream.
    assert captured["on_chunk"] is not None, "scheduled run holds the turn open via the no-op sink"
    assert callable(captured["on_chunk"]), "the held-open sink is the no-op chunk callable"
    assert captured["text"] == "digest please"
    assert captured["in_flight_while_running"] is True, "registered in_flight (Stop works) while running"
    assert events == ["turn.start", "turn.end"], "publishes the session turn lifecycle on the bus"
    assert session_id not in app.state.in_flight_dispatches, "slot released after the turn"


def test_hfr_482_create_per_run_delivery_adopts_reserved_session(monkeypatch, tmp_path):
    """HFR-482: A create-per-run Run adopts its freshly reserved Session at admission."""
    from core.scheduled_tasks import TaskExecutionStore
    from core.services import sessions as sessions_service
    from storage.background import attach_agent_run_delivery_in_connection

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(
        tmp_path,
        native_id="proj_create_per_run_delivery",
    )
    session_id = session["id"]
    request_store = TaskExecutionStore()
    run = request_store.enqueue_definition_run(
        definition_id="scheduled-create-per-run",
        run_type="scheduled",
        source_kind="scheduler",
        session_key="",
        session_id=None,
        post_to=None,
        deliver_key=None,
        prompt="fresh session prompt",
        agent_name="worker",
        session_policy="create_per_run",
    )
    assert request_store.claim(run.id) is not None

    started = asyncio.Event()

    async def _fake_dispatch_turn(
        ctrl, ctx, text, *, source=SOURCE_HUMAN, on_chunk=None, **_kwargs
    ):
        started.set()
        return TurnDispatchOutcome(error=None, settled_by=SETTLED_BY_TERMINAL_RESULT)

    monkeypatch.setattr(session_turns, "dispatch_turn_with_outcome", _fake_dispatch_turn)

    controller = _build_controller_double()
    internal_server.create_app(controller)
    ctx = MessageContext(
        user_id="workbench",
        channel_id=session_id,
        platform="avibe",
        message_id=f"scheduled:scheduled-create-per-run:{run.id}",
        platform_specific={
            "agent_session_id": session_id,
            "agent_session_target": {"agent_backend": "claude"},
            "task_execution_id": run.id,
            "task_trigger_kind": "scheduled",
            "task_definition_id": "scheduled-create-per-run",
        },
    )

    async def _go():
        result = await controller.session_turn_gate.submit_scheduled(
            session_id,
            ctx,
            "fresh session prompt",
        )
        await asyncio.wait_for(started.wait(), timeout=3)
        return result

    result = asyncio.run(_go())

    assert result.delivery_owner_transferred is True
    stored = request_store.get_run(run.id)
    assert stored is not None
    assert stored["session_id"] == session_id
    assert stored["delivery_id"]
    assert stored["metadata"]["delivery_outcome"] == {
        "intent": "queue",
        "status": "claimed",
        "target_was_busy": False,
    }
    with engine.connect() as conn:
        delivery = message_deliveries.get_delivery(conn, stored["delivery_id"])
    assert delivery is not None
    assert delivery["session_id"] == session_id

    unbound_existing = request_store.enqueue_definition_run(
        definition_id="scheduled-existing",
        run_type="scheduled",
        source_kind="scheduler",
        session_key="",
        session_id=None,
        post_to=None,
        deliver_key=None,
        prompt="must not adopt",
        agent_name="worker",
        session_policy="existing",
    )
    bound_create_per_run = request_store.enqueue_definition_run(
        definition_id="scheduled-bound-create-per-run",
        run_type="scheduled",
        source_kind="scheduler",
        session_key="",
        session_id=session_id,
        post_to=None,
        deliver_key=None,
        prompt="must not rebind",
        agent_name="worker",
        session_policy="create_per_run",
    )
    with engine.begin() as conn:
        other_session = sessions_service.create_session(
            conn,
            scope_id=session["scope_id"],
            agent_backend="claude",
            agent_name="worker",
        )
        other_delivery = _reserve_submission(
            conn,
            scope_id=session["scope_id"],
            session_id=other_session["id"],
            text="foreign delivery",
        )
        assert not attach_agent_run_delivery_in_connection(
            conn,
            unbound_existing.id,
            session_id=other_session["id"],
            delivery_id=other_delivery["id"],
        )
        assert not attach_agent_run_delivery_in_connection(
            conn,
            bound_create_per_run.id,
            session_id=other_session["id"],
            delivery_id=other_delivery["id"],
        )


def test_scheduled_gate_busy_enqueues_and_leaves_chat_turn_untouched(monkeypatch, tmp_path):
    """A scheduled run for a session that already has a turn in flight ENQUEUES a
    harness-attributed ``queued`` row (so it runs AFTER the active turn via the
    existing flush) instead of preempting it — and it never starts a competing
    turn nor disturbs the in-flight Chat task (Codex P2)."""
    from core.inbox_events import bus
    from storage import messages_service

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session, owner_turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_sched_busy",
    )
    scope_id = session["scope_id"]
    session_id = session["id"]

    # A scheduled run must NEVER reach dispatch_turn while busy — a call here fails
    # the test loudly.
    async def _explode_dispatch_turn(*args, **kwargs):
        raise AssertionError("a busy scheduled run must enqueue, not dispatch a turn")

    monkeypatch.setattr(session_turns, "dispatch_turn_with_outcome", _explode_dispatch_turn)
    published: list[tuple[str, dict]] = []
    monkeypatch.setattr(
        bus,
        "publish",
        lambda event, payload: published.append((event, payload)),
    )

    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    ctx = MessageContext(
        user_id="workbench",
        channel_id=session_id,
        platform="avibe",
        message_id="watch:def-watch:scheduled-busy",
        platform_specific={
            "task_trigger_kind": "watch",
            "task_definition_id": "def-watch",
        },
    )

    async def _go():
        async def _busy():
            await asyncio.sleep(60)

        chat_task = asyncio.create_task(_busy())
        chat_ctx = MessageContext(user_id="U", channel_id="C", platform="avibe")
        app.state.in_flight_dispatches[session_id] = session_turns.Turn(
            task=chat_task,
            context=chat_ctx,
            logical_turn_id=owner_turn_id,
        )
        try:
            await controller.session_turn_gate.submit_scheduled(session_id, ctx, "scheduled while busy")
        finally:
            entry = app.state.in_flight_dispatches.get(session_id)
            # The in-flight Chat turn is undisturbed: same task object, not cancelled.
            assert entry is not None and entry.task is chat_task and not chat_task.done()
            chat_task.cancel()
        return chat_ctx

    chat_ctx = asyncio.run(_go())
    controller.message_handler.handle_user_message.assert_not_awaited()
    with engine.connect() as conn:
        queued = message_deliveries.list_queued(conn, session_id)
        # The queued row is drainable + carries the session's scope and harness
        # attribution; it stays OUT of the user transcript.
        transcript = messages_service.list_session_messages(conn, session_id=session_id, types=("user",))
    assert [q["text"] for q in queued] == ["scheduled while busy"]
    assert queued[0]["scope_id"] == scope_id
    assert queued[0]["author"] == "harness"
    assert queued[0]["author_name"] == "watch"
    assert queued[0]["author_id"] == "def-watch"
    assert [row["text"] for row in transcript["messages"]] == ["active owner"]
    assert ("queue.updated", {"session_id": session_id}) in published


def test_agent_run_send_now_steers_its_content_without_promoting_fifo(monkeypatch, tmp_path):
    """HFR-430: content-bearing send-now is P1 for that exact content."""
    from core.scheduled_tasks import TaskExecutionStore
    from core.services import sessions as sessions_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn,
            platform="avibe",
            scope_type="project",
            native_id="proj_agent_send_now",
            now="2026-07-30T00:00:00Z",
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session_id = sessions_service.create_session(
            conn,
            scope_id=scope_id,
            agent_backend="claude",
            agent_name="worker",
        )["id"]
        original = _reserve_submission(
            conn,
            scope_id=scope_id,
            session_id=session_id,
            text="original work",
        )

    request_store = TaskExecutionStore()
    request = request_store.enqueue_agent_run(
        session_id=session_id,
        message="apply the correction",
        agent_name="worker",
        delivery_intent="send_now",
    )
    assert request_store.claim(request.id) is not None
    original_started = asyncio.Event()
    seen: list[tuple[str, str]] = []

    async def _dispatch(
        ctrl, ctx, text, *, source=SOURCE_HUMAN, on_chunk=None, **_kwargs
    ):
        seen.append((text, source))
        if text == "original work":
            _bind_test_native_start(engine, ctx)
            original_started.set()
            await asyncio.sleep(60)
        return TurnDispatchOutcome(error=None, settled_by=SETTLED_BY_TERMINAL_RESULT)

    monkeypatch.setattr(session_turns, "dispatch_turn_with_outcome", _dispatch)

    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)
    controller.session_turns._steer = AsyncMock(
        return_value=steer_result(SteerOutcome.ACCEPTED)
    )

    async def _go():
        async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
            response = await client.post(
                "/internal/dispatch_async",
                json={
                    "session_id": session_id,
                    "text": "original work",
                    "user_message_id": original["id"],
                },
            )
            assert response.status_code == 202
            await asyncio.wait_for(original_started.wait(), timeout=3)
            with engine.begin() as conn:
                message_deliveries.enqueue_queued(
                    conn,
                    scope_id=scope_id,
                    session_id=session_id,
                    text="older queued input",
                )
            context = MessageContext(
                user_id="workbench",
                channel_id=session_id,
                platform="avibe",
                message_id=f"agent_run:{request.id}",
                platform_specific={
                    "task_execution_id": request.id,
                    "task_trigger_kind": "agent_run",
                    "suppress_delivery": True,
                },
            )
            result = await controller.session_turn_gate.submit_scheduled(
                session_id,
                context,
                request.message or "",
                delivery_intent="send_now",
            )
            active = app.state.in_flight_dispatches[session_id]
            assert not active.task.done()
            active.task.cancel()
            with contextlib.suppress(asyncio.CancelledError):
                await active.task
            return result

    result = asyncio.run(_go())

    assert result == session_turns.TurnSubmissionResult(
        route="ran",
        queue_persisted=True,
        target_was_busy=True,
        delivery_status="accepted",
        delivery_owner_transferred=True,
    )
    controller.command_handler.handle_stop.assert_not_awaited()
    controller.session_turns._steer.assert_awaited_once()
    assert controller.session_turns._steer.await_args.args[1].text == "apply the correction"
    assert seen == [("original work", SOURCE_HUMAN)]
    with engine.connect() as conn:
        assert [row["text"] for row in message_deliveries.list_queued(conn, session_id)] == [
            "older queued input"
        ]
    stored = request_store.get_run(request.id)
    assert stored is not None
    assert stored["metadata"]["delivery_outcome"] == {
        "intent": "steer",
        "status": "accepted",
        "target_was_busy": True,
    }


def test_agent_run_send_now_steers_a_turn_started_during_admission(monkeypatch, tmp_path):
    """A stale idle snapshot cannot downgrade explicit P1 into P3 queueing."""
    from core.scheduled_tasks import TaskExecutionStore
    from core.services import sessions as sessions_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn,
            platform="avibe",
            scope_type="project",
            native_id="proj_agent_send_now_admission_race",
            now="2026-07-30T00:00:00Z",
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session_id = sessions_service.create_session(
            conn,
            scope_id=scope_id,
            agent_backend="claude",
            agent_name="worker",
        )["id"]

    request_store = TaskExecutionStore()
    request = request_store.enqueue_agent_run(
        session_id=session_id,
        message="apply the late correction",
        agent_name="worker",
        delivery_intent="send_now",
    )
    assert request_store.claim(request.id) is not None
    controller = _build_controller_double()
    internal_server.create_app(controller)
    controller.session_turns._steer = AsyncMock(
        return_value=steer_result(SteerOutcome.ACCEPTED)
    )
    original_deliver = controller.session_turns.deliver
    inserted_racer = False

    async def _deliver_with_race(delivery_request, *, context=None):
        nonlocal inserted_racer
        if not inserted_racer:
            inserted_racer = True
            with engine.begin() as conn:
                owner = _reserve_submission(
                    conn,
                    scope_id=scope_id,
                    session_id=session_id,
                    text="racing owner",
                )
                turn_id = message_deliveries.new_turn_id()
                message_deliveries.insert_turn(
                    conn,
                    turn_id=turn_id,
                    session_id=session_id,
                    initial_delivery_id=owner["id"],
                    state="starting",
                    backend="claude",
                )
                claimed = message_deliveries.open_start_attempt(
                    conn,
                    owner["id"],
                    expected_version=1,
                    turn_id=turn_id,
                    attempt_id=message_deliveries.new_attempt_id(),
                )
                assert claimed is not None
                bound = message_deliveries.bind_native_start(
                    conn,
                    turn_id,
                    expected_version=int(
                        message_deliveries.get_turn(conn, turn_id)["version"]
                    ),
                    runtime_key=f"runtime:{session_id}",
                    runtime_turn_id=f"runtime-turn:{turn_id}",
                    native_turn_id=f"native:{turn_id}",
                )
                assert bound is not None
                accepted = message_deliveries.materialize_start_acceptance(
                    conn,
                    turn_id=turn_id,
                    evidence={"kind": "test_native_acceptance"},
                )
                assert accepted
        return await original_deliver(delivery_request, context=context)

    controller.session_turns.deliver = _deliver_with_race
    context = MessageContext(
        user_id="workbench",
        channel_id=session_id,
        platform="avibe",
        message_id=f"agent_run:{request.id}",
        platform_specific={
            "task_execution_id": request.id,
            "task_trigger_kind": "agent_run",
        },
    )

    async def _exercise():
        return await controller.session_turn_gate.submit_scheduled(
            session_id,
            context,
            request.message or "",
            delivery_intent="send_now",
        )

    result = asyncio.run(_exercise())

    assert result.target_was_busy is False
    assert result.delivery_status == "accepted"
    controller.session_turns._steer.assert_awaited_once()
    controller.command_handler.handle_stop.assert_not_awaited()
    with engine.connect() as conn:
        assert message_deliveries.list_queued(conn, session_id) == []


def test_agent_run_send_now_refusal_keeps_the_turn_and_queue(monkeypatch, tmp_path):
    """A refused interrupt is truthful and leaves both durable owners untouched."""
    from core.scheduled_tasks import TaskExecutionStore
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session, owner_turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_agent_send_now_refused",
    )
    session_id = session["id"]

    request_store = TaskExecutionStore()
    request = request_store.enqueue_agent_run(
        session_id=session_id,
        message="keep this queued",
        agent_name="worker",
        delivery_intent="send_now",
    )
    assert request_store.claim(request.id) is not None
    controller = _build_controller_double()

    async def _refuse_stop(context):
        context.platform_specific["stop_failure_reason"] = "refused"
        return False

    controller.command_handler.handle_stop = AsyncMock(side_effect=_refuse_stop)
    app = internal_server.create_app(controller)

    async def _go():
        task = asyncio.create_task(asyncio.sleep(60))
        app.state.in_flight_dispatches[session_id] = session_turns.Turn(
            task=task,
            context=MessageContext(user_id="U", channel_id=session_id, platform="avibe"),
            logical_turn_id=owner_turn_id,
        )
        context = MessageContext(
            user_id="workbench",
            channel_id=session_id,
            platform="avibe",
            message_id=f"agent_run:{request.id}",
            platform_specific={
                "task_execution_id": request.id,
                "task_trigger_kind": "agent_run",
            },
        )
        try:
            result = await controller.session_turn_gate.submit_scheduled(
                session_id,
                context,
                request.message or "",
                delivery_intent="send_now",
            )
            held = not task.done()
            return result, held
        finally:
            task.cancel()
            with contextlib.suppress(asyncio.CancelledError):
                await task

    result, held = asyncio.run(_go())

    assert result == session_turns.TurnSubmissionResult(
        route="enqueued",
        queue_persisted=True,
        target_was_busy=True,
        delivery_status="queued",
        delivery_owner_transferred=True,
    )
    assert held is True
    with engine.connect() as conn:
        queued = message_deliveries.list_queued(conn, session_id)
        assert [row["text"] for row in queued] == [
            "keep this queued"
        ]
    stored = request_store.get_run(request.id)
    assert stored is not None
    assert stored["status"] == "running"
    assert stored["delivery_id"] == queued[0]["id"]
    assert "workbench_queue_holds_run" not in stored["metadata"]
    assert stored["metadata"]["delivery_outcome"] == {
        "intent": "steer",
        "status": "queued",
        "target_was_busy": True,
    }


def test_agent_run_send_now_retry_keeps_its_refused_p3_fallback_queued(monkeypatch, tmp_path):
    """A retry does not promote a P1 Delivery after it has fallen back to P3."""
    from core.scheduled_tasks import TaskExecutionStore

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session, _owner_turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_agent_send_now_retry",
    )
    session_id = session["id"]
    request_store = TaskExecutionStore()
    request = request_store.enqueue_agent_run(
        session_id=session_id,
        message="retry this correction",
        agent_name="worker",
        delivery_intent="send_now",
    )
    assert request_store.claim(request.id) is not None
    controller = _build_controller_double()
    internal_server.create_app(controller)
    controller.session_turns._steer = AsyncMock(
        side_effect=(
            steer_result(SteerOutcome.REFUSED, reason="temporarily_unavailable"),
            steer_result(SteerOutcome.ACCEPTED),
        )
    )
    context = MessageContext(
        user_id="workbench",
        channel_id=session_id,
        platform="avibe",
        message_id=f"agent_run:{request.id}",
        platform_specific={
            "task_execution_id": request.id,
            "task_trigger_kind": "agent_run",
        },
    )

    async def _go():
        first = await controller.session_turn_gate.submit_scheduled(
            session_id,
            context,
            request.message or "",
            delivery_intent="send_now",
        )
        second = await controller.session_turn_gate.submit_scheduled(
            session_id,
            context,
            request.message or "",
            delivery_intent="send_now",
        )
        return first, second

    first, second = asyncio.run(_go())

    assert first.delivery_status == "queued"
    assert second.delivery_status == "queued"
    assert controller.session_turns._steer.await_count == 1
    with engine.connect() as conn:
        assert [row["text"] for row in message_deliveries.list_queued(conn, session_id)] == [
            "retry this correction"
        ]
    stored = request_store.get_run(request.id)
    assert stored is not None
    assert stored["metadata"]["delivery_outcome"] == {
        "intent": "steer",
        "status": "queued",
        "target_was_busy": True,
    }


def test_legacy_send_now_re_admits_unattempted_p3_delivery(monkeypatch, tmp_path):
    """An interrupted pre-cutover queue admission resumes as its own P1 content."""

    from core.scheduled_tasks import TaskExecutionStore

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session, _owner_turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_legacy_send_now_re_admission",
    )
    session_id = session["id"]
    with engine.begin() as conn:
        older = message_deliveries.enqueue_queued(
            conn,
            scope_id=session["scope_id"],
            session_id=session_id,
            text="older queued work",
        )

    request_store = TaskExecutionStore()
    request = request_store.enqueue_agent_run(
        session_id=session_id,
        message="legacy exact content",
        agent_name="worker",
        delivery_intent="queue",
    )
    assert request_store.claim(request.id) is not None
    controller = _build_controller_double()
    internal_server.create_app(controller)
    controller.session_turns._steer = AsyncMock(
        return_value=steer_result(SteerOutcome.ACCEPTED)
    )
    context = MessageContext(
        user_id="workbench",
        channel_id=session_id,
        platform="avibe",
        message_id=f"agent_run:{request.id}",
        platform_specific={
            "task_execution_id": request.id,
            "task_trigger_kind": "agent_run",
        },
    )

    async def _go():
        admitted = await controller.session_turn_gate.submit_scheduled(
            session_id,
            context,
            request.message or "",
            delivery_intent="queue",
        )
        resumed = await controller.session_turn_gate.submit_scheduled(
            session_id,
            context,
            request.message or "",
            delivery_intent="send_now",
        )
        return admitted, resumed

    admitted, resumed = asyncio.run(_go())

    assert admitted.delivery_status == "queued"
    assert resumed.delivery_status == "accepted"
    controller.session_turns._steer.assert_awaited_once()
    with engine.connect() as conn:
        queued = message_deliveries.list_queued(conn, session_id)
        stored = request_store.get_run(request.id)
        assert stored is not None
        delivery = message_deliveries.get_delivery(conn, stored["delivery_id"])
    assert [row["id"] for row in queued] == [older["id"]]
    assert delivery is not None
    assert message_deliveries.delivery_has_history_event(
        delivery,
        kind="legacy_send_now_re_admission",
    )
    assert message_deliveries.delivery_has_history_event(delivery, kind="steer")


def test_concurrent_agent_run_send_now_callers_steer_in_fifo_order(
    monkeypatch,
    tmp_path,
):
    """Concurrent send-now callers preserve FIFO and never invoke Stop."""
    from core.scheduled_tasks import TaskExecutionStore
    from core.services import sessions as sessions_service
    from storage import messages_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn,
            platform="avibe",
            scope_type="project",
            native_id="proj_agent_send_now_concurrent",
            now="2026-07-30T00:00:00Z",
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session_id = sessions_service.create_session(
            conn,
            scope_id=scope_id,
            agent_backend="claude",
            agent_name="worker",
        )["id"]
        original = _reserve_submission(
            conn,
            scope_id=scope_id,
            session_id=session_id,
            text="original work",
        )

    request_store = TaskExecutionStore()
    requests = [
        request_store.enqueue_agent_run(
            session_id=session_id,
            message=message,
            agent_name="worker",
            delivery_intent="send_now",
        )
        for message in ("first correction", "second correction")
    ]
    for request in requests:
        assert request_store.claim(request.id) is not None

    original_started = asyncio.Event()
    seen: list[str] = []

    async def _dispatch(
        ctrl, ctx, text, *, source=SOURCE_HUMAN, on_chunk=None, **_kwargs
    ):
        seen.append(text)
        _bind_test_native_start(engine, ctx)
        if text == "original work":
            original_started.set()
            await asyncio.sleep(60)
        return TurnDispatchOutcome(
            error=None,
            settled_by=SETTLED_BY_TERMINAL_RESULT,
        )

    monkeypatch.setattr(session_turns, "dispatch_turn_with_outcome", _dispatch)
    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    controller.session_turns._steer = AsyncMock(
        return_value=steer_result(SteerOutcome.ACCEPTED)
    )
    transport = httpx.ASGITransport(app=app)

    def _context(request):
        return MessageContext(
            user_id="workbench",
            channel_id=session_id,
            platform="avibe",
            message_id=f"agent_run:{request.id}",
            platform_specific={
                "task_execution_id": request.id,
                "task_trigger_kind": "agent_run",
            },
        )

    async def _go():
        async with httpx.AsyncClient(
            transport=transport,
            base_url="http://testserver",
        ) as client:
            response = await client.post(
                "/internal/dispatch_async",
                json={
                    "session_id": session_id,
                    "text": "original work",
                    "user_message_id": original["id"],
                },
            )
            assert response.status_code == 202
            await asyncio.wait_for(original_started.wait(), timeout=3)
            submissions = [
                asyncio.create_task(
                    controller.session_turn_gate.submit_scheduled(
                        session_id,
                        _context(request),
                        request.message or "",
                        delivery_intent="send_now",
                    )
                )
                for request in requests
            ]
            results = await asyncio.gather(*submissions)
            active = app.state.in_flight_dispatches[session_id]
            assert not active.task.done()
            active.task.cancel()
            with contextlib.suppress(asyncio.CancelledError):
                await active.task
            return results

    results = asyncio.run(_go())

    controller.command_handler.handle_stop.assert_not_awaited()
    assert controller.session_turns._steer.await_count == 2
    assert [result.delivery_status for result in results] == [
        "accepted",
        "accepted",
    ]
    assert all(result.route == "ran" for result in results)
    assert all(result.queue_persisted is True for result in results)
    assert all(result.target_was_busy is True for result in results)
    assert all(result.delivery_owner_transferred is True for result in results)
    assert seen == ["original work"]
    with engine.connect() as conn:
        assert message_deliveries.list_queued(conn, session_id) == []
    for request, expected_status in zip(
        requests,
        ("accepted", "accepted"),
        strict=True,
    ):
        stored = request_store.get_run(request.id)
        assert stored is not None
        assert stored["metadata"]["delivery_outcome"] == {
            "intent": "steer",
            "status": expected_status,
            "target_was_busy": True,
        }


def test_agent_run_send_now_restart_preserves_refused_queue_behind_durable_owner(
    monkeypatch,
    tmp_path,
):
    """Restart neither replays Stop nor bypasses the still-active durable owner."""
    from core.scheduled_tasks import TaskExecutionStore

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session, owner_turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_agent_send_now_restart",
    )
    session_id = session["id"]

    request_store = TaskExecutionStore()
    request = request_store.enqueue_agent_run(
        session_id=session_id,
        message="recover after restart",
        agent_name="worker",
        delivery_intent="send_now",
    )
    assert request_store.claim(request.id) is not None
    first_controller = _build_controller_double()

    async def _refuse_stop(stop_context):
        stop_context.platform_specific["stop_failure_reason"] = "refused"
        return False

    first_controller.command_handler.handle_stop = AsyncMock(side_effect=_refuse_stop)
    first_app = internal_server.create_app(first_controller)
    context = MessageContext(
        user_id="workbench",
        channel_id=session_id,
        platform="avibe",
        message_id=f"agent_run:{request.id}",
        platform_specific={
            "task_execution_id": request.id,
            "task_trigger_kind": "agent_run",
        },
    )

    async def _admit_then_restart():
        task = asyncio.create_task(asyncio.sleep(60))
        first_app.state.in_flight_dispatches[session_id] = session_turns.Turn(
            task=task,
            context=MessageContext(
                user_id="U",
                channel_id=session_id,
                platform="avibe",
            ),
            logical_turn_id=owner_turn_id,
        )
        try:
            result = await first_controller.session_turn_gate.submit_scheduled(
                session_id,
                context,
                request.message or "",
                delivery_intent="send_now",
            )
        finally:
            task.cancel()
            with contextlib.suppress(asyncio.CancelledError):
                await task
        return result

    admitted = asyncio.run(_admit_then_restart())
    assert admitted.delivery_status == "queued"
    with engine.connect() as conn:
        assert [row["text"] for row in message_deliveries.list_queued(conn, session_id)] == [
            "recover after restart"
        ]

    seen: list[str] = []

    async def _dispatch(
        ctrl, ctx, text, *, source=SOURCE_HUMAN, on_chunk=None, **_kwargs
    ):
        seen.append(text)
        return TurnDispatchOutcome(
            error=None,
            settled_by=SETTLED_BY_TERMINAL_RESULT,
        )

    monkeypatch.setattr(session_turns, "dispatch_turn_with_outcome", _dispatch)
    second_controller = _build_controller_double()
    internal_server.create_app(second_controller)

    async def _recover():
        recovered = await second_controller.session_turns.recover_persisted_agent_run_queue(
            session_id
        )
        for _ in range(200):
            if session_id not in second_controller.session_turns.in_flight:
                break
            await asyncio.sleep(0.01)
        return recovered

    recovered = asyncio.run(_recover())

    assert recovered == []
    assert seen == []
    second_controller.command_handler.handle_stop.assert_not_awaited()
    with engine.connect() as conn:
        assert [row["text"] for row in message_deliveries.list_queued(conn, session_id)] == [
            "recover after restart"
        ]
    stored = request_store.get_run(request.id)
    assert stored is not None
    assert stored["metadata"]["delivery_intent"] == "steer"
    assert stored["metadata"]["delivery_outcome"]["status"] == "queued"


def test_agent_run_send_now_on_an_idle_backlog_starts_its_own_content(monkeypatch, tmp_path):
    """Content-bearing P1 starts itself and leaves an older P3 head queued."""
    from core.scheduled_tasks import TaskExecutionStore
    from core.services import sessions as sessions_service
    from storage import messages_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn,
            platform="avibe",
            scope_type="project",
            native_id="proj_agent_send_now_idle",
            now="2026-07-30T00:00:00Z",
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session_id = sessions_service.create_session(
            conn,
            scope_id=scope_id,
            agent_backend="claude",
            agent_name="worker",
        )["id"]
        message_deliveries.enqueue_queued(
            conn,
            scope_id=scope_id,
            session_id=session_id,
            text="older queued input",
        )

    request_store = TaskExecutionStore()
    request = request_store.enqueue_agent_run(
        session_id=session_id,
        message="new urgent input",
        agent_name="worker",
        delivery_intent="send_now",
    )
    assert request_store.claim(request.id) is not None
    seen: list[str] = []

    async def _dispatch(
        ctrl, ctx, text, *, source=SOURCE_HUMAN, on_chunk=None, **_kwargs
    ):
        seen.append(text)
        return TurnDispatchOutcome(error=None, settled_by=SETTLED_BY_TERMINAL_RESULT)

    monkeypatch.setattr(session_turns, "dispatch_turn_with_outcome", _dispatch)
    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    context = MessageContext(
        user_id="workbench",
        channel_id=session_id,
        platform="avibe",
        message_id=f"agent_run:{request.id}",
        platform_specific={
            "task_execution_id": request.id,
            "task_trigger_kind": "agent_run",
        },
    )

    async def _go():
        result = await controller.session_turn_gate.submit_scheduled(
            session_id,
            context,
            request.message or "",
            delivery_intent="send_now",
        )
        for _ in range(300):
            if len(seen) == 1:
                break
            await asyncio.sleep(0.01)
        return result

    result = asyncio.run(_go())

    assert result == session_turns.TurnSubmissionResult(
        route="ran",
        queue_persisted=True,
        target_was_busy=False,
        delivery_status="claimed",
        delivery_owner_transferred=True,
    )
    assert seen == ["new urgent input"]
    with engine.connect() as conn:
        assert [row["text"] for row in message_deliveries.list_queued(conn, session_id)] == [
            "older queued input"
        ]
    controller.command_handler.handle_stop.assert_not_awaited()


def test_agent_run_send_now_idle_start_failure_is_reconciled_without_replay(
    monkeypatch,
    tmp_path,
):
    from core.scheduled_tasks import TaskExecutionStore
    from core.services import sessions as sessions_service
    from storage import messages_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn,
            platform="avibe",
            scope_type="project",
            native_id="proj_send_now_recovery",
            now="2026-07-30T00:00:00Z",
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session_id = sessions_service.create_session(
            conn,
            scope_id=scope_id,
            agent_backend="claude",
            agent_name="worker",
        )["id"]

    request_store = TaskExecutionStore()
    request = request_store.enqueue_agent_run(
        session_id=session_id,
        message="retry the idle flush",
        agent_name="worker",
        delivery_intent="send_now",
    )
    assert request_store.claim(request.id) is not None
    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    controller.emit_agent_message = AsyncMock()

    async def _ambiguous_dispatch(*args, **kwargs):
        raise RuntimeError("native start outcome lost")

    monkeypatch.setattr(session_turns, "dispatch_turn_with_outcome", _ambiguous_dispatch)
    context = MessageContext(
        user_id="workbench",
        channel_id=session_id,
        platform="avibe",
        message_id=f"agent_run:{request.id}",
        platform_specific={
            "task_execution_id": request.id,
            "task_trigger_kind": "agent_run",
        },
    )

    async def _go():
        result = await controller.session_turn_gate.submit_scheduled(
            session_id,
            context,
            request.message or "",
            delivery_intent="send_now",
        )
        for _ in range(300):
            if session_id not in app.state.in_flight_dispatches:
                break
            await asyncio.sleep(0.01)
        return result

    result = asyncio.run(_go())

    assert result == session_turns.TurnSubmissionResult(
        route="ran",
        queue_persisted=True,
        target_was_busy=False,
        delivery_status="claimed",
        delivery_owner_transferred=True,
    )
    with engine.connect() as conn:
        delivery = message_deliveries.get_delivery_by_dedupe(
            conn,
            message_deliveries.native_dedupe_key(
                "avibe",
                f"agent_run:{request.id}",
                scope_id=scope_id,
            ),
        )
        assert delivery is not None
        assert delivery["state"] == "claimed"
        turn = message_deliveries.get_turn(conn, delivery["turn_id"])
        assert turn is not None
        assert turn["start_receipt_outcome"] == "unknown"
        assert message_deliveries.list_queued(conn, session_id) == []
    stored = request_store.get_run(request.id)
    assert stored is not None
    assert stored["status"] == "running"
    assert stored["delivery_id"] == delivery["id"]
    assert "workbench_queue_holds_run" not in stored["metadata"]


def test_canceling_held_agent_run_retires_queue_before_send_now(
    monkeypatch,
    tmp_path,
):
    """A canceled queue owner cannot leave stale work that triggers Stop."""

    from core.scheduled_tasks import TaskExecutionStore
    from core.services import sessions as sessions_service
    from storage import messages_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn,
            platform="avibe",
            scope_type="project",
            native_id="proj_cancel_before_send_now",
            now="2026-07-30T00:00:00Z",
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session_id = sessions_service.create_session(
            conn,
            scope_id=scope_id,
            agent_backend="claude",
            agent_name="worker",
        )["id"]

    request_store = TaskExecutionStore()
    request = request_store.enqueue_agent_run(
        session_id=session_id,
        message="obsolete urgent correction",
        agent_name="worker",
        delivery_intent="send_now",
    )
    assert request_store.claim(request.id) is not None
    request_store.requeue(request.id)
    with engine.begin() as conn:
        queued_delivery = message_deliveries.enqueue_queued(
            conn,
            scope_id=scope_id,
            session_id=session_id,
            platform="avibe",
            author="harness",
            source="harness",
            message_type="harness",
            native_message_id=f"agent_run:{request.id}",
            text=request.message or "",
        )
        from storage.background import attach_agent_run_delivery_in_connection

        assert attach_agent_run_delivery_in_connection(
            conn,
            request.id,
            session_id=session_id,
            delivery_id=queued_delivery["id"],
        )

    controller = _build_controller_double()
    app = internal_server.create_app(controller)

    async def _exercise():
        active_task = asyncio.create_task(asyncio.sleep(60))
        app.state.in_flight_dispatches[session_id] = session_turns.Turn(
            task=active_task,
            context=MessageContext(
                user_id="workbench",
                channel_id=session_id,
                platform="avibe",
            ),
        )
        try:
            assert request_store.cancel_run(request.id) is True
            return await controller.session_turns.send_now(session_id)
        finally:
            active_task.cancel()
            with contextlib.suppress(asyncio.CancelledError):
                await active_task

    result = asyncio.run(_exercise())

    assert result == {
        "ok": True,
        "session_id": session_id,
        "status": "empty",
    }
    controller.command_handler.handle_stop.assert_not_awaited()
    with engine.connect() as conn:
        assert message_deliveries.list_queued(conn, session_id) == []
    stored = request_store.get_run(request.id)
    assert stored is not None
    assert stored["status"] == "canceled"
    assert stored["cancel_requested"] is True


def test_idle_send_now_releases_hold_and_starts_the_exact_head(
    monkeypatch,
    tmp_path,
):
    """Empty P1 releases a hold and claims only the observed FIFO head."""

    from core.services import sessions as sessions_service
    from storage import messages_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn,
            platform="avibe",
            scope_type="project",
            native_id="proj_idle_flush_failed",
            now="2026-07-30T00:00:00Z",
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session_id = sessions_service.create_session(
            conn,
            scope_id=scope_id,
            agent_backend="claude",
            agent_name="worker",
        )["id"]
        queued = message_deliveries.enqueue_queued(
            conn,
            scope_id=scope_id,
            session_id=session_id,
            text="retry me later",
        )

    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    controller.emit_agent_message = AsyncMock()

    async def _dispatch(
        ctrl, context, text, *, source=SOURCE_HUMAN, on_chunk=None, **_kwargs
    ):
        assert text == "retry me later"
        _bind_test_native_start(engine, context)
        return TurnDispatchOutcome(error=None, settled_by=SETTLED_BY_TERMINAL_RESULT)

    monkeypatch.setattr(session_turns, "dispatch_turn_with_outcome", _dispatch)

    async def _exercise():
        transport = httpx.ASGITransport(app=app)
        async with httpx.AsyncClient(
            transport=transport,
            base_url="http://testserver",
        ) as client:
            response = await client.post(f"/internal/send-now/{session_id}")
            for _ in range(300):
                if session_id not in app.state.in_flight_dispatches:
                    break
                await asyncio.sleep(0.01)
            return response

    response = asyncio.run(_exercise())

    assert response.status_code == 200
    assert response.json() == {
        "ok": True,
        "session_id": session_id,
        "status": "claimed",
        "delivery_id": queued["id"],
    }
    with engine.connect() as conn:
        assert message_deliveries.list_queued(conn, session_id) == []
        assert messages_service.get_message(conn, queued["id"], session_id=session_id)


def test_agent_run_send_now_cancel_race_never_becomes_failed(monkeypatch, tmp_path):
    from core.scheduled_tasks import (
        ScheduledTaskService,
        ScheduledTaskStore,
        TaskExecutionStore,
    )
    from core.services import sessions as sessions_service
    from storage import messages_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn,
            platform="avibe",
            scope_type="project",
            native_id="proj_send_now_cancel",
            now="2026-07-30T00:00:00Z",
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session_id = sessions_service.create_session(
            conn,
            scope_id=scope_id,
            agent_backend="claude",
            agent_name="worker",
        )["id"]

    request_store = TaskExecutionStore()
    request = request_store.enqueue_agent_run(
        session_id=session_id,
        message="must not survive cancellation",
        agent_name="worker",
        delivery_intent="send_now",
    )
    controller = _build_controller_double()
    controller.agent_service.runtime_activation_identity_for_request = Mock(
        return_value=None
    )
    controller.platform_settings_managers = {}
    controller.im_clients = {"avibe": SimpleNamespace()}
    controller.get_im_client_for_context = lambda _context: SimpleNamespace(
        should_use_thread_for_reply=lambda: True,
        should_use_thread_for_dm_session=lambda: False,
    )
    internal_server.create_app(controller)
    submit_scheduled = controller.session_turn_gate.submit_scheduled

    async def _cancel_after_claim(*args, **kwargs):
        sqlite_store = request_store._sqlite
        assert sqlite_store is not None
        assert sqlite_store.cancel_run(request.id) is True
        return await submit_scheduled(*args, **kwargs)

    controller.session_turn_gate.submit_scheduled = _cancel_after_claim
    service = ScheduledTaskService(
        controller=controller,
        store=ScheduledTaskStore(tmp_path / "scheduled_tasks.json"),
        request_store=request_store,
    )

    async def _exercise() -> None:
        await service._drain_requests()
        execution = service._inflight_executions.get(request.id)
        assert execution is not None
        await execution

    asyncio.run(_exercise())

    stored = request_store.get_run(request.id)
    assert stored is not None
    assert stored["status"] == "canceled"
    assert stored["cancel_requested"] is True
    assert stored["error"] is None
    assert stored["metadata"]["delivery_outcome"]["status"] == "canceled"
    with engine.connect() as conn:
        assert message_deliveries.list_queued(conn, session_id) == []


def test_scheduled_gate_busy_duplicate_native_id_is_skipped(monkeypatch, tmp_path):
    """A retried harness callback already sitting in the queue is a duplicate,
    not a scheduler failure."""
    from core.services import sessions as sessions_service
    from storage import messages_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn, platform="avibe", scope_type="project", native_id="proj_sched_dup", now="2026-05-31T00:00:00Z"
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session = sessions_service.create_session(
            conn, scope_id=scope_id, agent_backend="claude", agent_name="worker"
        )
        active_delivery = _reserve_submission(
            conn,
            scope_id=scope_id,
            session_id=session["id"],
            text="running",
            author="harness",
            source="harness",
            message_type="harness",
            native_message_id="watch:def-watch:running",
        )
        active_turn_id = message_deliveries.new_turn_id()
        message_deliveries.insert_turn(
            conn,
            turn_id=active_turn_id,
            session_id=session["id"],
            initial_delivery_id=active_delivery["id"],
            state="starting",
            backend="claude",
        )
        opened = message_deliveries.open_start_attempt(
            conn,
            active_delivery["id"],
            expected_version=1,
            turn_id=active_turn_id,
            attempt_id=message_deliveries.new_attempt_id(),
        )
        assert opened is not None
        bound = message_deliveries.bind_native_start(
            conn,
            active_turn_id,
            expected_version=int(
                message_deliveries.get_turn(conn, active_turn_id)["version"]
            ),
            runtime_key=f"runtime:{session['id']}",
            runtime_turn_id=f"runtime-turn:{active_turn_id}",
            native_turn_id=f"native:{active_turn_id}",
        )
        assert bound is not None
        accepted = message_deliveries.materialize_start_acceptance(
            conn,
            turn_id=active_turn_id,
            evidence={"kind": "test_native_acceptance"},
        )
        assert accepted
        messages_service.append(
            conn,
            scope_id=scope_id,
            session_id=session["id"],
            platform="avibe",
            author="harness",
            source="harness",
            message_type="harness",
            text="accepted before delivery migration",
            native_message_id="watch:def-watch:legacy-accepted",
        )
    session_id = session["id"]

    async def _explode_dispatch_turn(*args, **kwargs):
        raise AssertionError("a busy scheduled run must enqueue, not dispatch a turn")

    monkeypatch.setattr(session_turns, "dispatch_turn_with_outcome", _explode_dispatch_turn)

    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    ctx = MessageContext(
        user_id="workbench",
        channel_id=session_id,
        platform="avibe",
        message_id="watch:def-watch:run-1",
        platform_specific={
            "task_trigger_kind": "watch",
            "task_definition_id": "def-watch",
        },
    )

    async def _go():
        async def _busy():
            await asyncio.sleep(60)

        chat_task = asyncio.create_task(_busy())
        app.state.in_flight_dispatches[session_id] = session_turns.Turn(
            task=chat_task,
            context=MessageContext(
                user_id="U",
                channel_id="C",
                platform="avibe",
                message_id="watch:def-watch:running",
            ),
            logical_turn_id=active_turn_id,
        )
        try:
            first = await controller.session_turn_gate.submit_scheduled(session_id, ctx, "first")
            second = await controller.session_turn_gate.submit_scheduled(session_id, ctx, "duplicate")
            running_ctx = MessageContext(
                user_id="workbench",
                channel_id=session_id,
                platform="avibe",
                message_id="watch:def-watch:running",
            )
            running_duplicate = await controller.session_turn_gate.submit_scheduled(
                session_id,
                running_ctx,
                "running duplicate",
            )
            legacy_ctx = MessageContext(
                user_id="workbench",
                channel_id=session_id,
                platform="avibe",
                message_id="watch:def-watch:legacy-accepted",
            )
            legacy_duplicate = await controller.session_turn_gate.submit_scheduled(
                session_id,
                legacy_ctx,
                "legacy accepted duplicate",
            )
        finally:
            chat_task.cancel()
        return first, second, running_duplicate, legacy_duplicate

    assert asyncio.run(_go()) == ("enqueued", "duplicate", "duplicate", "duplicate")
    with engine.connect() as conn:
        queued = message_deliveries.list_queued(conn, session_id)
    assert [row["text"] for row in queued] == ["first"]


def test_scheduled_gate_retry_resumes_matching_reserved_delivery(monkeypatch, tmp_path):
    """A retry resumes a pre-claim reservation instead of completing as duplicate."""
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(
        tmp_path,
        native_id="proj_sched_reserved_retry",
    )
    session_id = session["id"]
    dispatched: list[str] = []

    async def _accept_dispatch(
        ctrl,
        ctx,
        text,
        *,
        source=SOURCE_HUMAN,
        on_chunk=None,
        lifecycle_snapshot=None,
    ):
        del lifecycle_snapshot
        dispatched.append(text)
        _bind_test_native_start(engine, ctx)
        return TurnDispatchOutcome(error=None, settled_by=SETTLED_BY_TERMINAL_RESULT)

    monkeypatch.setattr(session_turns, "dispatch_turn_with_outcome", _accept_dispatch)

    controller = _build_controller_double()
    internal_server.create_app(controller)
    manager = controller.session_turns
    submit_scheduled = controller.session_turn_gate.submit_scheduled
    resolve_backend = manager._delivery_backend
    fail_before_claim = True

    def _resolve_backend(session_id, context):
        nonlocal fail_before_claim
        if fail_before_claim:
            fail_before_claim = False
            raise RuntimeError("backend temporarily unresolved")
        return resolve_backend(session_id, context)

    monkeypatch.setattr(manager, "_delivery_backend", _resolve_backend)
    ctx = MessageContext(
        user_id="workbench",
        channel_id=session_id,
        platform="avibe",
        message_id="watch:def-watch:reserved-retry",
        platform_specific={
            "agent_session_target": {"agent_backend": "claude"},
            "task_trigger_kind": "watch",
            "task_definition_id": "def-watch",
        },
    )

    async def _go():
        with pytest.raises(RuntimeError, match="temporarily unresolved"):
            await submit_scheduled(session_id, ctx, "original prompt")
        with engine.connect() as conn:
            reserved = message_deliveries.get_delivery_by_dedupe(
                conn,
                message_deliveries.native_dedupe_key(
                    "avibe",
                    "watch:def-watch:reserved-retry",
                    scope_id=session["scope_id"],
                ),
            )
            assert reserved is not None
            assert reserved["state"] == "reserved"

        resumed = await submit_scheduled(
            session_id,
            ctx,
            "changed retry payload",
        )
        duplicate = await submit_scheduled(session_id, ctx, "duplicate")
        return resumed, duplicate, reserved["id"]

    resumed, duplicate, delivery_id = asyncio.run(_go())
    assert (resumed, duplicate) == ("ran", "duplicate")
    assert dispatched == ["original prompt"]
    with engine.connect() as conn:
        delivery = message_deliveries.get_delivery(conn, delivery_id)
        assert delivery is not None
        assert delivery["state"] == "accepted"
        assert delivery["message_id"] == delivery_id


def test_scheduled_gate_retry_preserves_existing_delivery_owner(monkeypatch, tmp_path):
    from core.scheduled_tasks import TaskExecutionStore
    from storage.background import (
        attach_agent_run_delivery_in_connection,
        run_update_event_transaction,
    )

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(
        tmp_path,
        native_id="proj_sched_owned_retry",
    )
    session_id = session["id"]
    request_store = TaskExecutionStore()
    run = request_store.enqueue_hook_send(
        session_key="",
        session_id=session_id,
        prompt="owned watch result",
        run_type="watch",
    )
    assert request_store.claim(run.id) is not None
    delivery_id = message_deliveries.new_delivery_id()
    with run_update_event_transaction(engine) as conn:
        message_deliveries.insert_delivery(
            conn,
            delivery_id=delivery_id,
            session_id=session_id,
            priority="p3",
            state="queued",
            snapshot=message_deliveries.message_snapshot(
                scope_id=session["scope_id"],
                session_id=session_id,
                platform="avibe",
                author="harness",
                source="harness",
                message_type="harness",
                text="owned watch result",
                native_message_id=f"watch:{run.id}",
            ),
            dispatch_text="owned watch result",
            dedupe_key=f"avibe:watch:{run.id}",
        )
        assert attach_agent_run_delivery_in_connection(
            conn,
            run.id,
            session_id=session_id,
            delivery_id=delivery_id,
        )

    controller = _build_controller_double()
    internal_server.create_app(controller)
    context = MessageContext(
        user_id="workbench",
        channel_id=session_id,
        platform="avibe",
        message_id=f"watch:{run.id}",
        platform_specific={
            "task_execution_id": run.id,
            "task_trigger_kind": "watch",
        },
    )

    result = asyncio.run(
        controller.session_turn_gate.submit_scheduled(
            session_id,
            context,
            "owned watch result",
        )
    )

    assert result == session_turns.TurnSubmissionResult(
        route="enqueued",
        queue_persisted=True,
        target_was_busy=False,
        delivery_status="queued",
        delivery_owner_transferred=True,
    )
    assert request_store.get_run(run.id)["status"] == "running"


def test_scheduled_gate_cancellation_preserves_transferred_delivery_owner(
    monkeypatch,
    tmp_path,
):
    """A canceled executor cannot take a natively accepted steer back from Delivery."""
    from core.scheduled_tasks import TaskExecutionStore

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session, _active_turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_sched_canceled_handoff",
    )
    session_id = session["id"]
    request_store = TaskExecutionStore()
    run = request_store.enqueue_agent_run(
        session_id=session_id,
        message="steer while active",
        agent_name="worker",
    )
    assert request_store.claim(run.id) is not None

    controller = _build_controller_double()
    internal_server.create_app(controller)
    manager = controller.session_turns
    native_write_started = asyncio.Event()
    release_native_write = asyncio.Event()

    async def _natively_accepted_delivery(request, *, context):
        del request, context
        native_write = asyncio.create_task(release_native_write.wait())
        native_write_started.set()
        try:
            await asyncio.shield(native_write)
        except asyncio.CancelledError:
            # Match the shared steering boundary: native receipt is reconciled
            # before cancellation propagates to durable admission.
            await native_write
            raise

    monkeypatch.setattr(manager, "deliver", _natively_accepted_delivery)
    context = MessageContext(
        user_id="workbench",
        channel_id=session_id,
        platform="avibe",
        message_id=f"agent_run:{run.id}",
        platform_specific={
            "task_execution_id": run.id,
            "task_trigger_kind": "agent_run",
        },
    )

    async def _go():
        submission = asyncio.create_task(
            controller.session_turn_gate.submit_scheduled(
                session_id,
                context,
                "steer while active",
            )
        )
        await native_write_started.wait()
        submission.cancel()
        await asyncio.sleep(0)
        assert not submission.done()
        release_native_write.set()
        return await submission

    result = asyncio.run(_go())

    assert result == session_turns.TurnSubmissionResult(
        route="enqueued",
        queue_persisted=True,
        target_was_busy=True,
        delivery_status="reserved",
        delivery_owner_transferred=True,
    )
    stored = request_store.get_run(run.id)
    assert stored is not None
    assert stored["status"] == "running"
    assert stored["delivery_id"]
    with engine.connect() as conn:
        delivery = message_deliveries.get_delivery(conn, stored["delivery_id"])
    assert delivery is not None
    assert delivery["state"] == "reserved"


def test_scheduled_send_now_recovers_transferred_reservation(monkeypatch, tmp_path):
    """After ownership transfer, a pre-claim failure belongs to Delivery recovery."""
    from core.scheduled_tasks import TaskExecutionStore

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(
        tmp_path,
        native_id="proj_sched_send_now_reserved_retry",
    )
    session_id = session["id"]
    request_store = TaskExecutionStore()
    run = request_store.enqueue_agent_run(
        session_id=session_id,
        message="original send-now prompt",
        agent_name="worker",
        delivery_intent="send_now",
    )
    assert request_store.claim(run.id) is not None
    dispatched: list[str] = []

    async def _accept_dispatch(
        ctrl,
        ctx,
        text,
        *,
        source=SOURCE_HUMAN,
        on_chunk=None,
        lifecycle_snapshot=None,
    ):
        del lifecycle_snapshot
        dispatched.append(text)
        _bind_test_native_start(engine, ctx)
        return TurnDispatchOutcome(error=None, settled_by=SETTLED_BY_TERMINAL_RESULT)

    monkeypatch.setattr(session_turns, "dispatch_turn_with_outcome", _accept_dispatch)

    controller = _build_controller_double()
    internal_server.create_app(controller)
    manager = controller.session_turns
    submit_scheduled = controller.session_turn_gate.submit_scheduled
    resolve_backend = manager._delivery_backend
    fail_before_claim = True

    def _resolve_backend(session_id, context):
        nonlocal fail_before_claim
        if fail_before_claim:
            fail_before_claim = False
            raise RuntimeError("backend temporarily unresolved")
        return resolve_backend(session_id, context)

    monkeypatch.setattr(manager, "_delivery_backend", _resolve_backend)
    ctx = MessageContext(
        user_id="workbench",
        channel_id=session_id,
        platform="avibe",
        message_id=f"agent_run:{run.id}",
        platform_specific={
            "agent_session_target": {"agent_backend": "claude"},
            "task_execution_id": run.id,
            "task_trigger_kind": "agent_run",
        },
    )

    async def _go():
        deferred = await submit_scheduled(
            session_id,
            ctx,
            "original send-now prompt",
            delivery_intent="send_now",
        )
        assert isinstance(deferred, session_turns.TurnSubmissionResult)
        assert deferred.route == "enqueued"
        assert deferred.delivery_status == "reserved"
        assert deferred.delivery_owner_transferred is True
        held = request_store.get_run(run.id)
        assert held is not None
        assert held["status"] == "running"
        assert held["delivery_id"] is not None
        assert "workbench_queue_holds_run" not in held["metadata"]

        await manager.recover_durable_delivery_state(session_id)
        resumed_owner = await submit_scheduled(
            session_id,
            ctx,
            "duplicate",
            delivery_intent="send_now",
        )
        return resumed_owner

    resumed_owner = asyncio.run(_go())
    assert isinstance(resumed_owner, session_turns.TurnSubmissionResult)
    assert resumed_owner.route == "ran"
    # The duplicate answers with the Delivery's state when its admission reads it. Admission
    # now yields the loop while it waits for SQLite (#2630), so the recovered turn may have
    # moved its Delivery from claimed to accepted by then; either way the turn owns it.
    assert resumed_owner.delivery_status in {"claimed", "accepted"}
    assert resumed_owner.delivery_owner_transferred is True
    assert dispatched == ["original send-now prompt"]


def test_scheduled_gate_cancel_stops_scheduled_run(monkeypatch, tmp_path):
    """Stop works for a scheduled run: because the run goes through ``_run_turn``
    it registers the scheduled ``context`` in ``in_flight``, so
    ``/internal/cancel/{session_id}`` finds the task + reuses the IM ``/stop`` path
    to interrupt the backend (mirrors the Chat cancel test)."""
    from core.services import sessions as sessions_service
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.settings_service import upsert_scope

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn, platform="avibe", scope_type="project", native_id="proj_sched_cancel", now="2026-05-31T00:00:00Z"
        )
        _seed_project_workdir(conn, scope_id, tmp_path)
        session = sessions_service.create_session(
            conn, scope_id=scope_id, agent_backend="claude", agent_name="worker"
        )
    session_id = session["id"]

    started = asyncio.Event()
    stop_requested = asyncio.Event()
    terminal_ready = asyncio.Event()

    async def _long_dispatch_turn(
        ctrl, ctx, text, *, source=SOURCE_HUMAN, on_chunk=None, **_kwargs
    ):
        _bind_test_native_start(engine, ctx)
        started.set()
        await stop_requested.wait()
        await terminal_ready.wait()
        return TurnDispatchOutcome(error=None, settled_by=SETTLED_BY_STOPPED)

    async def stop_backend(stop_context):
        assert stop_context is app.state.in_flight_dispatches[session_id].context
        stop_requested.set()
        return True

    monkeypatch.setattr(session_turns, "dispatch_turn_with_outcome", _long_dispatch_turn)

    controller = _build_controller_double()
    controller.command_handler.handle_stop = AsyncMock(side_effect=stop_backend)
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)
    ctx = MessageContext(user_id="workbench", channel_id=session_id, platform="avibe")

    async def _go():
        # Start the scheduled run in the background (it holds in_flight open).
        run = asyncio.create_task(controller.session_turn_gate.submit_scheduled(session_id, ctx, "scheduled run"))
        turn = None
        try:
            await asyncio.wait_for(started.wait(), timeout=3)
            turn = app.state.in_flight_dispatches[session_id]
            async with httpx.AsyncClient(transport=transport, base_url="http://testserver") as client:
                resp = await client.post(f"/internal/cancel/{session_id}")
            assert resp.status_code == 200
            assert resp.json()["status"] == "cancel_requested"
            controller.command_handler.handle_stop.assert_awaited_once_with(turn.context)
            assert stop_requested.is_set()
            assert not turn.task.done()
            assert app.state.in_flight_dispatches[session_id] is turn

            terminal_ready.set()
            # Submission is admission, not completion: join the real dispatch too.
            await asyncio.wait_for(asyncio.shield(turn.task), timeout=3)
            await asyncio.wait_for(asyncio.shield(run), timeout=3)
            assert turn.task.done() and not turn.task.cancelled()
            assert session_id not in app.state.in_flight_dispatches, "slot released after the scheduled run was stopped"
            with engine.connect() as conn:
                stopped_turn = message_deliveries.get_turn(conn, turn.logical_turn_id)
            assert stopped_turn["terminal_outcome"] == "canceled"
            return resp
        finally:
            pending = {run} | {entry.task for entry in app.state.in_flight_dispatches.values()}
            if turn is not None:
                pending.add(turn.task)
            for task in pending:
                if not task.done():
                    task.cancel()
            await asyncio.gather(*pending, return_exceptions=True)

    resp = asyncio.run(_go())
    assert resp.status_code == 200
    assert resp.json()["status"] == "cancel_requested"
    # The cancel interrupted the backend through the IM /stop path with the
    # scheduled run's own context.
    controller.command_handler.handle_stop.assert_awaited_once()
    assert session_id not in app.state.in_flight_dispatches, "slot released after the scheduled run was stopped"


def _cancel_run_through_live_turn(controller, session_id, turn_id, run_id):
    """Cancel one Run while a live runtime owns the exact durable Turn."""

    context = MessageContext(
        user_id="workbench",
        channel_id=session_id,
        platform="avibe",
        platform_specific={"workbench_session_id": session_id},
    )

    async def _go():
        holder = asyncio.create_task(asyncio.Event().wait())
        controller.session_turns.in_flight[session_id] = session_turns.Turn(
            task=holder,
            context=context,
            logical_turn_id=turn_id,
        )
        try:
            return await controller.session_turns.cancel(
                session_id,
                agent_run_id=run_id,
            )
        finally:
            holder.cancel()
            await asyncio.gather(holder, return_exceptions=True)

    return asyncio.run(_go()), context


def test_hfr_476_run_cancel_stops_a_shared_turn(monkeypatch, tmp_path):
    """HFR-476: Canceling a Run steered into a live Turn stops that Turn like Session Stop."""

    from core.scheduled_tasks import TaskExecutionStore
    from storage.background import attach_agent_run_delivery_in_connection
    from storage.models import message_deliveries as delivery_rows

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session, turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_shared_run_cancel",
    )
    session_id = session["id"]
    request_store = TaskExecutionStore()
    owner_run, steer_run = (
        request_store.enqueue_agent_run(
            session_id=session_id,
            message=message,
            agent_name="worker",
            callback_session_id="ses_callback",
        )
        for message in ("initial owner", "steered participant")
    )
    assert request_store.claim(owner_run.id) is not None
    assert request_store.claim(steer_run.id) is not None

    with engine.begin() as conn:
        initial = message_deliveries.delivery_for_turn(conn, turn_id)
        assert initial is not None
        assert attach_agent_run_delivery_in_connection(
            conn,
            owner_run.id,
            session_id=session_id,
            delivery_id=initial["id"],
        )
        steer_id = message_deliveries.new_delivery_id()
        values = dict(initial)
        values.update(
            id=steer_id,
            priority="p1",
            dedupe_key=None,
            turn_role="steer",
            turn_position=1,
            submitted_at="2026-08-11T11:00:00Z",
            updated_at="2026-08-11T11:00:00Z",
            version=1,
        )
        conn.execute(delivery_rows.insert().values(**values))
        assert attach_agent_run_delivery_in_connection(
            conn,
            steer_run.id,
            session_id=session_id,
            delivery_id=steer_id,
        )
        for run in (owner_run, steer_run):
            assert message_deliveries.agent_run_input_reached_turn(
                conn,
                run_id=run.id,
                turn_id=turn_id,
            ) == (True, "run_input_in_turn")

    controller = _build_controller_double()
    internal_server.create_app(controller)

    result, context = _cancel_run_through_live_turn(
        controller,
        session_id,
        turn_id,
        steer_run.id,
    )

    assert result == {
        "ok": True,
        "session_id": session_id,
        "status": "cancel_requested",
    }
    controller.command_handler.handle_stop.assert_awaited_once_with(context)
    saved = request_store.get_run(steer_run.id)
    assert saved is not None
    assert saved["cancel_requested"] is True
    with engine.connect() as conn:
        turn = message_deliveries.get_turn(conn, turn_id)
    assert turn is not None
    assert turn["control_mode"] == "stop_only"
    assert turn["control_state"] == "waiting_terminal"


def test_run_cancel_stops_a_turn_with_an_unresolved_steer(
    monkeypatch,
    tmp_path,
):
    """A native steer in flight cannot keep the initial Run's cancel from stopping."""

    from core.scheduled_tasks import TaskExecutionStore
    from storage.background import attach_agent_run_delivery_in_connection

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session, turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_unresolved_steer_cancel",
    )
    session_id = session["id"]
    request_store = TaskExecutionStore()
    owner_run, steer_run = (
        request_store.enqueue_agent_run(
            session_id=session_id,
            message=message,
            agent_name="worker",
            callback_session_id="ses_callback",
        )
        for message in ("initial owner", "second input already steering")
    )
    assert request_store.claim(owner_run.id) is not None
    assert request_store.claim(steer_run.id) is not None

    with engine.begin() as conn:
        turn = message_deliveries.get_turn(conn, turn_id)
        initial = message_deliveries.delivery_for_turn(conn, turn_id)
        assert turn is not None
        assert initial is not None
        assert attach_agent_run_delivery_in_connection(
            conn,
            owner_run.id,
            session_id=session_id,
            delivery_id=initial["id"],
        )
        steer = _reserve_submission(
            conn,
            scope_id=session["scope_id"],
            session_id=session_id,
            text="second input already steering",
        )
        claimed = message_deliveries.open_steer_attempt(
            conn,
            steer["id"],
            expected_version=int(steer["version"]),
            turn_id=turn_id,
            attempt_id=message_deliveries.new_attempt_id(),
            expected_native_turn_id=str(turn["native_turn_id"]),
        )
        assert claimed is not None
        assert claimed["state"] == "steering"
        assert attach_agent_run_delivery_in_connection(
            conn,
            steer_run.id,
            session_id=session_id,
            delivery_id=str(claimed["id"]),
        )
        # A possibly-written steer is inside the Turn, so its own cancel stops too.
        assert message_deliveries.agent_run_input_reached_turn(
            conn,
            run_id=steer_run.id,
            turn_id=turn_id,
        ) == (True, "run_input_in_turn")

    controller = _build_controller_double()
    internal_server.create_app(controller)

    result, context = _cancel_run_through_live_turn(
        controller,
        session_id,
        turn_id,
        owner_run.id,
    )

    assert result == {
        "ok": True,
        "session_id": session_id,
        "status": "cancel_requested",
    }
    controller.command_handler.handle_stop.assert_awaited_once_with(context)
    saved = request_store.get_run(owner_run.id)
    assert saved is not None
    assert saved["cancel_requested"] is True
    with engine.connect() as conn:
        turn = message_deliveries.get_turn(conn, turn_id)
    assert turn is not None
    assert turn["control_mode"] == "stop_only"
    assert turn["control_state"] == "waiting_terminal"


def test_run_cancel_joining_a_refused_stop_retries_its_own_stop(
    monkeypatch,
    tmp_path,
):
    """A Run cancel waits for a joined Stop's receipt and retries when refused."""

    from core.scheduled_tasks import TaskExecutionStore
    from storage.background import attach_agent_run_delivery_in_connection

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session, turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_run_cancel_joins_refused_stop",
    )
    session_id = session["id"]
    request_store = TaskExecutionStore()
    run = request_store.enqueue_agent_run(
        session_id=session_id,
        message="initial owner",
        agent_name="worker",
    )
    assert request_store.claim(run.id) is not None
    with engine.begin() as conn:
        initial = message_deliveries.delivery_for_turn(conn, turn_id)
        assert initial is not None
        assert attach_agent_run_delivery_in_connection(
            conn,
            run.id,
            session_id=session_id,
            delivery_id=initial["id"],
        )

    controller = _build_controller_double()
    internal_server.create_app(controller)
    stop_entered = asyncio.Event()
    release_stop = asyncio.Event()
    stop_calls = 0

    async def _refuse_first_stop(stop_context):
        nonlocal stop_calls
        stop_calls += 1
        if stop_calls > 1:
            return True
        stop_entered.set()
        await release_stop.wait()
        stop_context.platform_specific["stop_failure_reason"] = "refused"
        return False

    controller.command_handler.handle_stop = AsyncMock(side_effect=_refuse_first_stop)
    context = MessageContext(
        user_id="workbench",
        channel_id=session_id,
        platform="avibe",
        platform_specific={"workbench_session_id": session_id},
    )

    async def _go():
        holder = asyncio.create_task(asyncio.Event().wait())
        controller.session_turns.in_flight[session_id] = session_turns.Turn(
            task=holder,
            context=context,
            logical_turn_id=turn_id,
        )
        try:
            session_stop = asyncio.create_task(controller.session_turns.cancel(session_id))
            await asyncio.wait_for(stop_entered.wait(), timeout=1.0)
            run_cancel = asyncio.create_task(
                controller.session_turns.cancel(session_id, agent_run_id=run.id)
            )
            await asyncio.sleep(0.1)
            assert not run_cancel.done()
            # Nothing is recorded while the joined Stop has no receipt.
            assert request_store.get_run(run.id)["cancel_requested"] is False
            release_stop.set()
            return await run_cancel, await session_stop
        finally:
            holder.cancel()
            await asyncio.gather(holder, return_exceptions=True)

    run_cancel, session_stop = asyncio.run(_go())

    assert session_stop["ok"] is False, session_stop
    assert run_cancel == {
        "ok": True,
        "session_id": session_id,
        "status": "cancel_requested",
    }
    assert controller.command_handler.handle_stop.await_count == 2
    assert request_store.get_run(run.id)["cancel_requested"] is True
    with engine.connect() as conn:
        turn = message_deliveries.get_turn(conn, turn_id)
    assert turn is not None and turn["control_state"] == "waiting_terminal"


def test_run_cancel_guard_preserves_an_in_flight_replacement(monkeypatch, tmp_path):
    """Canceling the owner Run cannot supersede an accepted P0 replacement."""

    from core.scheduled_tasks import TaskExecutionStore
    from storage.background import attach_agent_run_delivery_in_connection

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session, turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_replacement_run_cancel",
    )
    session_id = session["id"]
    request_store = TaskExecutionStore()
    owner_run = request_store.enqueue_agent_run(
        session_id=session_id,
        message="initial owner",
        agent_name="worker",
        callback_session_id="ses_callback",
    )
    assert request_store.claim(owner_run.id) is not None

    with engine.begin() as conn:
        turn = message_deliveries.get_turn(conn, turn_id)
        initial = message_deliveries.delivery_for_turn(conn, turn_id)
        assert turn is not None
        assert initial is not None
        assert attach_agent_run_delivery_in_connection(
            conn,
            owner_run.id,
            session_id=session_id,
            delivery_id=initial["id"],
        )
        replacement = _reserve_submission(
            conn,
            scope_id=session["scope_id"],
            session_id=session_id,
            text="replacement from another user",
        )
        successor_turn_id = message_deliveries.new_turn_id()
        message_deliveries.insert_turn(
            conn,
            turn_id=successor_turn_id,
            session_id=session_id,
            initial_delivery_id=str(replacement["id"]),
            state="waiting",
            backend="claude",
        )
        replacement = message_deliveries.cas_delivery(
            conn,
            str(replacement["id"]),
            expected_version=int(replacement["version"]),
            expected_states=("reserved",),
            values={
                "priority": "p0",
                "state": "interrupt_waiting",
                "turn_id": successor_turn_id,
                "turn_role": "initial",
                "turn_position": 0,
            },
        )
        assert replacement is not None
        controlled = message_deliveries.cas_turn(
            conn,
            turn_id,
            expected_version=int(turn["version"]),
            expected_states=("active",),
            values={
                "control_state": "waiting_terminal",
                "control_mode": "replace",
                "control_attempt_id": message_deliveries.new_attempt_id(),
                "control_expected_native_turn_id": turn["native_turn_id"],
                "control_successor_delivery_id": replacement["id"],
                "control_successor_turn_id": successor_turn_id,
            },
        )
        assert controlled is not None

    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        async with httpx.AsyncClient(
            transport=transport,
            base_url="http://testserver",
        ) as client:
            return await client.post(
                f"/internal/cancel/{session_id}",
                params={"run_id": owner_run.id},
            )

    response = asyncio.run(_go())

    assert response.status_code == 200
    assert response.json() == {
        "ok": True,
        "session_id": session_id,
        "status": "run_detached",
        "reason": "turn_has_replacement_successor",
    }
    controller.command_handler.handle_stop.assert_not_awaited()
    saved = request_store.get_run(owner_run.id)
    assert saved is not None
    assert saved["status"] == "canceled"
    assert saved["callback_status"] == "skipped"
    with engine.connect() as conn:
        turn = message_deliveries.get_turn(conn, turn_id)
        successor = message_deliveries.get_turn(conn, successor_turn_id)
        replacement = message_deliveries.get_delivery(conn, str(replacement["id"]))
    assert turn is not None
    assert turn["control_mode"] == "replace"
    assert turn["control_successor_turn_id"] == successor_turn_id
    assert successor is not None and successor["state"] == "waiting"
    assert replacement is not None and replacement["state"] == "interrupt_waiting"


def test_run_cancel_waits_for_an_unconfirmed_replacement(monkeypatch, tmp_path):
    """An owner Run cancel records nothing while a replacement has no receipt."""

    from core.scheduled_tasks import TaskExecutionStore
    from storage.background import attach_agent_run_delivery_in_connection

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session, turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_unconfirmed_replacement_run_cancel",
    )
    session_id = session["id"]
    request_store = TaskExecutionStore()
    owner_run = request_store.enqueue_agent_run(
        session_id=session_id,
        message="initial owner",
        agent_name="worker",
        callback_session_id="ses_callback",
    )
    assert request_store.claim(owner_run.id) is not None

    with engine.begin() as conn:
        turn = message_deliveries.get_turn(conn, turn_id)
        initial = message_deliveries.delivery_for_turn(conn, turn_id)
        assert turn is not None
        assert initial is not None
        assert attach_agent_run_delivery_in_connection(
            conn,
            owner_run.id,
            session_id=session_id,
            delivery_id=initial["id"],
        )
        replacement = _reserve_submission(
            conn,
            scope_id=session["scope_id"],
            session_id=session_id,
            text="replacement from another user",
        )
        successor_turn_id = message_deliveries.new_turn_id()
        message_deliveries.insert_turn(
            conn,
            turn_id=successor_turn_id,
            session_id=session_id,
            initial_delivery_id=str(replacement["id"]),
            state="waiting",
            backend="claude",
        )
        replacement = message_deliveries.cas_delivery(
            conn,
            str(replacement["id"]),
            expected_version=int(replacement["version"]),
            expected_states=("reserved",),
            values={
                "priority": "p0",
                "state": "interrupt_waiting",
                "turn_id": successor_turn_id,
                "turn_role": "initial",
                "turn_position": 0,
            },
        )
        assert replacement is not None
        controlled = message_deliveries.cas_turn(
            conn,
            turn_id,
            expected_version=int(turn["version"]),
            expected_states=("active",),
            values={
                "control_state": "interrupting",
                "control_mode": "replace",
                "control_attempt_id": message_deliveries.new_attempt_id(),
                "control_expected_native_turn_id": turn["native_turn_id"],
                "control_successor_delivery_id": replacement["id"],
                "control_successor_turn_id": successor_turn_id,
            },
        )
        assert controlled is not None

    monkeypatch.setattr(session_turns, "_RUN_CANCEL_JOIN_WAIT_SECONDS", 0.2)
    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        async with httpx.AsyncClient(
            transport=transport,
            base_url="http://testserver",
        ) as client:
            return await client.post(
                f"/internal/cancel/{session_id}",
                params={"run_id": owner_run.id},
            )

    response = asyncio.run(_go())

    assert response.status_code == 409
    assert response.json()["ok"] is False
    assert response.json()["code"] == "stop_unknown"
    assert response.json()["reason"] == "joined_unconfirmed_interrupt"
    controller.command_handler.handle_stop.assert_not_awaited()
    saved = request_store.get_run(owner_run.id)
    assert saved is not None
    assert saved["status"] == "running"
    assert saved["cancel_requested"] is False


def test_run_cancel_retires_its_own_in_flight_replacement(monkeypatch, tmp_path):
    """Canceling a replacement Run cannot leave its waiting prompt activatable."""

    from core.scheduled_tasks import TaskExecutionStore
    from storage.background import attach_agent_run_delivery_in_connection

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session, turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_replacement_owner_cancel",
    )
    session_id = session["id"]
    request_store = TaskExecutionStore()
    replacement_run = request_store.enqueue_agent_run(
        session_id=session_id,
        message="replacement from this Run",
        agent_name="worker",
        callback_session_id="ses_callback",
    )
    assert request_store.claim(replacement_run.id) is not None

    with engine.begin() as conn:
        turn = message_deliveries.get_turn(conn, turn_id)
        assert turn is not None
        replacement = _reserve_submission(
            conn,
            scope_id=session["scope_id"],
            session_id=session_id,
            text="replacement from this Run",
        )
        replacement_id = str(replacement["id"])
        successor_turn_id = message_deliveries.new_turn_id()
        message_deliveries.insert_turn(
            conn,
            turn_id=successor_turn_id,
            session_id=session_id,
            initial_delivery_id=replacement_id,
            state="waiting",
            backend="claude",
        )
        replacement = message_deliveries.cas_delivery(
            conn,
            replacement_id,
            expected_version=int(replacement["version"]),
            expected_states=("reserved",),
            values={
                "priority": "p0",
                "state": "interrupt_waiting",
                "turn_id": successor_turn_id,
                "turn_role": "initial",
                "turn_position": 0,
            },
        )
        assert replacement is not None
        assert attach_agent_run_delivery_in_connection(
            conn,
            replacement_run.id,
            session_id=session_id,
            delivery_id=replacement_id,
        )
        controlled = message_deliveries.cas_turn(
            conn,
            turn_id,
            expected_version=int(turn["version"]),
            expected_states=("active",),
            values={
                "control_state": "interrupting",
                "control_mode": "replace",
                "control_attempt_id": message_deliveries.new_attempt_id(),
                "control_expected_native_turn_id": turn["native_turn_id"],
                "control_successor_delivery_id": replacement_id,
                "control_successor_turn_id": successor_turn_id,
            },
        )
        assert controlled is not None

    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        async with httpx.AsyncClient(
            transport=transport,
            base_url="http://testserver",
        ) as client:
            return await client.post(
                f"/internal/cancel/{session_id}",
                params={"run_id": replacement_run.id},
            )

    response = asyncio.run(_go())

    assert response.status_code == 200
    assert response.json() == {
        "ok": True,
        "session_id": session_id,
        "status": "run_detached",
        "reason": "run_not_owned_by_turn",
    }
    controller.command_handler.handle_stop.assert_not_awaited()
    saved = request_store.get_run(replacement_run.id)
    assert saved is not None
    assert saved["status"] == "canceled"
    assert saved["callback_status"] == "skipped"
    with engine.connect() as conn:
        turn = message_deliveries.get_turn(conn, turn_id)
        successor = message_deliveries.get_turn(conn, successor_turn_id)
        replacement = message_deliveries.get_delivery(conn, replacement_id)
    assert turn is not None
    assert turn["state"] == "active"
    assert turn["control_state"] == "interrupting"
    assert turn["control_mode"] == "stop_only"
    assert turn["control_successor_delivery_id"] is None
    assert turn["control_successor_turn_id"] is None
    assert successor is not None
    assert successor["state"] == "terminal"
    assert successor["terminal_outcome"] == "not_written"
    assert replacement is not None
    assert replacement["state"] == "retired"
    assert replacement["turn_id"] is None


def test_run_cancel_keeps_a_sole_starting_owner_attached(monkeypatch, tmp_path):
    """A claimed initial Run owns its starting Turn until native start resolves."""

    from core.scheduled_tasks import TaskExecutionStore
    from storage.background import attach_agent_run_delivery_in_connection

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(
        tmp_path,
        native_id="proj_starting_run_cancel",
    )
    session_id = session["id"]
    request_store = TaskExecutionStore()
    owner_run = request_store.enqueue_agent_run(
        session_id=session_id,
        message="starting owner",
        agent_name="worker",
    )
    assert request_store.claim(owner_run.id) is not None

    with engine.begin() as conn:
        delivery = _reserve_submission(
            conn,
            scope_id=session["scope_id"],
            session_id=session_id,
            text="starting owner",
        )
        turn_id = message_deliveries.new_turn_id()
        message_deliveries.insert_turn(
            conn,
            turn_id=turn_id,
            session_id=session_id,
            initial_delivery_id=str(delivery["id"]),
            state="starting",
            backend="claude",
        )
        claimed = message_deliveries.open_start_attempt(
            conn,
            str(delivery["id"]),
            expected_version=int(delivery["version"]),
            turn_id=turn_id,
            attempt_id=message_deliveries.new_attempt_id(),
        )
        assert claimed is not None and claimed["state"] == "claimed"
        assert attach_agent_run_delivery_in_connection(
            conn,
            owner_run.id,
            session_id=session_id,
            delivery_id=str(claimed["id"]),
        )

    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        async with httpx.AsyncClient(
            transport=transport,
            base_url="http://testserver",
        ) as client:
            return await client.post(
                f"/internal/cancel/{session_id}",
                params={"run_id": owner_run.id},
            )

    response = asyncio.run(_go())

    assert response.status_code == 200
    assert response.json() == {
        "ok": True,
        "session_id": session_id,
        "status": "cancel_requested",
    }
    controller.command_handler.handle_stop.assert_not_awaited()
    saved = request_store.get_run(owner_run.id)
    assert saved is not None
    assert saved["status"] == "running"
    assert saved["cancel_requested"] is True
    with engine.connect() as conn:
        turn = message_deliveries.get_turn(conn, turn_id)
        delivery = message_deliveries.get_delivery(conn, str(delivery["id"]))
    assert turn is not None
    assert turn["state"] == "starting"
    assert turn["control_state"] == "pending"
    assert turn["control_mode"] == "stop_only"
    assert delivery is not None and delivery["state"] == "claimed"


def test_run_cancel_preserves_shared_starting_batch_siblings(monkeypatch, tmp_path):
    """Stopping an unwritten starting batch replays every surviving participant."""

    from core.scheduled_tasks import TaskExecutionStore
    from storage.background import attach_agent_run_delivery_in_connection

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(
        tmp_path,
        native_id="proj_shared_starting_run_cancel",
    )
    request_store = TaskExecutionStore()
    runs = [
        request_store.enqueue_agent_run(
            session_id=session["id"],
            message=message,
            agent_name="worker",
        )
        for message in ("canceled batch participant", "surviving batch participant")
    ]
    assert all(request_store.claim(run.id) is not None for run in runs)

    with engine.begin() as conn:
        deliveries = [
            _reserve_submission(
                conn,
                scope_id=session["scope_id"],
                session_id=session["id"],
                text=text,
            )
            for text in ("canceled batch participant", "surviving batch participant")
        ]
        turn_id = message_deliveries.new_turn_id()
        claimed = message_deliveries.claim_start_batch(
            conn,
            turn_id=turn_id,
            session_id=session["id"],
            backend="claude",
            deliveries=deliveries,
            dispatch_text="canceled batch participant\n\nsurviving batch participant",
        )
        for run, delivery in zip(runs, claimed["deliveries"], strict=True):
            assert attach_agent_run_delivery_in_connection(
                conn,
                run.id,
                session_id=session["id"],
                delivery_id=str(delivery["id"]),
            )
        assert message_deliveries.agent_run_input_reached_turn(
            conn,
            run_id=runs[0].id,
            turn_id=turn_id,
        ) == (True, "run_input_in_turn")

    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    manager = controller.session_turns
    transport = httpx.ASGITransport(app=app)
    dispatched: list[str] = []

    async def _record_start(_session_id, _context, text, **_kwargs):
        dispatched.append(text)

    monkeypatch.setattr(manager, "_run", _record_start)

    async def _go():
        async with httpx.AsyncClient(
            transport=transport,
            base_url="http://testserver",
        ) as client:
            response = await client.post(
                f"/internal/cancel/{session['id']}",
                params={"run_id": runs[0].id},
            )
        started_original = await manager._start_persisted_turn(
            turn_id,
            context=MessageContext(
                user_id="workbench",
                channel_id=session["id"],
                platform="avibe",
                platform_specific={"workbench_session_id": session["id"]},
            ),
        )
        return response, started_original

    response, started_original = asyncio.run(_go())

    assert response.status_code == 200
    assert response.json()["status"] == "cancel_requested"
    assert started_original is False
    assert dispatched == ["surviving batch participant"]
    assert request_store.get_run(runs[0].id)["status"] == "canceled"
    assert request_store.get_run(runs[1].id)["status"] == "running"
    with engine.connect() as conn:
        original = message_deliveries.get_turn(conn, turn_id)
        canceled = message_deliveries.get_delivery(
            conn,
            str(claimed["deliveries"][0]["id"]),
        )
        surviving = message_deliveries.get_delivery(
            conn,
            str(claimed["deliveries"][1]["id"]),
        )
    assert original is not None and original["terminal_outcome"] == "not_written"
    assert canceled is not None and canceled["state"] == "retired"
    assert surviving is not None and surviving["state"] == "claimed"
    assert surviving["turn_id"] != turn_id


def _prewrite_batch_with_absorbing_runner(monkeypatch, tmp_path, native_id):
    """Start a real two-Run pre-write batch whose dispatch absorbs cancellation."""

    from core.native_dispatch_phase import DISPATCH_PHASE_PREWRITE, set_dispatch_phase
    from core.scheduled_tasks import TaskExecutionStore
    from core.services.dispatch import TurnDispatchOutcome
    from storage.background import attach_agent_run_delivery_in_connection

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(tmp_path, native_id=native_id)
    session_id = session["id"]
    request_store = TaskExecutionStore()
    texts = ("canceled batch participant", "surviving batch participant")
    runs = [
        request_store.enqueue_agent_run(
            session_id=session_id,
            message=message,
            agent_name="worker",
        )
        for message in texts
    ]
    assert all(request_store.claim(run.id) is not None for run in runs)
    with engine.begin() as conn:
        deliveries = [
            _reserve_submission(
                conn,
                scope_id=session["scope_id"],
                session_id=session_id,
                text=text,
            )
            for text in texts
        ]
        turn_id = message_deliveries.new_turn_id()
        claimed = message_deliveries.claim_start_batch(
            conn,
            turn_id=turn_id,
            session_id=session_id,
            backend="claude",
            deliveries=deliveries,
            dispatch_text="\n\n".join(texts),
        )
        for run, delivery in zip(runs, claimed["deliveries"], strict=True):
            assert attach_agent_run_delivery_in_connection(
                conn,
                run.id,
                session_id=session_id,
                delivery_id=str(delivery["id"]),
            )

    controller = _build_controller_double()
    internal_server.create_app(controller)
    manager = controller.session_turns
    dispatch_entered = asyncio.Event()

    async def absorbing_prewrite_dispatch(_controller, dispatch_context, *_a, **_k):
        set_dispatch_phase(dispatch_context, DISPATCH_PHASE_PREWRITE)
        dispatch_entered.set()
        try:
            await asyncio.Event().wait()
        except asyncio.CancelledError:
            # OpenCode absorbs the inner cancellation after its cleanup.
            return TurnDispatchOutcome(
                error=None,
                settled_by=None,
                backend_dispatch_attempted=False,
            )

    monkeypatch.setattr(
        "core.session_turns.dispatch_turn_with_outcome",
        absorbing_prewrite_dispatch,
    )
    real_run = manager._run
    successor_starts: list[str] = []

    async def _run(run_session_id, run_context, text, **kwargs):
        if kwargs.get("logical_turn_id") == turn_id:
            return await real_run(run_session_id, run_context, text, **kwargs)
        successor_starts.append(text)

    monkeypatch.setattr(manager, "_run", _run)
    context = MessageContext(
        user_id="workbench",
        channel_id=session_id,
        platform="avibe",
        platform_specific={"workbench_session_id": session_id},
    )
    return SimpleNamespace(
        engine=engine,
        session_id=session_id,
        request_store=request_store,
        runs=runs,
        delivery_ids=[str(row["id"]) for row in claimed["deliveries"]],
        turn_id=turn_id,
        manager=manager,
        controller=controller,
        context=context,
        dispatch_entered=dispatch_entered,
        successor_starts=successor_starts,
    )


def test_run_cancel_of_a_prewrite_batch_stops_it_like_session_stop(
    monkeypatch,
    tmp_path,
):
    """A pre-write Run cancel retires the whole claimed batch, like Stop."""

    batch = _prewrite_batch_with_absorbing_runner(
        monkeypatch,
        tmp_path,
        "proj_absorbing_prewrite_run_cancel",
    )

    async def _go():
        assert await batch.manager._start_persisted_turn(
            batch.turn_id,
            context=batch.context,
        )
        await asyncio.wait_for(batch.dispatch_entered.wait(), timeout=1.0)
        return await batch.manager.cancel(
            batch.session_id,
            agent_run_id=batch.runs[0].id,
        )

    result = asyncio.run(_go())

    assert result == {
        "ok": True,
        "session_id": batch.session_id,
        "status": "cancel_requested",
        "reason": "prewrite_canceled",
    }
    batch.controller.command_handler.handle_stop.assert_not_awaited()
    assert batch.successor_starts == []
    assert batch.request_store.get_run(batch.runs[0].id)["status"] == "canceled"
    with batch.engine.connect() as conn:
        original = message_deliveries.get_turn(conn, batch.turn_id)
        states = [
            message_deliveries.get_delivery(conn, delivery_id)["state"]
            for delivery_id in batch.delivery_ids
        ]
    assert original is not None and original["terminal_outcome"] == "not_written"
    assert states == ["retired", "retired"]

def test_run_cancel_rechecks_a_changed_current_turn(monkeypatch, tmp_path):
    """A stale observed Turn cannot detach a Run that owns the current Turn."""

    from core.scheduled_tasks import TaskExecutionStore
    from storage.background import attach_agent_run_delivery_in_connection

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session, turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_changed_turn_run_cancel",
    )
    session_id = session["id"]
    request_store = TaskExecutionStore()
    owner_run = request_store.enqueue_agent_run(
        session_id=session_id,
        message="recovered current owner",
        agent_name="worker",
    )
    assert request_store.claim(owner_run.id) is not None
    with engine.begin() as conn:
        initial = message_deliveries.delivery_for_turn(conn, turn_id)
        assert initial is not None
        assert attach_agent_run_delivery_in_connection(
            conn,
            owner_run.id,
            session_id=session_id,
            delivery_id=str(initial["id"]),
        )

    controller = _build_controller_double()
    internal_server.create_app(controller)
    context = MessageContext(
        user_id="workbench",
        channel_id=session_id,
        platform="avibe",
        platform_specific={"workbench_session_id": session_id},
    )

    async def _go():
        holder = asyncio.create_task(asyncio.Event().wait())
        controller.session_turns.in_flight[session_id] = session_turns.Turn(
            task=holder,
            context=context,
            logical_turn_id=turn_id,
        )
        try:
            return await controller.session_turns.deliver(
                session_turns.DeliveryRequest(
                    session_id=session_id,
                    priority="p0",
                    content=None,
                    expected_turn_id="trn_recovered_predecessor",
                    cancel_agent_run_id=owner_run.id,
                ),
                context=context,
            )
        finally:
            holder.cancel()
            await asyncio.gather(holder, return_exceptions=True)

    result = asyncio.run(_go())

    assert result.state == "waiting_terminal"
    controller.command_handler.handle_stop.assert_awaited_once()
    saved = request_store.get_run(owner_run.id)
    assert saved is not None
    assert saved["status"] == "running"
    assert saved["cancel_requested"] is True
    with engine.connect() as conn:
        turn = message_deliveries.get_turn(conn, turn_id)
    assert turn is not None
    assert turn["control_state"] == "waiting_terminal"


def test_run_cancel_without_an_active_turn_settles_atomically(monkeypatch, tmp_path):
    """An orphaned live projection is canceled without inventing a Session Stop."""

    from core.scheduled_tasks import TaskExecutionStore

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    _engine, session = _create_test_session(
        tmp_path,
        native_id="proj_ownerless_run_cancel",
    )
    request_store = TaskExecutionStore()
    run = request_store.enqueue_agent_run(
        session_id=session["id"],
        message="orphaned live projection",
        agent_name="worker",
        callback_session_id="ses_callback",
    )
    assert request_store.claim(run.id) is not None

    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        async with httpx.AsyncClient(
            transport=transport,
            base_url="http://testserver",
        ) as client:
            return await client.post(
                f"/internal/cancel/{session['id']}",
                params={"run_id": run.id},
            )

    response = asyncio.run(_go())

    assert response.status_code == 200
    assert response.json() == {
        "ok": True,
        "session_id": session["id"],
        "status": "run_detached",
        "reason": "run_detached",
    }
    controller.command_handler.handle_stop.assert_not_awaited()
    saved = request_store.get_run(run.id)
    assert saved is not None
    assert saved["status"] == "canceled"
    assert saved["callback_status"] == "skipped"
    assert request_store.list_pending_callbacks() == []


def test_run_cancel_retires_every_pre_native_delivery_atomically(monkeypatch, tmp_path):
    """A canceled Run cannot leave any not-yet-written input eligible to dispatch."""

    from core.inbox_events import bus
    from core.scheduled_tasks import TaskExecutionStore
    from storage.background import attach_agent_run_delivery_in_connection
    from storage.delivery_states import RUN_CANCEL_RETIRE_STATES

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session, turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_pre_native_run_cancel",
    )
    session_id = session["id"]
    request_store = TaskExecutionStore()
    runs_and_deliveries: list[tuple[str, str]] = []
    runs_by_state = []
    for delivery_state in RUN_CANCEL_RETIRE_STATES:
        run = request_store.enqueue_agent_run(
            session_id=session_id,
            message=f"cancel {delivery_state} input",
            agent_name="worker",
            callback_session_id="ses_callback",
        )
        assert request_store.claim(run.id) is not None
        runs_by_state.append((delivery_state, run))

    with engine.begin() as conn:
        for delivery_state, run in runs_by_state:
            delivery = _reserve_submission(
                conn,
                scope_id=session["scope_id"],
                session_id=session_id,
                text=f"cancel {delivery_state} input",
            )
            if delivery_state == "queued":
                delivery = message_deliveries.cas_delivery(
                    conn,
                    str(delivery["id"]),
                    expected_version=int(delivery["version"]),
                    expected_states=("reserved",),
                    values={"state": "queued"},
                )
                assert delivery is not None
            elif delivery_state == "pending_steer":
                pending = message_deliveries.open_pending_steer_batch(
                    conn,
                    deliveries=[delivery],
                    turn_id=turn_id,
                    attempt_id=message_deliveries.new_attempt_id(),
                )
                assert len(pending) == 1
                delivery = pending[0]
            else:
                assert delivery_state == "reserved"
            assert attach_agent_run_delivery_in_connection(
                conn,
                run.id,
                session_id=session_id,
                delivery_id=str(delivery["id"]),
            )
            runs_and_deliveries.append((run.id, str(delivery["id"])))

    published: list[tuple[str, dict]] = []
    monkeypatch.setattr(
        bus,
        "publish",
        lambda event, payload: published.append((event, payload)),
    )
    controller = _build_controller_double()
    app = internal_server.create_app(controller)
    transport = httpx.ASGITransport(app=app)

    async def _go():
        async with httpx.AsyncClient(
            transport=transport,
            base_url="http://testserver",
        ) as client:
            return [
                await client.post(
                    f"/internal/cancel/{session_id}",
                    params={"run_id": run_id},
                )
                for run_id, _delivery_id in runs_and_deliveries
            ]

    responses = asyncio.run(_go())

    assert all(response.status_code == 200 for response in responses)
    assert [response.json()["status"] for response in responses] == [
        "run_detached"
    ] * len(RUN_CANCEL_RETIRE_STATES)
    controller.command_handler.handle_stop.assert_not_awaited()
    with engine.connect() as conn:
        retired = [
            message_deliveries.get_delivery(conn, delivery_id)
            for _run_id, delivery_id in runs_and_deliveries
        ]
    assert [row["state"] for row in retired] == [
        "retired"
    ] * len(RUN_CANCEL_RETIRE_STATES)
    assert all(row["current_attempt_id"] is None for row in retired)
    assert all(row["current_target_turn_id"] is None for row in retired)
    for run_id, _delivery_id in runs_and_deliveries:
        saved = request_store.get_run(run_id)
        assert saved is not None
        assert saved["status"] == "canceled"
        assert saved["callback_status"] == "skipped"
    assert request_store.list_pending_callbacks() == []
    assert published.count(("queue.updated", {"session_id": session_id})) == len(
        RUN_CANCEL_RETIRE_STATES
    )


def test_run_cancel_guard_allows_the_sole_initial_run_owner(monkeypatch, tmp_path):
    """A Run remains allowed to stop the backend when it owns the whole Turn."""

    from core.scheduled_tasks import TaskExecutionStore
    from storage.background import attach_agent_run_delivery_in_connection

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session, turn_id = _create_active_test_turn(
        tmp_path,
        native_id="proj_exclusive_run_cancel",
    )
    request_store = TaskExecutionStore()
    run = request_store.enqueue_agent_run(
        session_id=session["id"],
        message="sole initial participant",
        agent_name="worker",
    )
    assert request_store.claim(run.id) is not None

    with engine.begin() as conn:
        initial = message_deliveries.delivery_for_turn(conn, turn_id)
        assert initial is not None
        assert attach_agent_run_delivery_in_connection(
            conn,
            run.id,
            session_id=session["id"],
            delivery_id=initial["id"],
        )
        assert message_deliveries.agent_run_input_reached_turn(
            conn,
            run_id=run.id,
            turn_id=turn_id,
        ) == (True, "run_input_in_turn")


# --- #84: scheduled provenance survives the merge-queue --------------------------


def _seed_avibe_session_with_queue(queued):
    """Create an isolated Session and seed independent Deliveries oldest first."""
    from core.services import sessions as sessions_service
    from storage import message_deliveries
    from storage.background import attach_agent_run_delivery_in_connection
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from storage.models import agent_runs
    from storage.settings_service import upsert_scope
    from sqlalchemy import update

    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        scope_id = upsert_scope(
            conn, platform="avibe", scope_type="project", native_id="proj_q84", now="2026-05-31T00:00:00Z"
        )
        _seed_project_workdir(conn, scope_id, Path.cwd())
        session = sessions_service.create_session(
            conn, scope_id=scope_id, agent_backend="claude", agent_name="worker"
        )
        for text, prov in queued:
            delivery = message_deliveries.enqueue_queued(
                conn,
                scope_id=scope_id,
                session_id=session["id"],
                platform="avibe",
                author=("harness" if prov is not None else "user"),
                source=("harness" if prov is not None else "user"),
                message_type=("harness" if prov is not None else "user"),
                text=text,
                metadata=({session_turns.SCHEDULED_PROVENANCE_KEY: prov} if prov is not None else None),
                native_message_id=(prov or {}).get("message_id") if prov is not None else None,
            )
            spec = (prov or {}).get("platform_specific") or {}
            run_id = str(spec.get("task_execution_id") or "").strip()
            if run_id and conn.execute(
                select(agent_runs.c.id).where(agent_runs.c.id == run_id)
            ).scalar_one_or_none():
                conn.execute(
                    update(agent_runs)
                    .where(agent_runs.c.id == run_id)
                    .values(session_id=session["id"])
                )
                assert attach_agent_run_delivery_in_connection(
                    conn,
                    run_id,
                    session_id=session["id"],
                    delivery_id=str(delivery["id"]),
                )
    return session["id"]


def _manager_capturing_runs():
    """A SessionTurnManager whose ``_run`` records each flushed turn's (text, source,
    suppress_delivery) instead of dispatching."""
    runs: list = []
    mgr = session_turns.SessionTurnManager(
        controller=types.SimpleNamespace(),
        build_context=lambda sid: MessageContext(
            user_id="U", channel_id="C", platform="avibe", platform_specific={"agent_session_id": sid}
        ),
    )

    async def _fake_run(sid, context, text, *, source=SOURCE_HUMAN, **_kwargs):
        runs.append((text, source, context))

    mgr._run = _fake_run
    return mgr, runs


def _manager_accepting_runs():
    """Capture durable starts while simulating exact native acceptance."""

    manager, runs = _manager_capturing_runs()

    async def _accept(
        sid,
        context,
        text,
        *,
        source=SOURCE_HUMAN,
        logical_turn_id=None,
        delivery_id=None,
        **_kwargs,
    ):
        runs.append((text, source, context))
        _bind_test_native_start(manager._sqlite_engine(), context)
        with manager._sqlite_engine().begin() as conn:
            accepted = message_deliveries.materialize_start_acceptance(
                conn,
                turn_id=logical_turn_id,
                evidence={"kind": "test_native_acceptance"},
            )
            assert accepted
        manager._publish_materialized_delivery(delivery_id)
        settled = manager._terminalize_durable_turn(
            logical_turn_id,
            "completed",
            settled_by="test",
            evidence_kind="test_native_terminal",
        )
        assert settled["changed"] is True

    manager._run = _accept
    return manager, runs


def test_flush_runs_authorized_remote_fifo_head(
    tmp_path,
    monkeypatch,
):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(
        tmp_path,
        native_id="proj_remote_queue_retirement",
    )
    _seed_remote_worker()
    with engine.begin() as conn:
        remote = message_deliveries.enqueue_queued(
            conn,
            scope_id=session["scope_id"],
            session_id=session["id"],
            text="remote queued input",
            metadata=_authorized_remote_message_metadata(),
            author_id="remote-user",
            message_kind="original",
        )
        local = message_deliveries.enqueue_queued(
            conn,
            scope_id=session["scope_id"],
            session_id=session["id"],
            text="local queued input",
            author_id="local",
            message_kind="original",
        )

    manager, runs = _manager_accepting_runs()
    assert asyncio.run(manager.flush_queue(session["id"])) is True

    assert [(text, source) for text, source, _context in runs] == [
        ("remote queued input", SOURCE_HUMAN),
    ]
    with engine.connect() as conn:
        remote_saved = message_deliveries.get_delivery(conn, remote["id"])
        local_saved = message_deliveries.get_delivery(conn, local["id"])
    assert remote_saved is not None
    assert remote_saved["state"] == "accepted"
    assert local_saved is not None
    assert local_saved["state"] == "claimed"


def test_claimed_authorized_remote_turn_reaches_native_dispatch(
    tmp_path,
    monkeypatch,
):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(
        tmp_path,
        native_id="proj_remote_claimed_turn",
    )
    _seed_remote_worker()
    turn_id = message_deliveries.new_turn_id()
    with engine.begin() as conn:
        queued = message_deliveries.enqueue_queued(
            conn,
            scope_id=session["scope_id"],
            session_id=session["id"],
            text="claimed remote input",
            metadata=_authorized_remote_message_metadata(),
        )
        row = message_deliveries.get_delivery(conn, queued["id"])
        assert row is not None
        message_deliveries.claim_start_batch(
            conn,
            turn_id=turn_id,
            session_id=session["id"],
            backend="claude",
            deliveries=[row],
            dispatch_text="claimed remote input",
        )

    manager = session_turns.SessionTurnManager(
        controller=types.SimpleNamespace(),
        build_context=lambda sid: MessageContext(
            user_id="U",
            channel_id="C",
            platform="avibe",
            platform_specific={"agent_session_id": sid},
        ),
    )

    runs = []

    async def capture_run(_session_id, _context, text, **_kwargs):
        runs.append(text)

    manager._run = capture_run
    assert asyncio.run(manager._start_persisted_turn(turn_id)) is True
    assert runs == ["claimed remote input"]

    with engine.connect() as conn:
        saved_turn = message_deliveries.get_turn(conn, turn_id)
        saved_delivery = message_deliveries.get_delivery(conn, queued["id"])
    assert saved_turn is not None
    assert saved_turn["state"] == "starting"
    assert saved_delivery is not None
    assert saved_delivery["state"] == "claimed"
def test_flush_runs_scheduled_row_as_scheduled_with_provenance(tmp_path, monkeypatch):
    """A queued scheduled run flushes as its OWN SOURCE_SCHEDULED turn with its
    delivery provenance restored — not merged into a plain user turn (#84)."""
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    override = {"channel_id": "slack-321", "platform": "slack"}
    session_id = _seed_avibe_session_with_queue(
        [(
            "scheduled prompt",
            {
                "message_id": "scheduled:exec-1",
                "platform_specific": {
                    "suppress_delivery": True,
                    "delivery_override": override,
                    "task_trigger_kind": "task",
                },
            },
        )]
    )
    mgr, runs = _manager_capturing_runs()

    assert asyncio.run(mgr.flush_queue(session_id)) is True
    assert len(runs) == 1
    text, source, ctx = runs[0]
    # Ran as scheduled (not user), with the FULL provenance restored: the delivery
    # override (the redirect _get_target_context uses) + suppress_delivery (#84 / P1)
    # AND the stable scheduled native id for dedup (P2).
    assert (text, source) == ("scheduled prompt", SOURCE_SCHEDULED)
    assert ctx.platform_specific["suppress_delivery"] is True
    assert ctx.platform_specific["delivery_override"] == override
    assert ctx.message_id == "scheduled:exec-1"

    from storage import messages_service
    from storage.db import create_sqlite_engine

    with create_sqlite_engine().begin() as conn:
        assert message_deliveries.list_queued(conn, session_id) == []


def test_flush_merges_compatible_scheduled_deliveries_into_one_turn(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))

    def prov(execution_id: str, message_id: str = "watch:def-watch") -> dict:
        return {
            "message_id": message_id,
            "platform_specific": {
                "task_execution_id": execution_id,
                "task_trigger_kind": "watch",
                "task_definition_id": "def-watch",
            },
        }

    session_id = _seed_avibe_session_with_queue(
        [
            ("first callback", prov("run-1", "watch:def-watch:run-1")),
            ("second callback", prov("run-2", "watch:def-watch:run-2")),
            ("third callback", prov("run-3", "watch:def-watch:run-3")),
        ]
    )

    from storage.db import create_sqlite_engine

    with create_sqlite_engine().begin() as conn:
        assert [row["text"] for row in message_deliveries.list_queued(conn, session_id)] == [
            "first callback",
            "second callback",
            "third callback",
        ]

    mgr, runs = _manager_capturing_runs()

    assert asyncio.run(mgr.flush_queue(session_id)) is True
    assert len(runs) == 1
    text, source, ctx = runs[0]
    assert source == SOURCE_SCHEDULED
    assert text == "first callback\n\n---\n\nsecond callback\n\n---\n\nthird callback"
    assert ctx.platform_specific["task_definition_id"] == "def-watch"
    assert len(ctx.platform_specific["delivery_ids"]) == 3
    with create_sqlite_engine().begin() as conn:
        assert message_deliveries.list_queued(conn, session_id) == []


def test_flush_claims_compatible_agent_run_deliveries_as_one_turn(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))

    from core.scheduled_tasks import TaskExecutionStore
    from storage.background import SQLiteBackgroundTaskStore
    from storage.db import create_sqlite_engine

    request_store = TaskExecutionStore()

    def prov(execution_id: str) -> dict:
        return {
            "message_id": f"agent_run:{execution_id}",
            "platform_specific": {
                "task_execution_id": execution_id,
                "task_trigger_kind": "agent_run",
                "task_definition_id": None,
                "vibe_agent_name": "codex",
                "source_kind": None,
                "callback_session_id": None,
            },
        }

    queued: list[tuple[str, dict]] = []
    for index in range(4):
        request = request_store.enqueue_agent_run(
            session_id="placeholder",
            message=f"cli agent message {index + 1}",
            agent_name="codex",
        )
        assert request_store.claim(request.id) is not None
        request_store.requeue(request.id)
        queued.append((f"cli agent message {index + 1}", prov(request.id)))

    session_id = _seed_avibe_session_with_queue(queued)

    from storage.db import create_sqlite_engine

    mgr, runs = _manager_capturing_runs()

    assert asyncio.run(mgr.flush_queue(session_id)) is True
    assert len(runs) == 1
    text, source, ctx = runs[0]
    assert source == SOURCE_SCHEDULED
    assert text == (
        "cli agent message 1\n\n---\n\ncli agent message 2\n\n---\n\n"
        "cli agent message 3\n\n---\n\ncli agent message 4"
    )
    execution_ids = [item[1]["platform_specific"]["task_execution_id"] for item in queued]
    assert ctx.platform_specific["task_execution_id"] == execution_ids[0]
    assert ctx.platform_specific["accepted_agent_run_ids"] == execution_ids

    bg = SQLiteBackgroundTaskStore()
    try:
        stored = {run_id: bg.get_run(run_id) for run_id in execution_ids}
    finally:
        bg.close()

    assert [stored[run_id]["status"] for run_id in execution_ids] == ["running"] * 4
    assert len({stored[run_id]["delivery_id"] for run_id in execution_ids}) == 4
    assert all(stored[run_id]["delivery_id"] for run_id in execution_ids)
    assert all(
        "workbench_queue_holds_run" not in stored[run_id]["metadata"]
        for run_id in execution_ids
    )
    with create_sqlite_engine().connect() as conn:
        assert message_deliveries.list_queued(conn, session_id) == []


def test_flush_background_agent_run_preserves_primary_prompt(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))

    from core.scheduled_tasks import TaskExecutionStore
    from storage.db import create_sqlite_engine
    from storage.models import messages

    request_store = TaskExecutionStore()
    request = request_store.enqueue_agent_run(
        session_id="placeholder",
        message="background prompt",
        agent_name="codex",
    )
    assert request_store.claim(request.id) is not None
    request_store.requeue(request.id)
    session_id = _seed_avibe_session_with_queue(
        [
            (
                "background prompt",
                {
                    "message_id": f"agent_run:{request.id}",
                    "platform_specific": {
                        "task_execution_id": request.id,
                        "task_trigger_kind": "agent_run",
                        "task_definition_id": None,
                        "vibe_agent_name": "codex",
                        "suppress_delivery": True,
                    },
                },
            )
        ]
    )
    mgr, runs = _manager_capturing_runs()

    async def _accept_run(
        sid,
        context,
        text,
        *,
        source=SOURCE_HUMAN,
        logical_turn_id=None,
        delivery_id=None,
        **_kwargs,
    ):
        _bind_test_native_start(mgr._sqlite_engine(), context)
        with mgr._sqlite_engine().begin() as conn:
            accepted = message_deliveries.materialize_start_acceptance(
                conn,
                turn_id=logical_turn_id,
                evidence={"kind": "test_native_acceptance"},
            )
            assert accepted
        runs.append((text, source, context))

    mgr._run = _accept_run

    assert asyncio.run(mgr.flush_queue(session_id)) is True
    assert len(runs) == 1
    with create_sqlite_engine().connect() as conn:
        rows = conn.execute(
            select(messages).where(messages.c.session_id == session_id)
        ).mappings().all()

    harness_rows = [row for row in rows if row["type"] == "harness"]
    assert [(row["native_message_id"], row["content_text"]) for row in harness_rows] == [
        (f"agent_run:{request.id}", "background prompt")
    ]
    assert len(rows) == 1


def test_cancel_retires_exact_agent_run_delivery_without_reordering_survivors(
    tmp_path,
    monkeypatch,
):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))

    from core.scheduled_tasks import TaskExecutionStore
    from storage.background import SQLiteBackgroundTaskStore

    request_store = TaskExecutionStore()

    def prov(execution_id: str) -> dict:
        return {
            "message_id": f"agent_run:{execution_id}",
            "platform_specific": {
                "task_execution_id": execution_id,
                "task_trigger_kind": "agent_run",
                "task_definition_id": None,
                "vibe_agent_name": "codex",
                "source_kind": None,
                "callback_session_id": None,
            },
        }

    queued: list[tuple[str, dict]] = []
    run_ids: list[str] = []
    for index in range(3):
        request = request_store.enqueue_agent_run(
            session_id="placeholder",
            message=f"cli agent message {index + 1}",
            agent_name="codex",
        )
        assert request_store.claim(request.id) is not None
        request_store.requeue(request.id)
        queued.append((f"cli agent message {index + 1}", prov(request.id)))
        run_ids.append(request.id)

    session_id = _seed_avibe_session_with_queue(queued)

    from storage.db import create_sqlite_engine

    from core.inbox_events import bus

    published: list[tuple[str, dict]] = []
    monkeypatch.setattr(bus, "publish", lambda event, payload: published.append((event, payload)))

    bg = SQLiteBackgroundTaskStore()
    try:
        assert bg.cancel_run(run_ids[1]) is True
    finally:
        bg.close()

    mgr, runs = _manager_capturing_runs()

    assert asyncio.run(mgr.flush_queue(session_id)) is True
    assert len(runs) == 1
    text, source, ctx = runs[0]
    assert source == SOURCE_SCHEDULED
    assert text == "cli agent message 1\n\n---\n\ncli agent message 3"
    assert ctx.platform_specific["task_execution_id"] == run_ids[0]
    assert ctx.platform_specific["accepted_agent_run_ids"] == [
        run_ids[0],
        run_ids[2],
    ]

    with create_sqlite_engine().begin() as conn:
        assert message_deliveries.list_queued(conn, session_id) == []

    bg = SQLiteBackgroundTaskStore()
    try:
        stored = {run_id: bg.get_run(run_id) for run_id in run_ids}
    finally:
        bg.close()

    assert stored[run_ids[0]]["status"] == "running"
    assert stored[run_ids[1]]["status"] == "canceled"
    assert stored[run_ids[2]]["status"] == "running"
    assert len({stored[run_ids[0]]["delivery_id"], stored[run_ids[2]]["delivery_id"]}) == 2
    with create_sqlite_engine().connect() as conn:
        canceled_delivery = message_deliveries.get_delivery(
            conn,
            stored[run_ids[1]]["delivery_id"],
        )
    assert canceled_delivery is not None
    assert canceled_delivery["state"] == "retired"
    assert published.count(("queue.updated", {"session_id": session_id})) >= 1


def test_turn_claim_retires_terminal_agent_run_and_dispatches_the_rest(tmp_path, monkeypatch):
    """A Run terminalized behind its Delivery's back must not brick the flush.

    ``cancel_run`` retires the Delivery itself, but a Run can also settle without
    that path — a watch fire whose Run ended ``failed``, or a crash between the
    two writes. The claim path then converges on the same outcome as the proper
    cancellation above instead of raising and crash-looping the controller.
    """

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))

    from core.scheduled_tasks import TaskExecutionStore
    from storage.background import SQLiteBackgroundTaskStore
    from storage.db import create_sqlite_engine
    from storage.models import agent_runs
    from sqlalchemy import update

    request_store = TaskExecutionStore()

    def prov(execution_id: str) -> dict:
        return {
            "message_id": f"agent_run:{execution_id}",
            "platform_specific": {
                "task_execution_id": execution_id,
                "task_trigger_kind": "agent_run",
                "task_definition_id": None,
                "vibe_agent_name": "codex",
                "source_kind": None,
                "callback_session_id": None,
            },
        }

    queued: list[tuple[str, dict]] = []
    run_ids: list[str] = []
    for index in range(3):
        request = request_store.enqueue_agent_run(
            session_id="placeholder",
            message=f"cli agent message {index + 1}",
            agent_name="codex",
        )
        assert request_store.claim(request.id) is not None
        request_store.requeue(request.id)
        queued.append((f"cli agent message {index + 1}", prov(request.id)))
        run_ids.append(request.id)

    session_id = _seed_avibe_session_with_queue(queued)
    with create_sqlite_engine().begin() as conn:
        conn.execute(
            update(agent_runs)
            .where(agent_runs.c.id == run_ids[1])
            .values(
                status="canceled",
                cancel_requested=1,
                completed_at="2026-06-22T00:00:10Z",
            )
        )

    mgr, runs = _manager_capturing_runs()

    assert asyncio.run(mgr.flush_queue(session_id)) is True
    assert len(runs) == 1
    text, _source, ctx = runs[0]
    assert text == "cli agent message 1\n\n---\n\ncli agent message 3"
    assert ctx.platform_specific["accepted_agent_run_ids"] == [
        run_ids[0],
        run_ids[2],
    ]

    bg = SQLiteBackgroundTaskStore()
    try:
        stored = {run_id: bg.get_run(run_id) for run_id in run_ids}
    finally:
        bg.close()

    assert stored[run_ids[0]]["status"] == "running"
    assert stored[run_ids[1]]["status"] == "canceled"
    assert stored[run_ids[2]]["status"] == "running"
    with mgr._sqlite_engine().connect() as conn:
        assert message_deliveries.list_queued(conn, session_id) == []
        retired = message_deliveries.get_delivery(
            conn,
            stored[run_ids[1]]["delivery_id"],
        )
    assert retired is not None
    assert retired["state"] == "retired"


def test_flush_merges_agent_runs_with_different_callback_targets(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))

    from core.scheduled_tasks import TaskExecutionStore

    request_store = TaskExecutionStore()

    def prov(execution_id: str, callback_session_id: str) -> dict:
        return {
            "message_id": f"agent_run:{execution_id}",
            "platform_specific": {
                "task_execution_id": execution_id,
                "task_trigger_kind": "agent_run",
                "task_definition_id": None,
                "vibe_agent_name": "codex",
                "callback_session_id": callback_session_id,
            },
        }

    queued: list[tuple[str, dict]] = []
    for index, callback_session_id in enumerate(["caller-a", "caller-b"]):
        request = request_store.enqueue_agent_run(
            session_id="placeholder",
            message=f"cli agent message {index + 1}",
            agent_name="codex",
            callback_session_id=callback_session_id,
        )
        assert request_store.claim(request.id) is not None
        request_store.requeue(request.id)
        queued.append((f"cli agent message {index + 1}", prov(request.id, callback_session_id)))

    session_id = _seed_avibe_session_with_queue(queued)

    mgr, runs = _manager_capturing_runs()

    assert asyncio.run(mgr.flush_queue(session_id)) is True
    assert len(runs) == 1
    text, source, ctx = runs[0]
    assert source == SOURCE_SCHEDULED
    assert text == "cli agent message 1\n\n---\n\ncli agent message 2"
    assert len(ctx.platform_specific["accepted_agent_run_ids"]) == 2
    assert "coalesced_queue" not in ctx.platform_specific
    with mgr._sqlite_engine().connect() as conn:
        assert message_deliveries.list_queued(conn, session_id) == []


def test_flush_merges_callback_backed_agent_runs_by_delivery_compatibility(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))

    from core.scheduled_tasks import TaskExecutionStore

    request_store = TaskExecutionStore()

    def prov(execution_id: str) -> dict:
        return {
            "message_id": f"agent_run:{execution_id}",
            "platform_specific": {
                "task_execution_id": execution_id,
                "task_trigger_kind": "agent_run",
                "task_definition_id": None,
                "vibe_agent_name": "codex",
                "callback_session_id": "same-caller",
            },
        }

    queued: list[tuple[str, dict]] = []
    for index in range(2):
        request = request_store.enqueue_agent_run(
            session_id="placeholder",
            message=f"callback agent message {index + 1}",
            agent_name="codex",
            callback_session_id="same-caller",
        )
        assert request_store.claim(request.id) is not None
        request_store.requeue(request.id)
        queued.append((f"callback agent message {index + 1}", prov(request.id)))

    session_id = _seed_avibe_session_with_queue(queued)

    mgr, runs = _manager_capturing_runs()

    assert asyncio.run(mgr.flush_queue(session_id)) is True
    assert len(runs) == 1
    text, source, ctx = runs[0]
    assert source == SOURCE_SCHEDULED
    assert text == "callback agent message 1\n\n---\n\ncallback agent message 2"
    assert len(ctx.platform_specific["accepted_agent_run_ids"]) == 2
    assert "coalesced_queue" not in ctx.platform_specific


def test_flush_merges_agent_runs_without_redundant_provenance_metadata(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))

    from core.scheduled_tasks import TaskExecutionStore

    request_store = TaskExecutionStore()

    def prov(execution_id: str) -> dict:
        return {
            "message_id": f"agent_run:{execution_id}",
            "platform_specific": {
                "task_execution_id": execution_id,
                "task_trigger_kind": "agent_run",
                "task_definition_id": None,
                "vibe_agent_name": "codex",
            },
        }

    queued: list[tuple[str, dict]] = []
    for index in range(2):
        request = request_store.enqueue_agent_run(
            session_id="placeholder",
            message=f"legacy callback message {index + 1}",
            agent_name="codex",
            callback_session_id=f"caller-{index + 1}",
        )
        assert request_store.claim(request.id) is not None
        request_store.requeue(request.id)
        queued.append((f"legacy callback message {index + 1}", prov(request.id)))

    session_id = _seed_avibe_session_with_queue(queued)

    mgr, runs = _manager_capturing_runs()

    assert asyncio.run(mgr.flush_queue(session_id)) is True
    assert len(runs) == 1
    text, source, ctx = runs[0]
    assert source == SOURCE_SCHEDULED
    assert text == "legacy callback message 1\n\n---\n\nlegacy callback message 2"
    assert len(ctx.platform_specific["accepted_agent_run_ids"]) == 2
    assert "coalesced_queue" not in ctx.platform_specific


def test_flush_does_not_claim_agent_runs_when_context_build_fails(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))

    from core.scheduled_tasks import TaskExecutionStore
    from storage.background import SQLiteBackgroundTaskStore

    request_store = TaskExecutionStore()

    def prov(execution_id: str) -> dict:
        return {
            "message_id": f"agent_run:{execution_id}",
            "platform_specific": {
                "task_execution_id": execution_id,
                "task_trigger_kind": "agent_run",
                "task_definition_id": None,
                "vibe_agent_name": "codex",
                "source_kind": None,
                "callback_session_id": None,
            },
        }

    queued: list[tuple[str, dict]] = []
    run_ids: list[str] = []
    for index in range(2):
        request = request_store.enqueue_agent_run(
            session_id="placeholder",
            message=f"cli agent message {index + 1}",
            agent_name="codex",
        )
        assert request_store.claim(request.id) is not None
        request_store.requeue(request.id)
        queued.append((f"cli agent message {index + 1}", prov(request.id)))
        run_ids.append(request.id)

    session_id = _seed_avibe_session_with_queue(queued)

    mgr = session_turns.SessionTurnManager(
        controller=types.SimpleNamespace(),
        build_context=lambda _sid: (_ for _ in ()).throw(RuntimeError("context unavailable")),
    )

    assert asyncio.run(mgr.flush_queue(session_id)) is False

    from storage.db import create_sqlite_engine

    with create_sqlite_engine().begin() as conn:
        queued_rows = message_deliveries.list_queued(conn, session_id)
    assert [row["text"] for row in queued_rows] == ["cli agent message 1", "cli agent message 2"]

    bg = SQLiteBackgroundTaskStore()
    try:
        stored = {run_id: bg.get_run(run_id) for run_id in run_ids}
    finally:
        bg.close()

    assert {row["status"] for row in stored.values()} == {"running"}
    assert all(row["delivery_id"] for row in stored.values())


def test_flush_quarantines_agent_run_when_native_start_may_have_written(
    tmp_path,
    monkeypatch,
):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))

    from core.scheduled_tasks import TaskExecutionStore
    from storage.background import SQLiteBackgroundTaskStore

    request_store = TaskExecutionStore()

    def prov(execution_id: str) -> dict:
        return {
            "message_id": f"agent_run:{execution_id}",
            "platform_specific": {
                "task_execution_id": execution_id,
                "task_trigger_kind": "agent_run",
                "task_definition_id": None,
                "vibe_agent_name": "codex",
            },
        }

    queued: list[tuple[str, dict]] = []
    run_ids: list[str] = []
    for index in range(2):
        request = request_store.enqueue_agent_run(
            session_id="placeholder",
            message=f"cli agent message {index + 1}",
            agent_name="codex",
        )
        assert request_store.claim(request.id) is not None
        request_store.requeue(request.id)
        queued.append((f"cli agent message {index + 1}", prov(request.id)))
        run_ids.append(request.id)

    session_id = _seed_avibe_session_with_queue(queued)
    mgr, _runs = _manager_capturing_runs()

    async def _failing_run(*_args, **_kwargs):
        raise RuntimeError("dispatch did not start")

    mgr._run = _failing_run

    assert asyncio.run(mgr.flush_queue(session_id)) is False

    from storage.db import create_sqlite_engine

    with create_sqlite_engine().begin() as conn:
        queued_rows = message_deliveries.list_queued(conn, session_id)
        unresolved_turn = message_deliveries.active_turn(conn, session_id)
        assert unresolved_turn is not None
        unresolved_batch = message_deliveries.initial_deliveries_for_turn(
            conn,
            unresolved_turn["id"],
        )
    assert queued_rows == []
    assert unresolved_turn["start_receipt_outcome"] == "unknown"
    assert [row["state"] for row in unresolved_batch] == ["claimed", "claimed"]

    bg = SQLiteBackgroundTaskStore()
    try:
        stored = {run_id: bg.get_run(run_id) for run_id in run_ids}
    finally:
        bg.close()

    assert [stored[run_id]["status"] for run_id in run_ids] == ["running", "running"]
    assert len({stored[run_id]["delivery_id"] for run_id in run_ids}) == 2


def test_flush_suppressed_segment_claims_each_delivery_id_in_one_turn(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))

    def prov(execution_id: str, instruction: str) -> dict:
        return {
            "message_id": f"watch:def-watch:{execution_id}",
            "platform_specific": {
                "task_execution_id": execution_id,
                "task_trigger_kind": "watch",
                "task_definition_id": "def-watch",
                "harness_display_prompt": instruction,
                "suppress_delivery": True,
            },
        }

    session_id = _seed_avibe_session_with_queue(
        [
            ("first callback", prov("run-1", "watch the deploy")),
            ("second callback", prov("run-2", "watch the deploy and page me")),
        ]
    )

    from storage.db import create_sqlite_engine

    mgr, runs = _manager_capturing_runs()

    assert asyncio.run(mgr.flush_queue(session_id)) is True
    assert len(runs) == 1
    assert runs[0][2].message_id == "watch:def-watch:run-1"
    assert len(runs[0][2].platform_specific["delivery_ids"]) == 2
    # Every merged Delivery's display snapshot travels with the context. The dispatch
    # text carries BOTH prompts, so a consumer that reads the singular ``display_text``
    # (the IM prompt echo) would announce one instruction for a two-prompt result.
    assert runs[0][2].platform_specific["display_texts"] == [
        "first callback",
        "second callback",
    ]
    # Same for the composed kinds, whose echo shows the stored instruction instead of
    # the snapshot: an instruction edited between the two firings leaves the merged
    # batch dispatching both, so each Delivery's own stamped instruction travels too.
    assert runs[0][2].platform_specific["harness_display_prompts"] == [
        "watch the deploy",
        "watch the deploy and page me",
    ]
    with create_sqlite_engine().begin() as conn:
        assert message_deliveries.list_queued(conn, session_id) == []


@pytest.mark.parametrize(
    ("trigger", "spec", "expected"),
    [
        pytest.param(
            "agent_run", {"source_kind": "agent", "source_actor": "sescaller01"},
            "[Harness: agent run run-1 from #sescaller01; agent run run-2 from #sescaller01]",
            id="agent-runs-from-one-caller",
        ),
        pytest.param(
            "agent_run", {"source_kind": "callback", "source_session_id": "seschild01"},
            "[Harness: callback of run run-1 from #seschild01; callback of run run-2 from #seschild01]",
            id="callbacks-from-one-session",
        ),
        pytest.param(
            "watch", {"task_definition_id": "def-watch", "task_definition_name": "deploy"},
            '[Harness: Watch def-watch "deploy"]',
            id="firings-of-one-watch",
        ),
    ],
)
def test_flush_merged_batch_names_each_bodys_sender(tmp_path, monkeypatch, trigger, spec, expected):
    """A merged batch's Harness line attributes every body, not only the leader's."""
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    from core.handlers.message_handler import MessageHandler

    def prov(execution_id: str) -> dict:
        callback = spec.get("source_kind") == "callback"
        own = {"parent_run_id": execution_id, "source_actor": execution_id} if callback else {}
        return {
            "message_id": f"{trigger}:{execution_id}",
            "platform_specific": {
                "task_execution_id": execution_id,
                "task_trigger_kind": trigger,
                "vibe_agent_name": "codex",
                **spec,
                **own,
            },
        }

    session_id = _seed_avibe_session_with_queue([("first body", prov("run-1")), ("second body", prov("run-2"))])
    mgr, runs = _manager_capturing_runs()

    assert asyncio.run(mgr.flush_queue(session_id)) is True
    [(text, _source, context)] = runs
    assert text == "first body\n\n---\n\nsecond body"
    prepared = asyncio.run(MessageHandler.prepare_input_metadata(object(), context, human=False))
    rendered = prepared.render(text, types.SimpleNamespace(include_time_info=False, include_user_info=True))
    assert rendered.splitlines()[0] == expected


def test_flush_does_not_coalesce_scheduled_callbacks_with_different_delivery(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))

    def prov(execution_id: str, channel_id: str) -> dict:
        return {
            "message_id": f"watch:def-watch:{execution_id}",
            "platform_specific": {
                "task_execution_id": execution_id,
                "task_trigger_kind": "watch",
                "task_definition_id": "def-watch",
                "delivery_override": {"platform": "slack", "channel_id": channel_id},
            },
        }

    session_id = _seed_avibe_session_with_queue(
        [
            ("first callback", prov("run-1", "C1")),
            ("different delivery", prov("run-2", "C2")),
        ]
    )

    from storage import messages_service
    from storage.db import create_sqlite_engine

    mgr, runs = _manager_capturing_runs()

    assert asyncio.run(mgr.flush_queue(session_id)) is True
    assert [(text, source) for text, source, _ in runs] == [("first callback", SOURCE_SCHEDULED)]
    with create_sqlite_engine().begin() as conn:
        remaining = message_deliveries.list_queued(conn, session_id)
    assert [row["text"] for row in remaining] == ["different delivery"]


def test_flush_does_not_coalesce_scheduled_callbacks_with_different_agent(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))

    def prov(execution_id: str, agent_name: str) -> dict:
        return {
            "message_id": f"watch:def-watch:{execution_id}",
            "platform_specific": {
                "task_execution_id": execution_id,
                "task_trigger_kind": "watch",
                "task_definition_id": "def-watch",
                "vibe_agent_name": agent_name,
            },
        }

    session_id = _seed_avibe_session_with_queue(
        [
            ("codex callback", prov("run-1", "codex")),
            ("claude callback", prov("run-2", "claude")),
        ]
    )

    from storage import messages_service
    from storage.db import create_sqlite_engine

    mgr, runs = _manager_capturing_runs()

    assert asyncio.run(mgr.flush_queue(session_id)) is True
    text, source, ctx = runs[0]
    assert (text, source) == ("codex callback", SOURCE_SCHEDULED)
    assert "vibe_agent_name" not in ctx.platform_specific
    with create_sqlite_engine().begin() as conn:
        remaining = message_deliveries.list_queued(conn, session_id)
    assert [row["text"] for row in remaining] == ["claude callback"]


def test_capture_scheduled_target_agent_splits_coalescing_key(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))

    def captured_prov(execution_id: str, agent_name: str) -> dict:
        ctx = MessageContext(
            user_id="U",
            channel_id="C",
            platform="avibe",
            message_id=f"watch:def-watch:{execution_id}",
            platform_specific={
                "task_execution_id": execution_id,
                "task_trigger_kind": "watch",
                "task_definition_id": "def-watch",
                "agent_session_target": {"id": f"ses-{agent_name}", "agent_name": agent_name},
            },
        )
        return session_turns.capture_scheduled_provenance(ctx)

    session_id = _seed_avibe_session_with_queue(
        [
            ("codex target callback", captured_prov("run-1", "codex")),
            ("claude target callback", captured_prov("run-2", "claude")),
        ]
    )

    from storage import messages_service
    from storage.db import create_sqlite_engine

    mgr, runs = _manager_capturing_runs()

    assert asyncio.run(mgr.flush_queue(session_id)) is True
    text, source, ctx = runs[0]
    assert (text, source) == ("codex target callback", SOURCE_SCHEDULED)
    assert session_turns.SCHEDULED_TARGET_AGENT_KEY not in ctx.platform_specific
    with create_sqlite_engine().begin() as conn:
        remaining = message_deliveries.list_queued(conn, session_id)
    assert [row["text"] for row in remaining] == ["claude target callback"]


def test_flush_preserves_scheduled_prompt_whitespace(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    session_id = _seed_avibe_session_with_queue(
        [
            (
                "  indented: true\n",
                {
                    "message_id": "watch:def-watch:run-1",
                    "platform_specific": {
                        "task_execution_id": "run-1",
                        "task_trigger_kind": "watch",
                        "task_definition_id": "def-watch",
                    },
                },
            )
        ]
    )

    mgr, runs = _manager_capturing_runs()

    assert asyncio.run(mgr.flush_queue(session_id)) is True
    assert runs[0][0] == "  indented: true\n"


def test_flush_does_not_mark_native_ids_when_context_build_fails(tmp_path, monkeypatch):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    session_id = _seed_avibe_session_with_queue(
        [
            (
                "suppressed callback",
                {
                    "message_id": "watch:def-watch:run-1",
                    "platform_specific": {
                        "task_execution_id": "run-1",
                        "task_trigger_kind": "watch",
                        "task_definition_id": "def-watch",
                        "suppress_delivery": True,
                    },
                },
            )
        ]
    )

    from storage.db import create_sqlite_engine

    mgr = session_turns.SessionTurnManager(
        controller=types.SimpleNamespace(),
        build_context=lambda sid: (_ for _ in ()).throw(RuntimeError("missing session")),
    )

    assert asyncio.run(mgr.flush_queue(session_id)) is False
    with create_sqlite_engine().begin() as conn:
        queued = message_deliveries.list_queued(conn, session_id)
    assert [row["native_message_id"] for row in queued] == ["watch:def-watch:run-1"]


def test_capture_scheduled_provenance_keeps_delivery_drops_routing():
    """capture_scheduled_provenance keeps the delivery / attribution keys — notably
    delivery_override, the redirect MessageDispatcher._get_target_context uses — and
    DROPS the routing keys the flush rebuilds, so a queued scheduled run keeps its
    delivery target (#84 / Codex P1 #3338692433)."""
    override = {"channel_id": "slack-9", "platform": "slack"}
    ctx = MessageContext(
        user_id="U",
        channel_id="C",
        platform="avibe",
        message_id="scheduled:exec-9",
        platform_specific={
            "platform": "avibe",
            "is_dm": False,
            "agent_session_id": "ses1",
            "agent_session_target": {"id": "ses1", "agent_name": "worker"},
            "delivery_override": override,
            "suppress_delivery": True,
            "turn_source": "scheduled",
            "task_trigger_kind": "task",
        },
    )
    prov = session_turns.capture_scheduled_provenance(ctx)
    # The stable native id is captured for dedup (Codex P2).
    assert prov["message_id"] == "scheduled:exec-9"
    spec = prov["platform_specific"]
    # Delivery / attribution provenance kept.
    assert spec["delivery_override"] == override
    assert spec["suppress_delivery"] is True
    assert spec["turn_source"] == "scheduled"
    assert spec["task_trigger_kind"] == "task"
    assert spec[session_turns.SCHEDULED_TARGET_AGENT_KEY] == "worker"
    # Routing keys the flush rebuilds are NOT carried.
    for routing in ("platform", "is_dm", "agent_session_id", "agent_session_target"):
        assert routing not in spec


def test_boot_publishes_app_then_waits_for_controller_recovery(
    monkeypatch,
):
    """HFR-152: HTTP serving waits for controller-owned runtime recovery."""
    import uvicorn

    calls: list[str] = []
    app_created = asyncio.Event()
    recovery_complete = asyncio.Event()
    manager = SimpleNamespace(
        recover_durable_delivery_state=AsyncMock(),
        recover_persisted_agent_run_queue=AsyncMock(),
    )
    controller = SimpleNamespace(
        session_turns=manager,
        _delivery_recovery_complete=recovery_complete,
        skill_observability=SimpleNamespace(close=AsyncMock()),
    )

    class _Server:
        def __init__(self, _config):
            pass

        async def serve(self, *, sockets):
            assert len(sockets) == 1
            assert recovery_complete.is_set()
            calls.append("serve")

    listener = SimpleNamespace(close=lambda: calls.append("close"))
    bound = SimpleNamespace(listener=listener)
    host = SimpleNamespace(
        instance_id=None,
        bearer_token=None,
        bind=lambda: bound,
        publish=lambda _bound: None,
        cleanup=lambda _bound: listener.close(),
    )

    def _create_app(_controller):
        calls.append("app")
        app_created.set()
        return object()

    monkeypatch.setattr(internal_server, "create_app", _create_app)
    monkeypatch.setattr(
        internal_server.control_ipc,
        "select_control_ipc_host",
        lambda **_kwargs: host,
    )
    monkeypatch.setattr(uvicorn, "Config", lambda *_args, **_kwargs: object())
    monkeypatch.setattr(uvicorn, "Server", _Server)

    async def _run() -> None:
        serving = asyncio.create_task(internal_server.serve(controller))
        await app_created.wait()
        assert calls == ["app"]
        manager.recover_durable_delivery_state.assert_not_awaited()
        manager.recover_persisted_agent_run_queue.assert_not_awaited()
        recovery_complete.set()
        await serving

    asyncio.run(_run())

    assert calls == ["app", "serve", "close"]
    controller.skill_observability.close.assert_awaited_once()


def _seed_slack_dm_session(conn, tmp_path, *, dm_chat_id: str, user_id: str = "U_DM"):
    """Create a Slack DM Session whose scope_id is the USER id, like production."""

    import json as _json

    from core.services import sessions as sessions_service
    from storage.models import scope_settings
    from storage.settings_service import upsert_scope

    now = "2026-08-09T00:00:00Z"
    scope_id = upsert_scope(
        conn,
        platform="slack",
        scope_type="user",
        native_id=user_id,
        now=now,
    )
    payload = {"bound_at": now}
    if dm_chat_id:
        payload["dm_chat_id"] = dm_chat_id
    conn.execute(
        scope_settings.insert().values(
            scope_id=scope_id,
            enabled=1,
            role=None,
            workdir=str(tmp_path),
            agent_name=None,
            agent_backend=None,
            agent_variant=None,
            model=None,
            reasoning_effort=None,
            require_mention=None,
            settings_version=1,
            settings_json=_json.dumps(payload),
            created_at=now,
            updated_at=now,
        )
    )
    return sessions_service.create_session(
        conn,
        scope_id=scope_id,
        agent_backend="claude",
        agent_name="claude",
    )


def test_build_session_context_uses_bound_dm_channel_for_dm_scope(monkeypatch, tmp_path):
    """A DM Session's scope_id is the USER id, which is not a channel.

    Slack's ``chat.postMessage`` tolerates a user id (it opens the DM), so sending
    kept working — but ``reactions.add`` answers ``channel_not_found``, so the
    reaction ack failed and silently downgraded to the ack message. The builder
    must swap in the bound ``dm_chat_id`` like every other resolver does.
    """

    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        session = _seed_slack_dm_session(conn, tmp_path, dm_chat_id="D_REAL")

    context = internal_server._build_session_context(session["id"])

    assert context.platform == "slack"
    assert context.user_id == "U_DM"
    assert context.channel_id == "D_REAL"
    assert context.platform_specific["is_dm"] is True


def test_build_session_context_falls_back_to_scope_id_without_dm_binding(monkeypatch, tmp_path):
    """No recorded dm_chat_id -> keep the old behaviour rather than inventing one."""

    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        session = _seed_slack_dm_session(conn, tmp_path, dm_chat_id="", user_id="U_UNBOUND")

    context = internal_server._build_session_context(session["id"])

    assert context.channel_id == "U_UNBOUND"


def test_build_session_context_respects_explicit_channel_override(monkeypatch, tmp_path):
    """An explicit channel_id (Delivery hydration) still wins over the binding."""

    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    ensure_sqlite_state()
    engine = create_sqlite_engine()
    with engine.begin() as conn:
        session = _seed_slack_dm_session(conn, tmp_path, dm_chat_id="D_REAL", user_id="U_OVERRIDE")

    context = internal_server._build_session_context(session["id"], channel_id="D_EXPLICIT")

    assert context.channel_id == "D_EXPLICIT"


def test_show_access_settings_read_returns_controller_snapshot(monkeypatch):
    from core import show_pages

    captured: list[str] = []

    class _Store:
        def get_access(self, page_id):
            captured.append(page_id)
            return show_pages.ShowAccess(
                page_id=page_id,
                access_mode="limited",
                share_id="stable-link",
                revision=7,
                normalized_emails=("[email protected]", "[email protected]"),
            )

        def close(self):
            captured.append("closed")

    monkeypatch.setattr(show_pages, "ShowPageStore", _Store)
    app = internal_server.create_app(_build_controller_double())

    async def _exercise():
        transport = httpx.ASGITransport(app=app)
        async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
            return await client.post(
                "/internal/show-access/settings-read",
                json={"page_id": "ses-show-access"},
            )

    response = asyncio.run(_exercise())

    assert response.status_code == 200
    assert response.json() == {
        "show_access": {
            "page_id": "ses-show-access",
            "access_mode": "limited",
            "share_id": "stable-link",
            "revision": 7,
            "normalized_emails": ["[email protected]", "[email protected]"],
            "entries": [
                {
                    "kind": "email",
                    "value": "[email protected]",
                    "organization_id": None,
                },
                {
                    "kind": "email",
                    "value": "[email protected]",
                    "organization_id": None,
                },
            ],
        }
    }
    assert captured == ["ses-show-access", "closed"]


@pytest.mark.parametrize(
    ("path", "payload", "error"),
    [
        (
            "/internal/show-access/settings-read",
            {"page_id": "ses-show-access", "extra": True},
            "invalid_show_access_settings_request",
        ),
        (
            "/internal/show-access/apply",
            {
                "page_id": "ses-show-access",
                "expected_revision": True,
                "target_access_mode": "limited",
                "target_share_id": "stable-link",
                "target_emails": ["[email protected]"],
            },
            "invalid_show_access_apply_request",
        ),
    ],
)
def test_show_access_internal_routes_reject_malformed_payloads(path, payload, error):
    app = internal_server.create_app(_build_controller_double())

    async def _exercise():
        transport = httpx.ASGITransport(app=app)
        async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
            return await client.post(path, json=payload)

    response = asyncio.run(_exercise())

    assert response.status_code == 400
    assert response.json() == {"ok": False, "error": error}


@pytest.mark.parametrize("status", ["conflict", "share_id_taken"])
def test_show_access_apply_preserves_atomic_result_status(monkeypatch, status):
    from core import show_pages

    captured: dict = {}

    class _Store:
        def apply_access(self, page_id, **kwargs):
            captured.update(page_id=page_id, **kwargs)
            return show_pages.ShowAccessApplyResult(
                status=status,
                show_access=show_pages.ShowAccess(
                    page_id=page_id,
                    access_mode="public",
                    share_id="current-link",
                    revision=9,
                    normalized_emails=(),
                ),
            )

        def close(self):
            return None

    monkeypatch.setattr(show_pages, "ShowPageStore", _Store)
    app = internal_server.create_app(_build_controller_double())
    payload = {
        "page_id": "ses-show-access",
        "expected_revision": 8,
        "target_access_mode": "limited",
        "target_share_id": "candidate-link",
        "target_emails": ["[email protected]"],
    }

    async def _exercise():
        transport = httpx.ASGITransport(app=app)
        async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
            return await client.post("/internal/show-access/apply", json=payload)

    response = asyncio.run(_exercise())

    assert response.status_code == 200
    assert response.json() == {
        "status": status,
        "show_access": {
            "page_id": "ses-show-access",
            "access_mode": "public",
            "share_id": "current-link",
            "revision": 9,
            "normalized_emails": [],
            "entries": [],
        },
    }
    assert captured == {
        "page_id": "ses-show-access",
        "expected_revision": 8,
        "target_access_mode": "limited",
        "target_share_id": "candidate-link",
        "target_emails": ["[email protected]"],
    }


def test_show_access_apply_writes_and_reads_group_and_organization_entries(monkeypatch):
    from core import show_pages

    captured: dict = {}

    class _Store:
        def apply_access(self, page_id, **kwargs):
            captured.update(page_id=page_id, **kwargs)
            return show_pages.ShowAccessApplyResult(
                status="applied",
                show_access=show_pages.ShowAccess(
                    page_id=page_id,
                    access_mode="limited",
                    share_id="stable-link",
                    revision=2,
                    entries=(
                        show_pages.ShowAccessEntry("group", "group-7", "org-1"),
                        show_pages.ShowAccessEntry("organization", "org-1", "org-1"),
                    ),
                ),
            )

        def close(self):
            return None

    monkeypatch.setattr(show_pages, "ShowPageStore", _Store)
    app = internal_server.create_app(_build_controller_double())
    payload = {
        "page_id": "ses-show-access",
        "expected_revision": 1,
        "target_access_mode": "limited",
        "target_share_id": "stable-link",
        "target_entries": [
            {"kind": "group", "value": "group-7"},
            {"kind": "organization", "value": "org-1"},
        ],
    }

    async def _exercise():
        transport = httpx.ASGITransport(app=app)
        async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
            return await client.post("/internal/show-access/apply", json=payload)

    response = asyncio.run(_exercise())

    assert response.status_code == 200
    assert response.json() == {
        "status": "applied",
        "show_access": {
            "page_id": "ses-show-access",
            "access_mode": "limited",
            "share_id": "stable-link",
            "revision": 2,
            "normalized_emails": [],
            "entries": [
                {"kind": "group", "value": "group-7", "organization_id": "org-1"},
                {
                    "kind": "organization",
                    "value": "org-1",
                    "organization_id": "org-1",
                },
            ],
        },
    }
    assert captured["target_entries"] == payload["target_entries"]
    assert "target_emails" not in captured


def test_show_access_internal_identity_mismatch_fails_closed(monkeypatch):
    from core import show_pages

    class _Store:
        def get_access(self, _page_id):
            return show_pages.ShowAccess(
                page_id="ses-other",
                access_mode="limited",
                share_id="secret-link",
                revision=2,
                normalized_emails=("[email protected]",),
            )

        def close(self):
            return None

    monkeypatch.setattr(show_pages, "ShowPageStore", _Store)
    app = internal_server.create_app(_build_controller_double())

    async def _exercise():
        transport = httpx.ASGITransport(app=app)
        async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
            return await client.post(
                "/internal/show-access/settings-read",
                json={"page_id": "ses-show-access"},
            )

    response = asyncio.run(_exercise())

    assert response.status_code == 500
    assert response.json() == {
        "ok": False,
        "error": "show_access_internal_failure",
    }
    assert "[email protected]" not in response.text


def test_show_access_apply_serializes_controller_writes(monkeypatch):
    from core import show_pages

    first_entered = threading.Event()
    release_first = threading.Event()
    calls: list[str] = []
    calls_lock = threading.Lock()

    class _Store:
        def apply_access(self, page_id, **_kwargs):
            with calls_lock:
                calls.append(page_id)
                call_number = len(calls)
            if call_number == 1:
                first_entered.set()
                assert release_first.wait(timeout=2)
            return show_pages.ShowAccessApplyResult(
                status="no_change",
                show_access=show_pages.ShowAccess(
                    page_id=page_id,
                    access_mode="private",
                    share_id="stable-link",
                    revision=0,
                    normalized_emails=(),
                ),
            )

        def close(self):
            return None

    monkeypatch.setattr(show_pages, "ShowPageStore", _Store)
    app = internal_server.create_app(_build_controller_double())
    payload = {
        "expected_revision": 0,
        "target_access_mode": "private",
        "target_share_id": "stable-link",
        "target_emails": [],
    }

    async def _exercise():
        transport = httpx.ASGITransport(app=app)
        async with httpx.AsyncClient(transport=transport, base_url="http://test") as client:
            first = asyncio.create_task(
                client.post(
                    "/internal/show-access/apply",
                    json={"page_id": "ses-first", **payload},
                )
            )
            assert await asyncio.to_thread(first_entered.wait, 2)
            second = asyncio.create_task(
                client.post(
                    "/internal/show-access/apply",
                    json={"page_id": "ses-second", **payload},
                )
            )
            await asyncio.sleep(0.05)
            with calls_lock:
                assert calls == ["ses-first"]
            release_first.set()
            return await asyncio.gather(first, second)

    responses = asyncio.run(_exercise())

    assert [response.status_code for response in responses] == [200, 200]
    assert calls == ["ses-first", "ses-second"]


def test_a_scheduled_turns_admission_never_holds_the_loop(monkeypatch, tmp_path):
    """#2630: admitting a scheduled turn writes its Delivery and Run rows in one transaction that waits for SQLite's
    write lock and commits. The loop runs every session's turns, so it stays free while another writer holds the
    lock."""
    import sqlite3
    import threading

    from core import session_turns

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(tmp_path, native_id="proj_admission_off_loop")
    session_id = session["id"]

    async def _fake_dispatch_turn(ctrl, ctx, text, *, source=SOURCE_HUMAN, on_chunk=None, **_kwargs):
        return TurnDispatchOutcome(error=None, settled_by=SETTLED_BY_TERMINAL_RESULT)

    monkeypatch.setattr(session_turns, "dispatch_turn_with_outcome", _fake_dispatch_turn)
    controller = _build_controller_double()
    internal_server.create_app(controller)
    ctx = MessageContext(
        user_id="workbench",
        channel_id=session_id,
        platform="avibe",
        message_id="scheduled:admission-off-loop:1",
        platform_specific={"agent_session_id": session_id, "agent_session_target": {"agent_backend": "claude"}},
    )

    held, release = threading.Event(), threading.Event()
    released_in_time: list[bool] = []

    def _hold_write_lock() -> None:
        # Another writer, as a second process or a long transaction would be.
        holder = sqlite3.connect(engine.url.database, timeout=10)
        try:
            holder.execute("BEGIN IMMEDIATE")
            held.set()
            released_in_time.append(release.wait(2))
            holder.rollback()
        finally:
            holder.close()

    async def _go():
        holder = threading.Thread(target=_hold_write_lock)
        holder.start()
        assert await asyncio.to_thread(held.wait, 5)
        submitting = asyncio.create_task(controller.session_turn_gate.submit_scheduled(session_id, ctx, "digest please"))
        await asyncio.sleep(0.1)
        # The loop lets the other writer go while admission waits for it.
        release.set()
        await submitting
        await asyncio.to_thread(holder.join, 5)

    asyncio.run(_go())
    assert released_in_time == [True]


@pytest.mark.parametrize("admission_fails", [False, True])
def test_a_cancellation_during_admission_keeps_the_runs_delivery_ownership(monkeypatch, tmp_path, admission_fails):
    """#2630: admission runs on a thread now, so a cancellation can arrive while it waits for SQLite's write lock.
    Once its transaction moves the Run's ownership to the Delivery, the submission must hand the turn to recovery,
    as a cancellation during delivery does, instead of letting the Run be terminalized and the turn dropped.

    #2657: an admission that fails moved nothing, so the submission answers the cancellation, not the error: the
    error would have the executor settle an ordinary failure instead of the stop or shutdown that cancelled it."""
    import sqlite3
    import threading

    from core import session_turns
    from core.scheduled_tasks import TaskExecutionStore
    from storage import background

    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    engine, session = _create_test_session(tmp_path, native_id="proj_admission_cancel")
    session_id = session["id"]
    request_store = TaskExecutionStore()
    run = request_store.enqueue_definition_run(
        definition_id="scheduled-admission-cancel",
        run_type="scheduled",
        source_kind="scheduler",
        session_key="",
        session_id=session_id,
        post_to=None,
        deliver_key=None,
        prompt="digest please",
        agent_name="worker",
        session_policy="existing",
    )
    assert request_store.claim(run.id) is not None

    async def _fake_dispatch_turn(ctrl, ctx, text, *, source=SOURCE_HUMAN, on_chunk=None, **_kwargs):
        return TurnDispatchOutcome(error=None, settled_by=SETTLED_BY_TERMINAL_RESULT)

    monkeypatch.setattr(session_turns, "dispatch_turn_with_outcome", _fake_dispatch_turn)
    controller = _build_controller_double()
    internal_server.create_app(controller)
    ctx = MessageContext(
        user_id="workbench",
        channel_id=session_id,
        platform="avibe",
        message_id=f"scheduled:scheduled-admission-cancel:{run.id}",
        platform_specific={
            "agent_session_id": session_id,
            "agent_session_target": {"agent_backend": "claude"},
            "task_execution_id": run.id,
            "task_trigger_kind": "scheduled",
            "task_definition_id": "scheduled-admission-cancel",
        },
    )
    held, release = threading.Event(), threading.Event()
    if admission_fails:

        def _refuse_binding(*_args, **_kwargs):
            raise sqlite3.OperationalError("disk I/O error")

        monkeypatch.setattr(background, "attach_agent_run_delivery_in_connection", _refuse_binding)

    def _hold_write_lock() -> None:
        holder = sqlite3.connect(engine.url.database, timeout=10)
        try:
            holder.execute("BEGIN IMMEDIATE")
            held.set()
            release.wait(5)
            holder.rollback()
        finally:
            holder.close()

    async def _go():
        holder = threading.Thread(target=_hold_write_lock)
        holder.start()
        assert await asyncio.to_thread(held.wait, 5)
        submitting = asyncio.create_task(
            controller.session_turn_gate.submit_scheduled(session_id, ctx, "digest please", delivery_intent="queue")
        )
        await asyncio.sleep(0.1)
        submitting.cancel()
        release.set()
        try:
            return await submitting
        except asyncio.CancelledError:
            return "cancelled"
        finally:
            await asyncio.to_thread(holder.join, 5)

    result = asyncio.run(_go())
    stored = request_store.get_run(run.id)
    if admission_fails:
        assert result == "cancelled", f"the admission's error replaced the cancellation: {result!r}"
        assert not stored["delivery_id"]
        return
    assert result.delivery_owner_transferred is True
    assert stored["delivery_id"] and stored["status"] in {"running", "queued"}