Skip to content

Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)

Python
90.7 KB
Raw Blame
import asyncio
import uuid
from types import SimpleNamespace
from unittest.mock import AsyncMock, Mock

import pytest
import pytest_asyncio

from free_claude_code.application.code_sessions import CodeConflictError, CodeService
from free_claude_code.application.code_sessions import service as service_module
from free_claude_code.application.code_sessions.models import (
    CodeItem,
    CodeRun,
    CodeSession,
    CodeUnavailableError,
    CodeValidationError,
    HarnessEvent,
    ItemUpdate,
    PromptRequest,
)
from free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStore
from free_claude_code.runtime.codex_protocol import CodexProtocol
from tests.code_sessions_support import (
    CodexPackets,
    FakeConnection,
    FakeHarness,
    close_code_database,
)


def new_id():
    return str(uuid.uuid4())


@pytest_asyncio.fixture
async def code(database_factory, tmp_path):
    harness = FakeHarness()
    store = SQLiteCodeStore(
        database_factory(tmp_path / "code.db", tmp_path / "code.lock")
    )
    service = CodeService(store, harness)
    await service.start()
    try:
        yield service, harness, tmp_path
    finally:
        await service.close()
        await close_code_database(service)


async def session_for(code):
    service, _, directory = code
    return await service.create_session(new_id(), str(directory))


@pytest.mark.asyncio
async def test_history_pages_do_not_create_execution_owners(code, monkeypatch):
    service, harness, directory = code
    session = await service._store.create(
        CodeSession(id=new_id(), cwd=str(directory), model=harness.model)
    )
    run = CodeRun(id=new_id(), session_id=session.id, text="old", model=harness.model)
    user = CodeItem(
        id=run.id, run_id=run.id, session_id=session.id, sequence=1, kind="user"
    )
    session, run = await service._store.admit_run(session, run, user, session.revision)
    await service._store.save_progress(
        session,
        session.revision,
        run=run.model_copy(update={"status": "completed"}),
        items=tuple(
            CodeItem(
                id=new_id(),
                run_id=run.id,
                session_id=session.id,
                sequence=n,
                kind="text",
                text="saved" * 100,
                complete=True,
            )
            for n in range(2, 202)
        ),
    )
    monkeypatch.setattr(
        service._store, "items", AsyncMock(side_effect=AssertionError("full history"))
    )
    monkeypatch.setattr(
        service._store, "runs", AsyncMock(side_effect=AssertionError("all runs"))
    )
    page = await service.get_detail(session.id)
    assert len(page.items) == 50
    assert page.next_before is not None
    older = await service.get_detail(session.id, before=page.next_before)
    assert len(older.items) == 50
    assert older.items[-1].sequence < page.items[0].sequence
    assert not service._owners
    assert not service._gates
    assert not harness.connections


@pytest.mark.asyncio
async def test_completed_turn_releases_bodies_but_keeps_connection(code):
    service, harness, _ = code
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "Work", expected_epoch=service.epoch
    )
    await harness.wait_inputs(1)
    connection = harness.connections[0]
    await harness.started.wait()
    await connection.text("turn-1", "answer", "saved output", complete=True)
    await connection.finish("turn-1")
    await service.wait_idle(session.id)
    owner = service._owners[session.id]
    assert not owner.state.items
    assert not owner.state.prompts
    assert len(owner.state.runs) == 1
    assert not connection.closed
    assert any(
        item.text == "saved output"
        for item in (await service.get_detail(session.id)).items
    )


@pytest.mark.asyncio
async def test_many_turns_release_history_and_preserve_prompt_receipts(code):
    service, harness, _ = code
    session = await session_for(code)
    previous_sequence = 0
    receipts = []
    for number in range(1, 13):
        harness.started.clear()
        await service.send(
            session.id,
            new_id(),
            session.revision,
            f"Work {number}",
            expected_epoch=service.epoch,
        )
        await harness.started.wait()
        connection = harness.connections[0]
        turn = f"turn-{number}"
        for kind in ("text", "tool", "reasoning"):
            await connection.text(
                turn, kind, f"{kind} output {number}", complete=True, kind=kind
            )
        await connection.prompt(number, turn)
        prompt = next(
            prompt
            for prompt in (await service.get_detail(session.id)).prompts
            if prompt.request_id == number
        )
        response_id = new_id()
        await service.answer(session.id, prompt.id, response_id, {"decision": "accept"})
        await connection.finish(turn)
        await service.wait_idle(session.id)
        receipts.append((prompt.id, response_id))
        detail = await service.get_detail(session.id)
        assert detail.items[-1].sequence > previous_sequence
        previous_sequence = detail.items[-1].sequence
        session = detail.session
        owner = service._owners[session.id]
        assert not owner.state.items and not owner.state.prompts
        assert tuple(owner.state.runs) == (detail.run.id,)
    assert len(harness.connections) == 1 and not connection.closed
    for prompt_id, response_id in receipts:
        receipt = await service.answer(
            session.id, prompt_id, response_id, {"decision": "accept"}
        )
        assert receipt.response_id == response_id
    assert not service._owners[session.id].state.prompts
    all_items = await service._store.items(session.id, None, None)
    assert [item.sequence for item in all_items] == list(range(1, 61))


@pytest.mark.asyncio
async def test_cold_history_gate_serializes_owner_creation_without_blocking_other_sessions(
    code, monkeypatch
):
    service, harness, directory = code
    sessions = [
        await service._store.create(
            CodeSession(id=new_id(), cwd=str(directory), model=harness.model)
        )
        for _ in range(2)
    ]
    entered, release = asyncio.Event(), asyncio.Event()
    read = service._store.read_history

    async def gated_read(session_id, *args):
        if session_id == sessions[0].id:
            entered.set()
            await release.wait()
        return await read(session_id, *args)

    monkeypatch.setattr(service._store, "read_history", gated_read)
    reading = asyncio.create_task(service.get_detail(sessions[0].id))
    await entered.wait()
    changing = asyncio.create_task(
        service.update_settings(
            sessions[0].id, sessions[0].revision, {"title": "Updated"}
        )
    )
    cancelled = asyncio.create_task(service.get_detail(sessions[0].id))
    try:
        other = await asyncio.wait_for(service.get_detail(sessions[1].id), 2)
        assert other.session.id == sessions[1].id
        assert not changing.done() and not service._owners
        cancelled.cancel()
        with pytest.raises(asyncio.CancelledError):
            await cancelled
        release.set()
        before = await reading
        await changing
        after = await service.get_detail(sessions[0].id)
        assert before.session.title != after.session.title == "Updated"
        assert after.version > before.version
        assert set(service._gates) == {sessions[0].id}
        assert service._gates[sessions[0].id].users == 0
    finally:
        release.set()
        await asyncio.gather(reading, changing, cancelled, return_exceptions=True)


@pytest.mark.asyncio
async def test_execution_seed_resumes_sequence_without_hydrating_old_transcript(
    code, monkeypatch
):
    service, harness, directory = code
    session = await service._store.create(
        CodeSession(id=new_id(), cwd=str(directory), model=harness.model)
    )
    run = CodeRun(id=new_id(), session_id=session.id, text="old", model=harness.model)
    item = CodeItem(
        id=run.id, run_id=run.id, session_id=session.id, sequence=900, kind="user"
    )
    session, run = await service._store.admit_run(session, run, item, session.revision)
    await service._store.save_progress(
        session, session.revision, run=run.model_copy(update={"status": "completed"})
    )
    monkeypatch.setattr(
        service._store, "items", AsyncMock(side_effect=AssertionError("full history"))
    )
    monkeypatch.setattr(
        service._store, "prompts", AsyncMock(side_effect=AssertionError("all prompts"))
    )
    await service.send(
        session.id, new_id(), session.revision, "Next", expected_epoch=service.epoch
    )
    await harness.started.wait()
    detail = await service.get_detail(session.id)
    assert detail.items[-1].sequence == 901
    assert run.id not in service._owners[session.id].state.runs
    await harness.connections[0].finish("turn-1")


@pytest.mark.asyncio
async def test_catalog_wait_releases_session_lock_and_revalidates_before_admission(
    code, monkeypatch
):
    service, harness, _ = code
    session = await session_for(code)
    entered, release = asyncio.Event(), asyncio.Event()
    prepare = harness.prepare

    async def held_prepare(*args):
        entered.set()
        await release.wait()
        return await prepare(*args)

    monkeypatch.setattr(harness, "prepare", held_prepare)
    sending = asyncio.create_task(
        service.send(
            session.id, new_id(), session.revision, "Work", expected_epoch=service.epoch
        )
    )
    try:
        await entered.wait()
        detail = await asyncio.wait_for(service.get_detail(session.id), 1)
        assert detail.run is None
        updated = await asyncio.wait_for(
            service.update_settings(
                session.id, session.revision, {"title": "Renamed during initialization"}
            ),
            1,
        )
        release.set()
        with pytest.raises(CodeConflictError):
            await sending
        assert updated.title == "Renamed during initialization"
        assert not harness.connections
        assert (await service.get_detail(session.id)).run is None
    finally:
        release.set()
        await asyncio.gather(sending, return_exceptions=True)


@pytest.fixture
def flush_timer(monkeypatch):
    sleeping, release = asyncio.Event(), asyncio.Event()

    async def sleep(delay):
        assert delay == 0.25
        sleeping.set()
        await release.wait()

    monkeypatch.setattr(
        service_module, "asyncio", SimpleNamespace(**(vars(asyncio) | {"sleep": sleep}))
    )
    yield sleeping, release
    release.set()


@pytest.mark.asyncio
@pytest.mark.parametrize(
    ("failure", "finished", "status"),
    [(BrokenPipeError, False, "failed"), (ConnectionResetError, True, "completed")],
)
async def test_child_lookup_pipe_failure_delivers_queued_close(
    code, monkeypatch, failure, finished, status
):
    service, harness, _ = code
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch
    )
    await asyncio.wait_for(harness.started.wait(), 3)
    connection = harness.connections[0]
    packets = CodexPackets(connection)
    await packets.spawn()
    await packets.review()
    if finished:
        await connection.finish("turn-1")
    native = packets.native
    monkeypatch.delattr(native, "rpc")
    native._alive = True
    native._process = Mock(
        stdin=Mock(drain=AsyncMock(side_effect=failure("Pipe closed")))
    )
    await native._packet(
        {
            "method": "guardianWarning",
            "params": {"threadId": "unregistered-child", "message": "Child warning"},
        }
    )
    native._queue.put_nowait(
        HarnessEvent(
            connection.generation,
            connection.thread_id,
            "closed",
            message="Native process ended",
        )
    )
    native._queue.put_nowait(None)
    try:
        await native._dispatch()
        detail = await service.get_detail(session.id)
        assert detail.active_review_ids == ()
        assert detail.run.status == status
        assert [item.kind for item in detail.items] == ["user", "subagent_auto_review"]
        assert not detail.items[-1].complete
    finally:
        for _, future in native._pending.values():
            future.cancel()


@pytest.mark.asyncio
async def test_pending_child_review_outside_page_keeps_its_run_and_history_cursor(code):
    service, harness, _ = code
    session = await session_for(code)
    first = await service.send(
        session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch
    )
    await asyncio.wait_for(harness.started.wait(), 3)
    connection = harness.connections[0]
    packets = CodexPackets(connection)
    await packets.spawn()
    await packets.review()
    review = (await service.get_detail(session.id)).items[-1]
    await connection.finish("turn-1")
    session = (await service.get_detail(session.id)).session
    await service.send(
        session.id, new_id(), session.revision, "Continue", expected_epoch=service.epoch
    )
    await asyncio.wait_for(harness.wait_inputs(2), 3)
    for index in range(55):
        await connection.text("turn-2", str(index), f"Output {index}", complete=True)
    await connection.finish("turn-2")
    newest = await service.get_detail(session.id)
    assert len(newest.items) == 51
    assert newest.items[0].id == review.id and newest.items[0].run_id == first.id
    assert first.id in {run.id for run in newest.runs}
    assert newest.active_review_ids == (review.id,)
    assert newest.next_before == (2, 9)
    await packets.review(status="approved")
    resolved = await service.get_detail(session.id)
    assert resolved.active_review_ids == ()
    assert review.id not in {item.id for item in resolved.items}
    assert resolved.next_before == newest.next_before
    refreshed = await service.get_detail(
        session.id, include_item_ids=(review.id, review.id, "missing")
    )
    assert len(refreshed.items) == 51
    assert refreshed.items[0].id == review.id and refreshed.items[0].complete
    assert first.id in {run.id for run in refreshed.runs}
    assert refreshed.next_before == newest.next_before
    older = await service.get_detail(session.id, before=newest.next_before)
    saved = next(item for item in older.items if item.id == review.id)
    assert saved.complete and saved.title == "Sub-agent Auto-review: Approved"
    assert saved.sequence == review.sequence and saved.run_id == first.id
    merged = {item.id: item for item in (*older.items, *resolved.items)}
    assert sorted(item.sequence for item in merged.values()) == list(range(1, 59))


@pytest.mark.asyncio
@pytest.mark.parametrize("ownership", ["notification", "metadata"])
async def test_owned_child_reviews_and_warnings_reach_saved_parent_transcript(
    code, ownership
):
    service, harness, _ = code
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch
    )
    await asyncio.wait_for(harness.started.wait(), 3)
    connection = harness.connections[0]
    packets = CodexPackets(connection)
    if ownership == "notification":
        await packets.spawn()
        await packets.spawn("grandchild", "child")
        await packets.spawn("unrelated", "outside")
    else:
        packets.parents.update(
            {
                "child": connection.thread_id,
                "grandchild": "child",
                "unrelated": "outside",
            }
        )
    for child in (connection.thread_id, "child", "grandchild", "unrelated"):
        await packets.review(child, status="approved", turn="turn-1")
        await packets.warning(child)
    detail = await service.get_detail(session.id)
    assert [item.kind for item in detail.items] == [
        "user",
        "auto_review",
        "notice",
        "subagent_auto_review",
        "notice",
        "subagent_auto_review",
        "notice",
    ]
    reviews = [item for item in detail.items if item.kind == "subagent_auto_review"]
    assert len({item.native_item_id for item in reviews}) == 2
    assert [item.raw["threadId"] for item in reviews] == ["child", "grandchild"]
    assert all(item.title == "Sub-agent Auto-review: Approved" for item in reviews)
    assert detail.items[-1].text == "Sub-agent: Native warning"
    assert detail.items[-1].raw == {
        "threadId": "grandchild",
        "message": "Native warning",
    }
    assert await service._store.items(session.id, None, None) == detail.items
    assert detail.run.status == "running"


@pytest.mark.asyncio
async def test_child_review_stays_with_first_entry_after_next_turn_begins(code):
    service, harness, _ = code
    session = await session_for(code)
    first = await service.send(
        session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch
    )
    await asyncio.wait_for(harness.started.wait(), 3)
    connection = harness.connections[0]
    packets = CodexPackets(connection)
    await packets.spawn()
    await packets.review()
    before = await service.get_detail(session.id)
    assert len(before.items) == 2
    review = before.items[-1]
    assert before.active_review_ids == (review.id,)
    await connection.finish("turn-1")
    await packets.send(
        "turn/completed",
        {"threadId": "child", "turn": {"id": "child-turn", "status": "completed"}},
    )
    assert (await service.get_detail(session.id)).active_review_ids == (review.id,)
    subscription, ready = await service.subscribe()
    events = aiter(subscription)
    try:
        assert ready["sessions"][0]["active_review_ids"] == [review.id]
        session = (await service.get_detail(session.id)).session
        harness.start_gate.clear()
        harness.started.clear()
        second = await service.send(
            session.id,
            new_id(),
            session.revision,
            "Continue",
            expected_epoch=service.epoch,
        )
        await asyncio.wait_for(harness.wait_inputs(2), 3)
        await packets.review(status="denied")
        await packets.review(status="denied")
        await packets.review()
        await packets.warning()
        await packets.review(review_id="next", status="approved", turn="turn-2")
        await packets.send(
            "turn/started", {"threadId": "child", "turn": {"id": "turn-2"}}
        )
        await packets.send(
            "turn/completed",
            {"threadId": "child", "turn": {"id": "turn-2", "status": "completed"}},
        )
        detail = await service.get_detail(session.id)
        saved = next(item for item in detail.items if item.id == review.id)
        assert (saved.run_id, saved.sequence, saved.native_turn_id) == (
            first.id,
            review.sequence,
            "child-turn",
        )
        assert saved.title == "Sub-agent Auto-review: Denied" and saved.complete
        assert detail.active_review_ids == ()
        assert detail.run.id == second.id and detail.run.native_turn_id is None
        assert all(item.run_id == second.id for item in detail.items[-3:])
        while (event := await asyncio.wait_for(anext(events), 3)).data.get(
            "item", {}
        ).get("id") != review.id:
            pass
        assert event.data["runs"][0]["id"] == first.id
        assert event.data["run"]["id"] == second.id
        harness.start_gate.set()
        await asyncio.wait_for(harness.started.wait(), 3)
        assert (await service.get_detail(session.id)).run.native_turn_id == "turn-2"
        await connection.finish("turn-2")
    finally:
        harness.start_gate.set()
        await subscription.aclose()


@pytest.mark.asyncio
@pytest.mark.parametrize("closure", ["native", "service"])
async def test_pending_child_review_becomes_unavailable_when_idle_connection_ends(
    database_factory, code, closure
):
    service, harness, directory = code
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch
    )
    await asyncio.wait_for(harness.started.wait(), 3)
    connection = harness.connections[0]
    packets = CodexPackets(connection)
    await packets.spawn()
    await connection.finish("turn-1")
    await packets.review()
    before = await service.get_detail(session.id)
    assert len(before.items) == 2
    review = before.items[-1]
    assert before.active_review_ids == (review.id,)
    subscription, _ = await service.subscribe()
    events = aiter(subscription)
    try:
        if closure == "native":
            await connection.close()
        else:
            await service._close_connection(await service._owner(session.id))
        event = await asyncio.wait_for(anext(events), 3)
        assert event.data["active_review_ids"] == []
        await packets.review(status="approved")
        detail = await service.get_detail(session.id)
        assert detail.items == before.items
        assert detail.active_review_ids == ()
        assert detail.run.status == "completed"
        await service.close()
        await close_code_database(service)
        restarted = CodeService(
            SQLiteCodeStore(
                database_factory(directory / "code.db", directory / "code.lock")
            ),
            harness,
        )
        await restarted.start()
        try:
            restored = await restarted.get_detail(session.id)
            assert restored.items == before.items
            assert restored.active_review_ids == ()
        finally:
            await restarted.close()
    finally:
        await subscription.aclose()


@pytest.mark.asyncio
async def test_mode_is_captured_per_turn_and_does_not_recreate_native_process(code):
    service, harness, _ = code
    session = await session_for(code)
    modes = ["full_access", "config", "ask", "auto_review"]
    for ordinal, mode in enumerate(modes, 1):
        session = await service.update_settings(
            session.id, session.revision, {"mode": mode}
        )
        run = await service.send(
            session.id,
            new_id(),
            session.revision,
            "hello",
            expected_epoch=service.epoch,
        )
        assert run.mode == mode
        await asyncio.wait_for(harness.wait_inputs(ordinal), 3)
        current = (await service.get_detail(session.id)).session
        with pytest.raises(CodeConflictError):
            await service.update_settings(current.id, current.revision, {"mode": "ask"})
        await harness.connections[0].finish(f"turn-{ordinal}")
        await service.wait_idle(session.id)
        session = (await service.get_detail(session.id)).session
    assert len(harness.connections) == 1
    assert harness.connections[0].modes == modes
    assert session.native_permission_defaults == harness.permission_defaults


@pytest.mark.asyncio
@pytest.mark.parametrize("pending_output", [False, True])
async def test_reobserved_child_review_publishes_liveness_on_new_native_connection(
    code,
    pending_output,
):
    service, harness, _ = code
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch
    )
    await asyncio.wait_for(harness.started.wait(), 3)
    first = harness.connections[0]
    packets = CodexPackets(first)
    await packets.spawn()
    await packets.review()
    review = (await service.get_detail(session.id)).items[-1]
    await first.finish("turn-1")
    harness.configurations[harness.model] = "replacement"
    session = (await service.get_detail(session.id)).session
    await service.send(
        session.id, new_id(), session.revision, "Continue", expected_epoch=service.epoch
    )
    await asyncio.wait_for(harness.wait_inputs(2), 3)
    second = harness.connections[1]
    if not pending_output:
        await second.finish("turn-2")
    assert (await service.get_detail(session.id)).active_review_ids == ()
    packets = CodexPackets(second)
    await packets.spawn()
    subscription, _ = await service.subscribe()
    try:
        if pending_output:
            await second.text("turn-2", "reply", "In progress")
        await packets.review()
        event = await asyncio.wait_for(anext(aiter(subscription)), 3)
        while event.data["active_review_ids"] != [review.id]:
            event = await asyncio.wait_for(anext(aiter(subscription)), 3)
        assert event.data["active_review_ids"] == [review.id]
        assert event.data.get("item", {}).get("id") == review.id
        assert event.data["runs"][0]["id"] == review.run_id
        detail = await service.get_detail(session.id)
        assert next(item for item in detail.items if item.id == review.id) == review
        assert detail.run.status == ("running" if pending_output else "completed")
    finally:
        await subscription.aclose()


@pytest.mark.asyncio
async def test_forced_interrupt_clears_pending_child_review_liveness(code, monkeypatch):
    service, harness, _ = code
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch
    )
    await asyncio.wait_for(harness.started.wait(), 3)
    connection = harness.connections[0]
    packets = CodexPackets(connection)
    await packets.spawn()
    await packets.review()
    assert (await service.get_detail(session.id)).active_review_ids

    async def unavailable(_turn_id):
        raise CodeUnavailableError("Native interrupt transport failed")

    monkeypatch.setattr(connection, "interrupt", unavailable)
    await service.stop(session.id, (await service.get_detail(session.id)).run.id)
    await asyncio.wait_for(service.wait_idle(session.id), 3)
    detail = await service.get_detail(session.id)
    assert detail.active_review_ids == ()
    assert detail.run.status == "interrupted"
    assert not detail.items[-1].complete


@pytest.mark.asyncio
async def test_mode_change_and_send_compete_for_one_revision(code):
    service, harness, _ = code
    session = await session_for(code)
    results = await asyncio.gather(
        service.update_settings(session.id, session.revision, {"mode": "full_access"}),
        service.send(
            session.id,
            new_id(),
            session.revision,
            "hello",
            expected_epoch=service.epoch,
        ),
        return_exceptions=True,
    )
    assert sum(isinstance(result, CodeConflictError) for result in results) == 1
    detail = await service.get_detail(session.id)
    if detail.run:
        assert detail.run.mode == "config"
        await asyncio.wait_for(harness.started.wait(), 3)
        await harness.connections[0].finish("turn-1")
    else:
        assert detail.session.mode == "full_access"


@pytest.mark.asyncio
@pytest.mark.parametrize("mode", [None, "plan", "never", {}, 1])
async def test_invalid_mode_is_rejected_without_changing_session(code, mode):
    service, _, _ = code
    session = await session_for(code)
    with pytest.raises(CodeValidationError):
        await service.update_settings(session.id, session.revision, {"mode": mode})
    assert (await service.get_detail(session.id)).session == session


@pytest.mark.asyncio
async def test_native_defaults_are_saved_before_input_and_preserved_on_resume(code):
    service, harness, _ = code
    session = await session_for(code)
    original = {"policy": "configured-original"}
    harness.permission_defaults = original
    session = await service.update_settings(
        session.id, session.revision, {"mode": "full_access"}
    )
    await service.send(
        session.id, new_id(), session.revision, "first", expected_epoch=service.epoch
    )
    await asyncio.wait_for(harness.started.wait(), 3)
    saved = await service._store.get_session(session.id)
    assert saved.native_permission_defaults == original
    assert harness.connections[0].defaults == [original]
    await harness.connections[0].finish("turn-1")
    await service.wait_idle(session.id)
    harness.permission_defaults = {"policy": "current-override"}
    harness.configurations[harness.model] = "recreate-process"
    session = (await service.get_detail(session.id)).session
    session = await service.update_settings(
        session.id, session.revision, {"mode": "config"}
    )
    await service.send(
        session.id, new_id(), session.revision, "second", expected_epoch=service.epoch
    )
    await asyncio.wait_for(harness.wait_inputs(2), 3)
    assert len(harness.connections) == 2
    assert harness.connections[1].defaults == [original]
    await harness.connections[1].finish("turn-2")


@pytest.mark.asyncio
async def test_failure_saving_native_defaults_never_submits_input(code, monkeypatch):
    service, harness, _ = code
    session = await session_for(code)
    save = service._store.save_progress

    async def reject_defaults(session, *args, **kwargs):
        if session.native_permission_defaults is not None:
            raise CodeUnavailableError("Unable to save permission defaults")
        await save(session, *args, **kwargs)

    monkeypatch.setattr(service._store, "save_progress", reject_defaults)
    await service.send(
        session.id, new_id(), session.revision, "first", expected_epoch=service.epoch
    )
    await asyncio.wait_for(service.wait_idle(session.id), 3)
    assert not any(connection.inputs for connection in harness.connections)
    assert not (await service._store.latest_run(session.id)).submission_started


@pytest.mark.asyncio
async def test_native_reviews_and_notices_keep_identity_order_and_survive_restart(
    database_factory, code
):
    service, harness, directory = code
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch
    )
    await asyncio.wait_for(harness.started.wait(), 3)
    connection = harness.connections[0]
    protocol = CodexProtocol(connection.generation)
    payload = {
        "threadId": connection.thread_id,
        "turnId": "turn-1",
        "targetItemId": "same-command",
        "action": {"command": "echo test"},
        "review": {"status": "inProgress"},
    }
    for review_id in ("one", "two"):
        await connection.sink(
            protocol.notification(
                "item/autoApprovalReview/started", {**payload, "reviewId": review_id}
            )
        )
    await connection.text("turn-1", "reply", "After reviews", complete=True)
    before = await service.get_detail(session.id)
    for review_id in ("two", "one"):
        await connection.sink(
            protocol.notification(
                "item/autoApprovalReview/completed",
                {
                    **payload,
                    "reviewId": review_id,
                    "review": {"status": "denied", "rationale": "Native refusal"},
                },
            )
        )
    await connection.sink(
        protocol.notification(
            "guardianWarning",
            {"threadId": connection.thread_id, "message": "Native warning"},
        )
    )
    await connection.sink(
        HarnessEvent("old-generation", connection.thread_id, "notice", message="stale")
    )
    await connection.finish("turn-1")
    await service.wait_idle(session.id)
    detail = await service.get_detail(session.id)
    assert [item.id for item in detail.items[:4]] == [item.id for item in before.items]
    assert [item.kind for item in detail.items] == [
        "user",
        "auto_review",
        "auto_review",
        "text",
        "notice",
    ]
    assert all(item.title == "Auto-review: Denied" for item in detail.items[1:3])
    assert detail.run.status == "completed"
    assert detail.items[-1].text == "Native warning"
    await service.close()
    await close_code_database(service)
    restarted = CodeService(
        SQLiteCodeStore(
            database_factory(directory / "code.db", directory / "code.lock")
        ),
        harness,
    )
    await restarted.start()
    try:
        assert (await restarted.get_detail(session.id)).items == detail.items
    finally:
        await restarted.close()


@pytest.mark.asyncio
async def test_selected_model_and_effort_are_session_settings_captured_on_send(code):
    service, harness, _ = code
    harness.configurations["provider/other"] = "other"
    session = await session_for(code)
    for effort in (None, "high", None):
        session = await service.update_settings(
            session.id,
            session.revision,
            {"model": "provider/other", "reasoning_effort": effort},
        )
        run = await service.send(
            session.id,
            new_id(),
            session.revision,
            "hello",
            expected_epoch=service.epoch,
        )
        await harness.wait_inputs(run.ordinal)
        connection = harness.connections[0]
        with pytest.raises(CodeConflictError):
            await service.update_settings(
                session.id, session.revision + 1, {"reasoning_effort": "low"}
            )
        await connection.finish(f"turn-{run.ordinal}")
        session = (await service.get_detail(session.id)).session
    assert connection.efforts == ["medium", "high", "medium"]
    assert {value[2] for value in connection.inputs} == {"provider/other"}
    assert len(harness.connections) == 1
    harness.configurations.pop("provider/other")
    with pytest.raises(CodeValidationError, match="unavailable"):
        await service.send(
            session.id,
            new_id(),
            session.revision,
            "kept draft",
            expected_epoch=service.epoch,
        )
    assert (await service.get_detail(session.id)).session.model == "provider/other"


@pytest.mark.asyncio
async def test_catalog_effort_removal_requires_choice_but_model_change_resolves_default(
    code,
):
    service, harness, _ = code
    session = await session_for(code)
    session = await service.update_settings(
        session.id, session.revision, {"reasoning_effort": "xhigh"}
    )
    harness.efforts = ("low", "medium")
    with pytest.raises(CodeValidationError, match="effort"):
        await service.send(
            session.id,
            new_id(),
            session.revision,
            "hello",
            expected_epoch=service.epoch,
        )
    harness.configurations["provider/other"] = "other"
    session = await service.update_settings(
        session.id, session.revision, {"model": "provider/other"}
    )
    assert session.reasoning_effort is None
    assert session.model == "provider/other"


@pytest.mark.asyncio
async def test_failed_outcome_is_durable_once_after_partial_output_and_older_pagination(
    code,
):
    service, harness, _ = code
    session = await session_for(code)
    run = await service.send(
        session.id, new_id(), session.revision, "first", expected_epoch=service.epoch
    )
    await harness.started.wait()
    connection = harness.connections[0]
    for kind in ("text", "reasoning", "tool"):
        await connection.text("turn-1", kind, f"partial {kind}", kind=kind)
    await connection.finish("turn-1", "failed", "Provider rejected the request")
    await connection.finish("turn-1", "failed", "duplicate")
    detail = await service.get_detail(session.id)
    assert detail.session.error is None
    assert detail.runs == (detail.run,)
    assert detail.run.error == "Provider rejected the request"
    assert [item.text for item in detail.items] == [
        "first",
        "partial text",
        "partial reasoning",
        "partial tool",
    ]
    await service.send(
        session.id,
        new_id(),
        detail.session.revision,
        "second",
        expected_epoch=service.epoch,
    )
    await harness.wait_inputs(2)
    for index in range(55):
        await connection.text("turn-2", str(index), str(index), complete=True)
    active = await service.get_detail(session.id)
    assert active.items[0].text == "first"
    assert len(active.items) == 60
    await connection.finish("turn-2")
    latest = await service.get_detail(session.id)
    assert run.id not in {value.id for value in latest.runs}
    older = await service.get_detail(session.id, before=latest.next_before)
    assert (
        next(value for value in older.runs if value.id == run.id).error
        == detail.run.error
    )


@pytest.mark.asyncio
async def test_retry_notice_does_not_finish_run_and_stale_error_is_ignored(
    database_factory, code
):
    service, harness, directory = code
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch
    )
    await harness.started.wait()
    connection = harness.connections[0]
    await connection.text("turn-1", "before", "Before retry", complete=True)
    await connection.sink(
        HarnessEvent(
            connection.generation,
            connection.thread_id,
            "error",
            turn_id="turn-1",
            message="retry",
            will_retry=True,
        )
    )
    detail = await service.get_detail(session.id)
    assert detail.run.status == "running"
    assert [item.kind for item in detail.items] == ["user", "text", "notice"]
    assert detail.items[-1].text == "Retrying… retry"
    assert detail.items[-1].sequence > detail.items[-2].sequence
    await connection.sink(
        HarnessEvent(
            connection.generation, connection.thread_id, "error", turn_id="turn-1"
        )
    )
    detail = await service.get_detail(session.id)
    assert detail.run.status == "running"
    assert detail.items[-1].text == "Codex reported an error."
    await connection.text("turn-1", "text", "success", complete=True)
    await connection.finish("turn-1")
    subscription, _ = await service.subscribe()
    cursor = service.cursor
    await connection.sink(
        HarnessEvent(
            connection.generation,
            connection.thread_id,
            "error",
            turn_id="turn-1",
            message="stale",
        )
    )
    assert service.cursor == cursor
    await subscription.aclose()
    assert (await service.get_detail(session.id)).run.error is None
    detail = await service.get_detail(session.id)
    await service.close()
    await close_code_database(service)
    restarted = CodeService(
        SQLiteCodeStore(
            database_factory(directory / "code.db", directory / "code.lock")
        ),
        harness,
    )
    await restarted.start()
    try:
        assert (await restarted.get_detail(session.id)).items == detail.items
    finally:
        await restarted.close()


@pytest.mark.asyncio
@pytest.mark.parametrize("client_id", [True, False])
async def test_acknowledgement_loss_recovers_old_turn_before_newer_send(
    code, client_id
):
    service, harness, _ = code
    session = await session_for(code)
    harness.start_gate.clear()
    first = await service.send(
        session.id, new_id(), session.revision, "first", expected_epoch=service.epoch
    )
    await harness.submitted.wait()
    connection = harness.connections[0]
    harness.histories[connection.thread_id] = [
        ItemUpdate(
            "turn-1",
            "native-user",
            "user",
            text="first",
            complete=True,
            client_id=first.id if client_id else None,
        ),
        ItemUpdate("turn-1", "tail", "text", text="recovered tail", complete=True),
    ]
    await connection.close()
    await service.wait_idle(session.id)
    detail = await service.get_detail(session.id)
    assert detail.run.status == "failed"
    await service.send(
        session.id,
        new_id(),
        detail.session.revision,
        "second",
        expected_epoch=service.epoch,
    )
    await harness.wait_inputs(2)
    recovered = await service.get_detail(session.id)
    assert [item.text for item in recovered.items] == [
        "first",
        "recovered tail",
        "second",
    ]
    assert recovered.runs[0].status == "failed"
    assert recovered.items[0].id == first.id


@pytest.mark.asyncio
async def test_prompt_membership_and_deleted_subscription_are_authoritative(code):
    service, harness, _ = code
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "first", expected_epoch=service.epoch
    )
    await harness.started.wait()
    connection = harness.connections[0]
    await connection.prompt(0, turn_id=None)
    detail = await service.get_detail(session.id)
    assert detail.active_prompt_ids == (detail.prompts[0].id,)
    await connection.resolve(0)
    assert (await service.get_detail(session.id)).active_prompt_ids == ()
    await connection.finish("turn-1")
    session = (await service.get_detail(session.id)).session
    await service.delete_session(session.id, session.revision)
    await service.wait_idle(session.id)
    subscription, ready = await service.subscribe()
    assert ready["sessions"] == []
    assert session.id not in service._owners
    await subscription.aclose()


@pytest.mark.asyncio
async def test_ambiguous_native_history_fails_recovery_without_resending_input(code):
    service, harness, _ = code
    session = await session_for(code)
    harness.start_gate.clear()
    await service.send(
        session.id, new_id(), session.revision, "first", expected_epoch=service.epoch
    )
    await harness.submitted.wait()
    connection = harness.connections[0]
    harness.histories[connection.thread_id] = [
        ItemUpdate(turn_id, "item", "text", text="unmatched", complete=True)
        for turn_id in ("unknown-1", "unknown-2")
    ]
    await connection.close()
    await service.wait_idle(session.id)
    detail = await service.get_detail(session.id)
    await service.send(
        session.id,
        new_id(),
        detail.session.revision,
        "second",
        expected_epoch=service.epoch,
    )
    await service.wait_idle(session.id)
    detail = await service.get_detail(session.id)
    assert detail.run.status == "failed"
    assert "could not be matched" in detail.run.error
    assert [item.text for item in detail.items] == ["first", "second"]
    assert sum(len(connection.inputs) for connection in harness.connections) == 1


@pytest.mark.asyncio
async def test_settings_and_send_compete_for_the_same_revision(code):
    service, harness, _ = code
    session = await session_for(code)
    outcomes = await asyncio.gather(
        service.update_settings(
            session.id, session.revision, {"reasoning_effort": "high"}
        ),
        service.send(
            session.id,
            new_id(),
            session.revision,
            "hello",
            expected_epoch=service.epoch,
        ),
        return_exceptions=True,
    )
    assert sum(isinstance(result, CodeConflictError) for result in outcomes) == 1
    detail = await service.get_detail(session.id)
    assert detail.session.revision == session.revision + 1
    if detail.run:
        assert detail.run.reasoning_effort == "medium"
    else:
        assert detail.session.reasoning_effort == "high"
        assert harness.connections == []


@pytest.mark.asyncio
async def test_old_service_epoch_cannot_admit_a_new_send_but_can_read_receipt(code):
    service, harness, _ = code
    session = await session_for(code)
    with pytest.raises(CodeConflictError, match="restarted"):
        await service.send(
            session.id, new_id(), session.revision, "stale", expected_epoch="previous"
        )
    assert harness.connections == []
    run = await service.send(
        session.id, new_id(), session.revision, "accepted", expected_epoch=service.epoch
    )
    repeated = await service.send(
        session.id, run.id, session.revision, "accepted", expected_epoch="previous"
    )
    assert repeated.id == run.id


@pytest.mark.asyncio
async def test_poorer_native_history_keeps_captured_source_and_reasoning(code):
    service, harness, _ = code
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "first", expected_epoch=service.epoch
    )
    await harness.started.wait()
    connection = harness.connections[0]
    original = ItemUpdate(
        "turn-1",
        "reasoning",
        "reasoning",
        text="Full captured reasoning",
        complete=True,
        raw={
            "item": {
                "id": "reasoning",
                "summary": ["original"],
                "opaque": {"signature": "retained"},
            },
            "stream": {"reasoning": {"0": "full"}},
        },
    )
    await connection.sink(
        HarnessEvent(
            connection.generation,
            connection.thread_id,
            "item",
            turn_id="turn-1",
            item=original,
        )
    )
    await connection.finish("turn-1")
    harness.histories[connection.thread_id] = [
        ItemUpdate(
            "turn-1",
            "reasoning",
            "reasoning",
            text="Shorter native history",
            complete=True,
            raw={"item": {"id": "reasoning", "summary": []}, "stream": {}},
        )
    ]
    harness.configurations[harness.model] = "changed"
    detail = await service.get_detail(session.id)
    await service.send(
        session.id,
        new_id(),
        detail.session.revision,
        "next",
        expected_epoch=service.epoch,
    )
    await harness.wait_inputs(2)
    retained = next(
        item
        for item in (await service.get_detail(session.id)).items
        if item.native_item_id == "reasoning"
    )
    assert retained.text == original.text
    assert retained.raw == original.raw


@pytest.mark.asyncio
async def test_storage_start_failure_is_isolated_to_code(database_factory, tmp_path):
    class BrokenStore(SQLiteCodeStore):
        async def start(self):
            raise CodeUnavailableError("Code disk unavailable")

    service = CodeService(
        BrokenStore(database_factory(tmp_path / "code.db", tmp_path / "code.lock")),
        FakeHarness(),
    )
    try:
        await service.start()
        assert service.availability() == (False, "Code disk unavailable")
    finally:
        await service.close()
        await close_code_database(service)


@pytest.mark.asyncio
async def test_shutdown_settles_run_when_native_interrupt_never_acknowledges(code):
    service, harness, _ = code
    session = await session_for(code)
    await service.send(
        session.id,
        new_id(),
        session.revision,
        "stop on shutdown",
        expected_epoch=service.epoch,
    )
    await harness.started.wait()
    harness.interrupt_gate.clear()
    await asyncio.wait_for(service.close(), 8)
    assert harness.connections[0].closed


@pytest.mark.asyncio
async def test_storage_failure_retires_native_work_even_with_pending_prompt(
    code, monkeypatch, caplog
):
    service, harness, _ = code
    session = await session_for(code)
    run = await service.send(
        session.id, new_id(), session.revision, "prompt", expected_epoch=service.epoch
    )
    await harness.started.wait()
    connection = harness.connections[0]
    await connection.prompt(1)

    error = CodeUnavailableError("Code disk unavailable")

    async def fail_save(*args, **kwargs):
        raise error

    monkeypatch.setattr(service._store, "save_progress", fail_save)
    await connection.text("turn-1", "text", "unsaved", complete=True)
    await asyncio.wait_for(service.wait_idle(session.id), 3)
    assert connection.closed
    with pytest.raises(CodeUnavailableError):
        await service.get_detail(session.id)
    await service.close()
    failures = [record for record in caplog.records if record.levelname == "ERROR"]
    assert len(failures) == 1
    assert failures[0].extra == {
        "event": "code.storage_failed",
        "operation": "save_progress",
        "session_id": session.id,
        "run_id": run.id,
    }
    assert failures[0].exc_info[1] is error
    assert "fail_save" in caplog.text


@pytest.mark.asyncio
async def test_shutdown_storage_read_failure_logs_original_cause(
    code, monkeypatch, caplog
):
    service, harness, _ = code
    session = await session_for(code)
    run = await service.send(
        session.id, new_id(), session.revision, "work", expected_epoch=service.epoch
    )
    await harness.started.wait()
    error = CodeUnavailableError("Cannot read run during shutdown")
    monkeypatch.setattr(service._store, "get_run", AsyncMock(side_effect=error))

    await service.close()

    assert harness.connections[0].closed
    failures = [record for record in caplog.records if record.levelname == "ERROR"]
    assert len(failures) == 1
    assert failures[0].extra["operation"] == "stop_run"
    assert failures[0].extra["session_id"] == session.id
    assert failures[0].extra["run_id"] == run.id
    assert failures[0].exc_info[1] is error


@pytest.mark.asyncio
@pytest.mark.parametrize("conflict", [False, True])
async def test_delete_before_first_run_logs_only_terminal_storage_failure(
    code, monkeypatch, caplog, conflict
):
    service, _, _ = code
    session = await session_for(code)
    error = (
        CodeConflictError("Revision changed")
        if conflict
        else CodeUnavailableError("Cannot save deletion")
    )
    save = service._store.save_progress
    monkeypatch.setattr(service._store, "save_progress", AsyncMock(side_effect=error))

    with pytest.raises(type(error)):
        await service.delete_session(session.id, session.revision)
    if conflict:
        monkeypatch.setattr(service._store, "save_progress", save)
        assert (await service.get_detail(session.id)).session == session
    else:
        await asyncio.wait_for(service.wait_idle(session.id), 3)
    await service.close()

    failures = [record for record in caplog.records if record.levelname == "ERROR"]
    assert len(failures) == (0 if conflict else 1)
    if not conflict:
        assert failures[0].extra["session_id"] == session.id
        assert failures[0].extra["run_id"] is None
        assert failures[0].extra["operation"] == "save_progress"
        assert failures[0].exc_info[1] is error


@pytest.mark.asyncio
async def test_same_send_id_in_two_sessions_has_independent_receipts(code, monkeypatch):
    service, harness, _ = code
    first, second = await session_for(code), await session_for(code)
    original = service._store.get_run
    looked_up = 0
    barrier = asyncio.Event()

    async def simultaneous_lookup(session_id, run_id):
        nonlocal looked_up
        result = await original(session_id, run_id)
        looked_up += 1
        if looked_up == 2:
            barrier.set()
        await barrier.wait()
        return result

    monkeypatch.setattr(service._store, "get_run", simultaneous_lookup)
    operation = new_id()
    outcomes = await asyncio.gather(
        *(
            service.send(
                session.id,
                operation,
                session.revision,
                "once",
                expected_epoch=service.epoch,
            )
            for session in (first, second)
        ),
        return_exceptions=True,
    )
    assert {
        value.session_id for value in outcomes if not isinstance(value, BaseException)
    } == {first.id, second.id}
    await harness.wait_inputs(2)
    assert sum(len(connection.inputs) for connection in harness.connections) == 2


async def idle_native(code):
    service, harness, _ = code
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "one", expected_epoch=service.epoch
    )
    await harness.started.wait()
    await harness.connections[0].finish("turn-1")
    return (await service.get_detail(session.id)).session


@pytest.mark.asyncio
async def test_deletion_fences_commands_and_repeated_delete_has_one_native_call(code):
    service, harness, folder = code
    session = await idle_native(code)
    project = folder / "project.txt"
    project.write_text("keep")
    harness.delete_gate.clear()
    await service.delete_session(session.id, session.revision)
    await harness.deleting.wait()
    await service.delete_session(session.id, session.revision)
    with pytest.raises(CodeConflictError):
        await service.send(
            session.id, new_id(), session.revision, "late", expected_epoch=service.epoch
        )
    with pytest.raises(CodeConflictError):
        await service.update_settings(session.id, session.revision, {"title": "late"})
    harness.delete_gate.set()
    await service.wait_idle(session.id)
    assert harness.connections[0].deleted == [session.native_thread_id]
    assert project.read_text() == "keep"
    assert not (await service.list_sessions()).sessions


@pytest.mark.asyncio
async def test_lost_native_delete_ack_reconciles_without_repeating_delete(code):
    service, harness, _ = code
    session = await idle_native(code)
    harness.delete_before_error = True
    harness.delete_error = CodeUnavailableError("Delete acknowledgement lost")
    await service.delete_session(session.id, session.revision)
    await service.wait_idle(session.id)
    assert not (await service.list_sessions()).sessions
    assert sum(len(connection.deleted) for connection in harness.connections) == 1


@pytest.mark.asyncio
async def test_local_delete_commit_failure_keeps_fence_and_can_reconcile(
    code, monkeypatch
):
    service, harness, _ = code
    session = await idle_native(code)
    original = service._store.delete

    async def failing_delete(session_id):
        raise CodeUnavailableError("Delete commit failed")

    monkeypatch.setattr(service._store, "delete", failing_delete)
    await service.delete_session(session.id, session.revision)
    await asyncio.wait_for(service.wait_idle(session.id), 3)
    detail = await service.get_detail(session.id)
    assert detail.session.status == "delete_uncertain"
    assert detail.items
    with pytest.raises(CodeConflictError):
        await service.send(
            session.id,
            new_id(),
            detail.session.revision,
            "late",
            expected_epoch=service.epoch,
        )
    monkeypatch.setattr(service._store, "delete", original)
    await service.delete_session(session.id, detail.session.revision)
    await service.wait_idle(session.id)
    assert not (await service.list_sessions()).sessions
    assert sum(len(connection.deleted) for connection in harness.connections) == 1


@pytest.mark.asyncio
async def test_late_old_native_events_cannot_claim_a_new_turn_before_ack(code):
    service, harness, _ = code
    session = await idle_native(code)
    connection = harness.connections[0]
    harness.start_gate.clear()
    harness.started.clear()
    await service.send(
        session.id, new_id(), session.revision, "next", expected_epoch=service.epoch
    )
    await harness.wait_inputs(2)
    await connection.sink(
        HarnessEvent(
            connection.generation,
            connection.thread_id,
            "turn_started",
            turn_id="turn-1",
        )
    )
    await connection.text("turn-1", "late", "obsolete", complete=True)
    await connection.finish("turn-1")
    detail = await service.get_detail(session.id)
    assert detail.run.status == "preparing"
    assert not any(item.text == "obsolete" for item in detail.items)
    harness.start_gate.set()
    await harness.started.wait()
    detail = await service.get_detail(session.id)
    assert detail.run.native_turn_id == "turn-2"


@pytest.mark.asyncio
async def test_creation_identity_received_during_cleanup_is_saved(code, monkeypatch):
    service, harness, _ = code
    session = await session_for(code)
    original_close = FakeConnection.close

    async def failed_create(connection):
        raise CodeUnavailableError("Native creation acknowledgement timed out")

    async def close_with_late_reply(connection):
        connection.thread_id = "late-native-id"
        harness.histories[connection.thread_id] = []
        await original_close(connection)

    monkeypatch.setattr(FakeConnection, "create_thread", failed_create)
    monkeypatch.setattr(FakeConnection, "close", close_with_late_reply)
    await service.send(
        session.id,
        new_id(),
        session.revision,
        "uncertain create",
        expected_epoch=service.epoch,
    )
    await service.wait_idle(session.id)
    detail = await service.get_detail(session.id)
    assert detail.session.native_thread_id == "late-native-id"
    assert detail.run.status == "failed"
    assert not harness.connections[0].inputs


@pytest.mark.asyncio
async def test_failed_stop_persistence_closes_work_without_waiting_for_more_output(
    code, monkeypatch
):
    service, harness, _ = code
    session = await session_for(code)
    run = await service.send(
        session.id,
        new_id(),
        session.revision,
        "quiet work",
        expected_epoch=service.epoch,
    )
    await harness.started.wait()

    async def failed_save(*args, **kwargs):
        raise CodeUnavailableError("Disk failed")

    monkeypatch.setattr(service._store, "save_progress", failed_save)
    with pytest.raises(CodeUnavailableError):
        await service.stop(session.id, run.id)
    await asyncio.wait_for(service.wait_idle(session.id), 3)
    assert harness.connections[0].closed


@pytest.mark.asyncio
async def test_create_is_lazy_and_retry_does_not_duplicate(code):
    service, harness, directory = code
    session = await session_for(code)
    repeated = await service.create_session(session.id, str(directory))
    assert repeated == session
    assert harness.connections == []
    assert len((await service.list_sessions()).sessions) == 1


@pytest.mark.asyncio
async def test_competing_sends_admit_only_one_and_repeat_returns_receipt(code):
    service, harness, _ = code
    session = await session_for(code)
    command = new_id()
    results = await asyncio.gather(
        service.send(
            session.id, command, session.revision, "first", expected_epoch=service.epoch
        ),
        service.send(
            session.id,
            new_id(),
            session.revision,
            "second",
            expected_epoch=service.epoch,
        ),
        return_exceptions=True,
    )
    assert sum(isinstance(result, CodeConflictError) for result in results) == 1
    run = results[0]
    assert not isinstance(run, BaseException)
    await harness.started.wait()
    repeat = await service.send(
        session.id, command, session.revision, "first", expected_epoch=service.epoch
    )
    assert repeat.id == run.id
    assert harness.connections[0].inputs == [(command, "first", "provider/model")]
    with pytest.raises(CodeConflictError):
        await service.send(
            session.id,
            command,
            session.revision,
            "changed",
            expected_epoch=service.epoch,
        )


@pytest.mark.asyncio
async def test_http_cancellation_does_not_cancel_native_creation(code):
    service, harness, _ = code
    session = await session_for(code)
    harness.creation_gate.clear()
    command = new_id()
    await service.send(
        session.id, command, session.revision, "continue", expected_epoch=service.epoch
    )
    await harness.creating.wait()
    # There is no HTTP-owned native waiter left to cancel after admission.
    detail = await service.get_detail(session.id)
    assert detail.run.id == command
    harness.creation_gate.set()
    await harness.started.wait()
    detail = await service.get_detail(session.id)
    assert detail.session.native_thread_id == "native-1"
    assert harness.connections[0].inputs[0][0] == command


@pytest.mark.asyncio
async def test_stop_before_native_ack_targets_that_run_only(code):
    service, harness, _ = code
    session = await session_for(code)
    harness.start_gate.clear()
    run = await service.send(
        session.id, new_id(), session.revision, "first", expected_epoch=service.epoch
    )
    await harness.submitted.wait()
    await service.stop(session.id, run.id)
    harness.start_gate.set()
    await harness.interrupted.wait()
    connection = harness.connections[0]
    assert connection.interrupts == ["turn-1"]
    await connection.finish("turn-1", "interrupted")
    detail = await service.get_detail(session.id)
    assert detail.run.status == "interrupted"
    second = await service.send(
        session.id,
        new_id(),
        detail.session.revision,
        "second",
        expected_epoch=service.epoch,
    )
    await harness.wait_inputs(2)
    await service.stop(session.id, run.id)
    assert second.id != run.id
    assert connection.interrupts == ["turn-1"]


@pytest.mark.asyncio
async def test_stop_during_creation_prevents_native_submission(code):
    service, harness, _ = code
    session = await session_for(code)
    harness.creation_gate.clear()
    run = await service.send(
        session.id,
        new_id(),
        session.revision,
        "do not run",
        expected_epoch=service.epoch,
    )
    await harness.creating.wait()
    await service.stop(session.id, run.id)
    harness.creation_gate.set()
    await service.wait_idle(session.id)
    detail = await service.get_detail(session.id)
    assert detail.run.status == "interrupted"
    assert detail.session.native_thread_id == "native-1"
    assert harness.connections[0].inputs == []


@pytest.mark.asyncio
async def test_browser_observers_are_independent_of_work(code):
    service, harness, _ = code
    session = await session_for(code)
    first, _ = await service.subscribe()
    second, _ = await service.subscribe()
    await service.send(
        session.id,
        new_id(),
        session.revision,
        "keep running",
        expected_epoch=service.epoch,
    )
    await harness.started.wait()
    await first.aclose()
    await second.aclose()
    connection = harness.connections[0]
    await connection.text("turn-1", "answer", "Still running", complete=True)
    await connection.finish("turn-1")
    detail = await service.get_detail(session.id)
    assert detail.items[-1].text == "Still running"
    assert detail.run.status == "completed"
    assert not connection.closed


@pytest.mark.asyncio
async def test_idle_delete_removes_both_histories_and_blocks_late_create(code):
    service, harness, directory = code
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch
    )
    await harness.started.wait()
    with pytest.raises(CodeConflictError):
        await service.delete_session(session.id, session.revision)
    assert harness.connections[0].deleted == []
    await harness.connections[0].finish("turn-1")
    detail = await service.get_detail(session.id)
    await service.delete_session(session.id, detail.session.revision)
    await service.wait_idle(session.id)
    assert harness.connections[0].deleted == ["native-1"]
    assert (await service.list_sessions()).sessions == ()
    with pytest.raises(CodeConflictError):
        await service.create_session(session.id, str(directory))


@pytest.mark.asyncio
async def test_restart_preserves_receipt_and_does_not_replay_input(
    database_factory, tmp_path
):
    harness = FakeHarness()
    database, lock = tmp_path / "code.db", tmp_path / "code.lock"
    first = CodeService(SQLiteCodeStore(database_factory(database, lock)), harness)
    await first.start()
    session = await first.create_session(new_id(), str(tmp_path))
    run = await first.send(
        session.id, new_id(), session.revision, "once", expected_epoch=first.epoch
    )
    await harness.started.wait()
    await first.close()
    await close_code_database(first)
    second = CodeService(SQLiteCodeStore(database_factory(database, lock)), harness)
    await second.start()
    try:
        repeat = await second.send(
            session.id, run.id, session.revision, "once", expected_epoch=second.epoch
        )
        assert repeat.id == run.id
        assert repeat.status == "interrupted"
        assert len(harness.connections) == 1
        assert harness.connections[0].inputs == [(run.id, "once", "provider/model")]
    finally:
        await second.close()
        await close_code_database(second)


@pytest.mark.asyncio
async def test_two_answers_claim_one_native_prompt(code):
    service, harness, _ = code
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "approval", expected_epoch=service.epoch
    )
    await harness.started.wait()
    connection = harness.connections[0]
    await connection.prompt(0)
    prompt = (await service.get_detail(session.id)).prompts[0]
    harness.answer_gate.clear()
    results = await asyncio.gather(
        service.answer(session.id, prompt.id, new_id(), {"choice": "accept"}),
        service.answer(session.id, prompt.id, new_id(), {"choice": "decline"}),
        return_exceptions=True,
    )
    assert sum(isinstance(result, CodeConflictError) for result in results) == 1
    await harness.answering.wait()
    harness.answer_gate.set()
    await harness.answered.wait()
    assert len(connection.answers) == 1
    assert (await service.get_detail(session.id)).prompts[0].status == "resolved"


@pytest.mark.asyncio
async def test_prompt_arrival_has_one_durable_position_despite_repeated_native_item(
    database_factory,
    code,
):
    service, harness, directory = code
    session = await session_for(code)
    run = await service.send(
        session.id, new_id(), session.revision, "Work", expected_epoch=service.epoch
    )
    await harness.started.wait()
    connection = harness.connections[0]
    await connection.text("turn-1", "shared-tool", "Before approval", kind="tool")
    subscription, _ = await service.subscribe()
    try:
        for request_id in (1, 1, "1"):
            prompt = PromptRequest(
                request_id, "approval", {}, {}, "turn-1", "shared-tool"
            )
            connection.requests[request_id] = prompt
            await connection.sink(
                HarnessEvent(
                    connection.generation,
                    connection.thread_id,
                    "prompt",
                    turn_id="turn-1",
                    prompt=prompt,
                )
            )
        detail = await service.get_detail(session.id)
        entries = [item for item in detail.items if item.kind == "prompt"]
        assert len(entries) == len(detail.prompts) == 2
        assert [item.sequence for item in entries] == [3, 4]
        assert {item.id for item in entries} == {prompt.id for prompt in detail.prompts}
        events = subscription.__aiter__()
        async with asyncio.timeout(2):
            for _ in range(2):
                event = await anext(events)
                if event.event == "item.updated":
                    event = await anext(events)
                assert event.event == "prompt.updated"
                assert event.data["item"]["id"] == event.data["prompt"]["id"]
                assert event.data["runs"][0]["id"] == run.id
        for request_id in (1, "1"):
            await connection.resolve(request_id)
        await connection.text(
            "turn-1", "shared-tool", "Complete output", kind="tool", complete=True
        )
        await connection.text("turn-1", "after", "After approvals", complete=True)
        await connection.finish("turn-1")
        await service.close()
        await close_code_database(service)
        restored = CodeService(
            SQLiteCodeStore(
                database_factory(directory / "code.db", directory / "code.lock")
            ),
            harness,
        )
        await restored.start()
        try:
            saved = await restored.get_detail(session.id)
            assert [item for item in saved.items if item.kind == "prompt"] == entries
            assert [item.sequence for item in saved.items] == [1, 2, 3, 4, 5]
            assert all(prompt.status == "resolved" for prompt in saved.prompts)
            await restored.send(
                session.id,
                new_id(),
                saved.session.revision,
                "Continue",
                expected_epoch=restored.epoch,
            )
            await harness.wait_inputs(2)
            await harness.connections[-1].finish("turn-2")
            recovered = await restored.get_detail(session.id)
            assert [
                item for item in recovered.items if item.kind == "prompt"
            ] == entries
            assert (
                len(
                    [
                        item
                        for item in recovered.items
                        if item.native_item_id == "shared-tool"
                    ]
                )
                == 1
            )
        finally:
            await restored.close()
    finally:
        await subscription.aclose()


@pytest.mark.asyncio
async def test_active_prompt_outside_page_keeps_its_entry_run_and_older_cursor(code):
    service, harness, _ = code
    session = await session_for(code)
    run = await service.send(
        session.id, new_id(), session.revision, "Work", expected_epoch=service.epoch
    )
    await harness.started.wait()
    connection = harness.connections[0]
    await connection.prompt(0, turn_id=None)
    prompt = (await service.get_detail(session.id)).prompts[0]
    for index in range(55):
        await connection.text("turn-1", str(index), f"Output {index}", complete=True)
    await connection.finish("turn-1")
    newest = await service.get_detail(session.id)
    assert newest.next_before is not None
    assert len(newest.items) == 51
    assert newest.items[0].id == prompt.id
    assert newest.items[0].run_id == run.id
    assert newest.active_prompt_ids == (prompt.id,)
    await connection.resolve(0)
    resolved = await service.get_detail(session.id)
    assert resolved.active_prompt_ids == () and resolved.prompts == ()
    assert resolved.next_before == newest.next_before
    older = await service.get_detail(session.id, before=newest.next_before)
    assert older.prompts[0].id == prompt.id and older.prompts[0].status == "resolved"
    by_id = {item.id: item for item in (*older.items, *newest.items)}
    assert sorted(item.sequence for item in by_id.values()) == list(range(1, 58))


@pytest.mark.asyncio
async def test_prompt_during_thread_creation_has_a_saved_run_without_native_ids(code):
    service, harness, _ = code
    session = await session_for(code)
    harness.creation_gate.clear()
    run = await service.send(
        session.id, new_id(), session.revision, "Start", expected_epoch=service.epoch
    )
    await harness.creating.wait()
    connection = harness.connections[0]
    try:
        await connection.prompt(0, turn_id=None)
        detail = await service.get_detail(session.id)
        assert detail.run.native_turn_id is None
        assert detail.items[-1].id == detail.prompts[0].id
        assert detail.items[-1].run_id == run.id
        assert detail.items[-1].sequence == 2
        assert detail.prompts[0].native_turn_id is None
        await connection.resolve(0)
    finally:
        harness.creation_gate.set()


@pytest.mark.asyncio
async def test_native_resolution_while_answer_is_waiting_never_resurrects_prompt(code):
    service, harness, _ = code
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "approval", expected_epoch=service.epoch
    )
    await harness.started.wait()
    connection = harness.connections[0]
    await connection.prompt(0)
    prompt = (await service.get_detail(session.id)).prompts[0]
    harness.answer_gate.clear()
    await service.answer(session.id, prompt.id, new_id(), {"choice": "accept"})
    await harness.answering.wait()
    await connection.resolve(0)
    harness.answer_gate.set()
    await harness.answered.wait()
    assert connection.answers == []
    assert (await service.get_detail(session.id)).prompts[0].status == "resolved"


@pytest.mark.asyncio
async def test_streaming_does_not_invalidate_rename_revision(code):
    service, harness, _ = code
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch
    )
    await harness.started.wait()
    before = await service.get_detail(session.id)
    await harness.connections[0].text("turn-1", "answer", "partial")
    after = await service.get_detail(session.id)
    assert after.version > before.version
    assert after.session.revision == before.session.revision
    await service.update_settings(
        session.id, before.session.revision, {"title": "My code"}
    )
    assert (await service.get_detail(session.id)).session.title == "My code"


@pytest.mark.asyncio
async def test_context_usage_is_an_absolute_deduplicated_session_snapshot(code):
    service, harness, _ = code
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch
    )
    await harness.started.wait()
    connection = harness.connections[0]
    before = await service.get_detail(session.id)
    subscription, _ = await service.subscribe()
    events = subscription.__aiter__()
    try:
        await connection.context_usage("turn-1", 90_000)
        async with asyncio.timeout(2):
            event = await anext(events)
        after = await service.get_detail(session.id)
        assert event.event == "session.updated"
        assert event.data["session"]["context_used_tokens"] == 90_000
        assert after.session.context_used_tokens == 90_000
        assert after.session.revision == before.session.revision
        assert after.session.updated_at == before.session.updated_at
        assert (
            await service._store.get_session(session.id)
        ).context_used_tokens == 90_000

        await connection.context_usage("turn-1", 90_000)
        duplicate = await service.get_detail(session.id)
        assert duplicate.version == after.version

        await connection.context_usage("turn-1", 25_000)
        compacted = await service.get_detail(session.id)
        assert compacted.session.context_used_tokens == 25_000
        assert compacted.session.revision == after.session.revision
        assert compacted.session.updated_at == after.session.updated_at
        await connection.finish("turn-1")
    finally:
        await subscription.aclose()


@pytest.mark.asyncio
async def test_context_usage_is_retained_across_model_changes(code):
    service, harness, _ = code
    harness.configurations["provider/other"] = "other"
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "first", expected_epoch=service.epoch
    )
    await harness.started.wait()
    connection = harness.connections[0]
    await connection.context_usage("turn-1", 40_000)
    await connection.finish("turn-1")

    detail = await service.get_detail(session.id)
    changed = await service.update_settings(
        session.id, detail.session.revision, {"model": "provider/other"}
    )
    assert changed.context_used_tokens == 40_000
    restored = await service.update_settings(
        session.id, changed.revision, {"model": "provider/model"}
    )
    assert restored.context_used_tokens == 40_000
    assert (await service._store.get_session(session.id)).context_used_tokens == 40_000

    await service.send(
        session.id,
        new_id(),
        restored.revision,
        "second",
        expected_epoch=service.epoch,
    )
    await harness.wait_inputs(2)
    await connection.context_usage("turn-2", 7_500)
    current = await service.get_detail(session.id)
    assert current.session.context_used_tokens == 7_500
    await connection.finish("turn-2")


@pytest.mark.asyncio
async def test_resumed_context_usage_is_accepted_after_the_next_run_is_admitted(code):
    service, harness, _ = code
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "first", expected_epoch=service.epoch
    )
    await harness.started.wait()
    original = harness.connections[0]
    await original.context_usage("turn-1", 10_000)
    await original.finish("turn-1")

    session = (await service.get_detail(session.id)).session
    harness.configurations[harness.model] = "replacement"
    harness.start_gate.clear()
    harness.started.clear()
    harness.submitted.clear()
    await service.send(
        session.id, new_id(), session.revision, "second", expected_epoch=service.epoch
    )
    await harness.submitted.wait()
    resumed = harness.connections[1]
    assert original.closed
    assert resumed.resumed == [session.native_thread_id]

    await resumed.context_usage("turn-1", 11_000)
    await resumed.context_usage("turn-1", 12_000, generation=original.generation)
    await resumed.context_usage("turn-1", 13_000, thread_id="another-thread")
    replayed = await service.get_detail(session.id)
    assert replayed.session.context_used_tokens == 11_000
    assert (await service._store.get_session(session.id)).context_used_tokens == 11_000

    harness.start_gate.set()
    await harness.started.wait()
    await resumed.context_usage("turn-2", 20_000)
    current = await service.get_detail(session.id)
    assert current.session.context_used_tokens == 20_000
    await resumed.finish("turn-2")


@pytest.mark.asyncio
async def test_catalog_replacement_is_limited_to_selected_entry_and_session(code):
    service, harness, _ = code
    harness.configurations["provider/other"] = "other-1"
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "first", expected_epoch=service.epoch
    )
    await harness.started.wait()
    original = harness.connections[0]
    await original.finish("turn-1")
    harness.model = "provider/other"
    detail = await service.get_detail(session.id)
    selected = await service.update_settings(
        session.id, detail.session.revision, {"model": harness.model}
    )
    await service.send(
        session.id,
        new_id(),
        selected.revision,
        "second",
        expected_epoch=service.epoch,
    )
    await harness.wait_inputs(2)
    await original.finish("turn-2")
    assert len(harness.connections) == 1
    harness.configurations["unrelated/model"] = "new"
    harness.configurations["provider/other"] = "changed"
    detail = await service.get_detail(session.id)
    await service.send(
        session.id,
        new_id(),
        detail.session.revision,
        "third",
        expected_epoch=service.epoch,
    )
    await harness.wait_inputs(3)
    assert len(harness.connections) == 2
    assert original.closed
    assert harness.connections[1].resumed == ["native-1"]


@pytest.mark.asyncio
async def test_cancelled_http_admission_still_commits_and_executes_once(
    database_factory, tmp_path
):
    committed = asyncio.Event()
    release = asyncio.Event()

    class GatedStore(SQLiteCodeStore):
        async def admit_run(self, session, run, item, expected_revision):
            result = await super().admit_run(session, run, item, expected_revision)
            committed.set()
            await release.wait()
            return result

    harness = FakeHarness()
    service = CodeService(
        GatedStore(database_factory(tmp_path / "code.db", tmp_path / "code.lock")),
        harness,
    )
    await service.start()
    try:
        session = await service.create_session(new_id(), str(tmp_path))
        operation_id = new_id()
        http = asyncio.create_task(
            service.send(
                session.id,
                operation_id,
                session.revision,
                "once",
                expected_epoch=service.epoch,
            )
        )
        await committed.wait()
        http.cancel()
        with pytest.raises(asyncio.CancelledError):
            await http
        release.set()
        await harness.started.wait()
        repeat = await service.send(
            session.id,
            operation_id,
            session.revision,
            "once",
            expected_epoch=service.epoch,
        )
        assert repeat.id == operation_id
        assert len(harness.connections[0].inputs) == 1
    finally:
        release.set()
        await service.close()
        await close_code_database(service)


@pytest.mark.asyncio
@pytest.mark.parametrize("trigger", ["timer", "size", "complete", "detail"])
async def test_buffer_staging_and_each_flush_preserve_commit_and_observer_order(
    code, monkeypatch, flush_timer, trigger
):
    service, harness, _ = code
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch
    )
    await harness.started.wait()
    before = await service.get_detail(session.id)
    connection = harness.connections[0]
    subscription, _ = await service.subscribe()
    save = service._store.save_progress
    writes = []

    async def observe_save(session, revision, **values):
        if values.get("items"):
            assert service.cursor == before.cursor
        await save(session, revision, **values)
        if values.get("items"):
            assert service.cursor == before.cursor
            writes.append(tuple(values["items"]))

    monkeypatch.setattr(service._store, "save_progress", observe_save)
    try:
        text = "x" * 4095
        await connection.text("turn-1", "answer", text)
        await asyncio.wait_for(flush_timer[0].wait(), 3)
        await connection.text("turn-1", "answer", text)
        observer, snapshot = await service.subscribe()
        await observer.aclose()
        assert snapshot["sessions"][0]["version"] == before.version + 1
        assert snapshot["cursor"] == before.cursor
        assert await service._store.items(session.id, None, None) == before.items
        assert writes == []

        if trigger == "timer":
            flush_timer[1].set()
        elif trigger == "size":
            await connection.text("turn-1", "answer", text + "x")
        elif trigger == "complete":
            await connection.text("turn-1", "answer", text, complete=True)
        else:
            await service.get_detail(session.id)

        event = await asyncio.wait_for(anext(aiter(subscription)), 3)
        assert event.event == "item.updated"
        assert event.id == before.cursor + 1
        assert event.data["version"] == before.version + (
            3 if trigger in {"size", "complete"} else 2
        )
        assert len(writes) == 1 and len(writes[0]) == 1
        saved = (await service._store.items(session.id, None, None))[-1]
        assert saved == writes[0][0]
        assert event.data["item"] == saved.model_dump(mode="json")
        assert saved.text == text + ("x" if trigger == "size" else "")
        assert saved.complete == (trigger == "complete")
    finally:
        flush_timer[1].set()
        await subscription.aclose()


@pytest.mark.asyncio
async def test_failed_terminal_bundle_retains_committed_records_and_staged_output(
    code, monkeypatch, flush_timer
):
    service, harness, _ = code
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "hello", expected_epoch=service.epoch
    )
    await harness.started.wait()
    connection = harness.connections[0]
    await connection.prompt(1)
    before = await service.get_detail(session.id)
    await connection.text("turn-1", "answer", "unsaved")
    await asyncio.wait_for(flush_timer[0].wait(), 3)
    save, publish = service._store.save_progress, service._events.publish
    attempted, published = [], []

    async def reject_terminal(session, revision, **values):
        run = values.get("run")
        if run is not None and run.status == "completed":
            attempted.append((session, values))
            raise CodeUnavailableError("Terminal commit failed")
        await save(session, revision, **values)

    def observe(event, data):
        published.append((event, data))
        return publish(event, data)

    monkeypatch.setattr(service._store, "save_progress", reject_terminal)
    monkeypatch.setattr(service._events, "publish", observe)
    await connection.finish("turn-1")
    await asyncio.wait_for(service.wait_idle(session.id), 3)
    assert len(attempted) == 1
    candidate_session, values = attempted[0]
    assert candidate_session.revision == before.session.revision + 1
    assert [item.text for item in values["items"]] == ["unsaved"]
    assert [prompt.status for prompt in values["prompts"]] == ["expired"]
    assert await service._store.get_session(session.id) == before.session
    assert await service._store.latest_run(session.id) == before.run
    assert await service._store.items(session.id, None, None) == before.items
    assert await service._store.prompts(session.id) == before.prompts
    owner = service._owners[session.id]
    assert owner.state.session == before.session and owner.state.run == before.run
    assert owner.state.runs[before.run.id] == before.run
    assert tuple(owner.state.prompts.values()) == before.prompts
    assert [item.text for item in owner.state.pending_items] == ["unsaved"]
    assert connection.closed
    assert published and all(event == "session.notice" for event, _ in published)
    assert all(
        data["run"] == before.run.model_dump(mode="json") for _, data in published
    )
    with pytest.raises(CodeUnavailableError):
        await service.get_detail(session.id)


@pytest.mark.asyncio
@pytest.mark.parametrize("fail", [False, True])
async def test_review_liveness_flush_includes_pending_output_and_keeps_staging_version(
    code, monkeypatch, flush_timer, fail
):
    service, harness, _ = code
    session = await session_for(code)
    await service.send(
        session.id, new_id(), session.revision, "Delegate", expected_epoch=service.epoch
    )
    await harness.started.wait()
    first = harness.connections[0]
    packets = CodexPackets(first)
    await packets.spawn()
    await packets.review()
    review = (await service.get_detail(session.id)).items[-1]
    await first.finish("turn-1")
    harness.configurations[harness.model] = "replacement"
    session = (await service.get_detail(session.id)).session
    harness.started.clear()
    await service.send(
        session.id, new_id(), session.revision, "Continue", expected_epoch=service.epoch
    )
    await asyncio.wait_for(harness.started.wait(), 3)
    second = harness.connections[1]
    before = await service.get_detail(session.id)
    packets = CodexPackets(second)
    await packets.spawn()
    await second.text("turn-2", "reply", "pending")
    await asyncio.wait_for(flush_timer[0].wait(), 3)
    save, publish = service._store.save_progress, service._events.publish
    writes, published = [], []

    async def observe_save(session, revision, **values):
        assert service._version == before.version + 1
        assert service.cursor == before.cursor
        writes.append(tuple(values["items"]))
        if fail:
            raise CodeUnavailableError("Review flush failed")
        await save(session, revision, **values)

    def observe(event, data):
        published.append((event, data))
        return publish(event, data)

    monkeypatch.setattr(service._store, "save_progress", observe_save)
    monkeypatch.setattr(service._events, "publish", observe)
    await packets.review()
    assert len(writes) == 1
    assert {item.id for item in writes[0]} == {
        review.id,
        next(item.id for item in writes[0] if item.text == "pending"),
    }
    if fail:
        await asyncio.wait_for(service.wait_idle(session.id), 3)
        assert second.closed
        assert all(event != "item.updated" for event, _ in published)
        assert published[-1][1]["active_review_ids"] == []
        assert {
            item.id for item in service._owners[session.id].state.pending_items
        } == {item.id for item in writes[0]}
    else:
        assert [event for event, _ in published] == ["item.updated", "item.updated"]
        assert [data["version"] for _, data in published] == [
            before.version + 2,
            before.version + 3,
        ]
        assert all(data["active_review_ids"] == [review.id] for _, data in published)
        assert next(item for item in writes[0] if item.id == review.id) == review
    monkeypatch.setattr(service._store, "save_progress", save)


@pytest.mark.asyncio
@pytest.mark.parametrize("native_exists", [False, True])
async def test_startup_reconciles_persisted_deletion_without_another_native_delete(
    database_factory, code, native_exists
):
    service, harness, directory = code
    session = await idle_native(code)
    await service._store.save_progress(
        session.model_copy(
            update={"status": "deleting", "revision": session.revision + 1}
        ),
        session.revision,
    )
    await service.close()
    await close_code_database(service)
    if not native_exists:
        harness.histories.pop(session.native_thread_id)
    restarted = CodeService(
        SQLiteCodeStore(
            database_factory(directory / "code.db", directory / "code.lock")
        ),
        harness,
    )
    try:
        await restarted.start()
        await asyncio.wait_for(restarted.wait_idle(session.id), 3)
        if native_exists:
            detail = await restarted.get_detail(session.id)
            assert detail.session.status == "ready" and detail.items
        else:
            assert not (await restarted.list_sessions()).sessions
            assert await restarted._store.is_deleted(session.id)
        assert all(connection.deleted == [] for connection in harness.connections)
    finally:
        await restarted.close()


@pytest.mark.asyncio
@pytest.mark.parametrize("may_have_input", [False, True])
async def test_missing_native_history_is_recreated_only_before_possible_input(
    database_factory, code, may_have_input
):
    service, harness, directory = code
    session = await session_for(code)
    await service._store.save_progress(
        session.model_copy(
            update={
                "native_thread_id": "missing",
                "native_may_have_input": may_have_input,
            }
        ),
        session.revision,
    )
    await service.close()
    await close_code_database(service)
    restarted = CodeService(
        SQLiteCodeStore(
            database_factory(directory / "code.db", directory / "code.lock")
        ),
        harness,
    )
    try:
        await restarted.start()
        await restarted.send(
            session.id,
            new_id(),
            session.revision,
            "next",
            expected_epoch=restarted.epoch,
        )
        if not may_have_input:
            await asyncio.wait_for(harness.started.wait(), 3)
            await harness.connections[-1].finish("turn-1")
        await asyncio.wait_for(restarted.wait_idle(session.id), 3)
        detail = await restarted.get_detail(session.id)
        assert detail.run is not None
        assert detail.run.status == ("failed" if may_have_input else "completed")
        assert len(harness.connections[-1].inputs) == (0 if may_have_input else 1)
    finally:
        await restarted.close()


@pytest.mark.asyncio
async def test_cancelled_close_waiter_does_not_cancel_owned_shutdown(code, monkeypatch):
    service, harness, _ = code
    session = await idle_native(code)
    connection = harness.connections[0]
    entered, release = asyncio.Event(), asyncio.Event()
    close = connection.close

    async def gated_close():
        entered.set()
        await release.wait()
        await close()

    monkeypatch.setattr(connection, "close", gated_close)
    waiter = asyncio.create_task(service.close())
    try:
        await asyncio.wait_for(entered.wait(), 3)
        waiter.cancel()
        with pytest.raises(asyncio.CancelledError):
            await waiter
        with pytest.raises(CodeUnavailableError):
            await service.send(
                session.id,
                new_id(),
                session.revision,
                "late",
                expected_epoch=service.epoch,
            )
        release.set()
        await asyncio.wait_for(asyncio.gather(service.close(), service.close()), 3)
        assert connection.closed and service.availability()[0] is False
    finally:
        release.set()
        await service.close()
        await close_code_database(service)