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
36.0 KB
Raw Blame
import asyncio
import json
import sqlite3
import threading
from contextlib import closing, suppress
from unittest.mock import AsyncMock, Mock, patch

import pytest
import pytest_asyncio

from free_claude_code.messaging.models import IncomingMessage, MessageScope
from free_claude_code.messaging.trees import MessagingStorageError, TreeQueueManager
from free_claude_code.messaging.trees.snapshot import TreeSnapshot
from free_claude_code.messaging.workflow import MessagingWorkflow
from free_claude_code.runtime.code_sessions_sqlite import SQLiteCodeStore
from free_claude_code.runtime.messaging_import import import_legacy
from free_claude_code.runtime.messaging_sqlite import SQLiteMessagingStore
from free_claude_code.runtime.sqlite_database import SQLiteDatabase

pytestmark = pytest.mark.asyncio


def tree(platform="telegram", chat="chat", root="root"):
    return TreeSnapshot(
        scope=MessageScope(platform=platform, chat_id=chat),
        root_id=root,
        nodes={
            root: {
                "node_id": root,
                "status_message_id": f"status-{root}",
                "state": "completed",
                "parent_id": None,
                "parent_reference_id": None,
                "session_id": "native-session",
            }
        },
    )


@pytest_asyncio.fixture
async def storage(tmp_path):
    database = SQLiteDatabase(tmp_path / "fcc.db", tmp_path / "code.lock")
    await database.start()
    try:
        yield SQLiteMessagingStore(database, managed_message_cap=2)
    finally:
        await database.close()


async def test_tree_and_managed_messages_are_durable_and_scope_isolated(storage):
    first, second = tree(), tree("discord")
    await storage.commit_trees((first, second))
    for message in ("one", "two", "two", "three"):
        await storage.record_message_id("telegram", "chat", message, "in", "prompt")
    assert await storage.get_tracked_message_ids_for_chat("telegram", "chat") == [
        "two",
        "three",
    ]
    await storage.commit_trees((), clear_scope=first.scope)
    loaded = await storage.load_conversation_snapshot()
    assert list(loaded.trees) == [second.identity]
    assert loaded.trees[second.identity].nodes["root"]["session_id"] == "native-session"
    assert not await storage.get_tracked_message_ids_for_chat("telegram", "chat")


async def test_reference_collision_rolls_back_whole_write(storage):
    original = tree()
    await storage.commit_trees((original,))
    collision = tree(root="status-root")
    with pytest.raises(MessagingStorageError) as failure:
        await storage.commit_trees((collision,))
    assert isinstance(failure.value.__cause__, sqlite3.IntegrityError)
    assert (await storage.load_conversation_snapshot()).trees == {
        original.identity: original
    }


@pytest.mark.parametrize("damaged", [False, True])
async def test_import_keeps_valid_data_and_never_replays_after_clear(
    storage, tmp_path, damaged
):
    source = tmp_path / "sessions.json"
    valid = tree()
    source.write_text(
        json.dumps(
            {
                "conversation": {
                    "trees": [valid.to_json(), *([{"broken": True}] if damaged else [])]
                }
            }
        )
    )
    warning = await import_legacy(storage.database, source)
    assert bool(warning) is damaged
    assert source.exists() is damaged
    assert (await storage.load_conversation_snapshot()).trees == {valid.identity: valid}
    await storage.commit_trees((), clear_scope=valid.scope)
    assert await import_legacy(storage.database, source) is None
    assert (await storage.load_conversation_snapshot()).is_empty


async def test_unreadable_json_does_not_block_new_conversations(storage, tmp_path):
    source = tmp_path / "sessions.json"
    source.write_text('{"conversation":')
    assert await import_legacy(storage.database, source)
    assert source.read_text() == '{"conversation":'
    await storage.commit_trees((tree(),))
    assert not (await storage.load_conversation_snapshot()).is_empty
    assert await import_legacy(storage.database, source) is None


async def test_pending_import_keeps_restart_repair_information(storage, tmp_path):
    pending = tree()
    pending.nodes["root"]["state"] = "in_progress"
    source = tmp_path / "sessions.json"
    source.write_text(json.dumps(pending_to_legacy(pending)))
    await import_legacy(storage.database, source)
    assert (await storage.load_conversation_snapshot()).trees[pending.identity].nodes[
        "root"
    ]["state"] == "in_progress"


def pending_to_legacy(snapshot):
    return {"trees": {snapshot.root_id: snapshot.to_json()}}


async def test_new_schema_preserves_foreign_keys(storage):
    await storage.commit_trees((tree(),))
    with closing(sqlite3.connect(storage.database.path)) as connection:
        assert connection.execute("PRAGMA foreign_key_check").fetchall() == []


async def test_sqlite_prevents_deleting_a_root_without_its_tree(storage):
    original = tree()
    await storage.commit_trees((original,))
    with pytest.raises(sqlite3.IntegrityError):
        await storage.database.run(
            lambda connection: connection.execute("DELETE FROM messaging_nodes")
        )
    assert (await storage.load_conversation_snapshot()).trees == {
        original.identity: original
    }


@pytest.mark.parametrize("wrapped", [False, True])
@pytest.mark.parametrize("dictionary", [False, True])
async def test_historical_formats_and_message_log_preserve_resume_and_order(
    storage, tmp_path, wrapped, dictionary
):
    original = tree()
    legacy = original.to_json()
    del legacy["scope"]
    legacy["nodes"]["root"]["incoming"] = {"platform": "telegram", "chat_id": "chat"}
    trees = {"old": legacy} if dictionary else [legacy]
    conversation = {"trees": trees}
    payload = {"conversation": conversation} if wrapped else conversation
    payload["message_log"] = {
        "telegram:chat": [
            {"message_id": value, "direction": "out", "kind": "notice"}
            for value in (1, 2, 2, 3)
        ]
    }
    source = tmp_path / "sessions.json"
    source.write_text(json.dumps(payload))
    assert await import_legacy(storage.database, source) is None
    assert not source.exists()
    loaded = (await storage.load_conversation_snapshot()).trees[original.identity]
    assert loaded.nodes["root"]["session_id"] == "native-session"
    await storage.trim()
    assert await storage.get_tracked_message_ids_for_chat("telegram", "chat") == [
        "2",
        "3",
    ]


async def test_cleanup_failure_cannot_resurrect_cleared_history(storage, tmp_path):
    source = tmp_path / "sessions.json"
    original = tree()
    source.write_text(json.dumps(pending_to_legacy(original)))
    with patch.object(type(source), "unlink", side_effect=PermissionError("busy")):
        assert await import_legacy(storage.database, source)
    assert source.exists()
    await storage.commit_trees((), clear_scope=original.scope)
    assert await import_legacy(storage.database, source) is None
    assert not source.exists()
    assert (await storage.load_conversation_snapshot()).is_empty


async def test_invalid_graph_and_invalid_log_entry_do_not_discard_good_records(
    storage, tmp_path
):
    original, invalid = tree(), tree(root="bad")
    invalid.nodes["bad"]["parent_id"] = "missing"
    source = tmp_path / "sessions.json"
    source.write_text(
        json.dumps(
            {
                "trees": [original.to_json(), invalid.to_json()],
                "managed_messages": {
                    "discord:other": [
                        {"message_id": "good", "direction": "in", "kind": "prompt"},
                        {"message_id": "bad"},
                    ]
                },
            }
        )
    )
    assert await import_legacy(storage.database, source)
    assert source.exists()
    assert list((await storage.load_conversation_snapshot()).trees) == [
        original.identity
    ]
    assert await storage.get_tracked_message_ids_for_chat("discord", "other") == [
        "good"
    ]


async def test_failed_import_transaction_keeps_source_and_allows_retry(
    storage, tmp_path
):
    from free_claude_code.runtime.messaging_sqlite import write_tree

    source = tmp_path / "sessions.json"
    source.write_text(
        json.dumps({"trees": [tree().to_json(), tree(root="second").to_json()]})
    )

    def fail_second_tree(connection, snapshot):
        write_tree(connection, snapshot)
        if snapshot.root_id == "second":
            raise sqlite3.OperationalError("disk failure")

    with (
        patch(
            "free_claude_code.runtime.messaging_import.write_tree",
            side_effect=fail_second_tree,
        ),
        pytest.raises(sqlite3.OperationalError),
    ):
        await import_legacy(storage.database, source)
    assert source.exists()
    assert (await storage.load_conversation_snapshot()).is_empty
    assert (
        await storage.database.run(
            lambda connection: connection.execute(
                "SELECT count(*) FROM messaging_legacy_import"
            ).fetchone()[0],
            write=False,
        )
        == 0
    )
    assert await import_legacy(storage.database, source) is None
    assert not source.exists()


def incoming(node, *, text="prompt"):
    return IncomingMessage(
        platform="telegram", chat_id="chat", message_id=node, user_id="user", text=text
    )


async def import_receipt(database):
    return await database.run(
        lambda connection: dict(
            connection.execute("SELECT * FROM messaging_legacy_import").fetchone()
        ),
        write=False,
    )


@pytest.mark.parametrize(
    "field,value",
    [
        ("platform", "\ud800"),
        ("chat_id", "\ud800"),
        ("root_id", "\ud800"),
        ("root_id", "\0root"),
        ("node_id", "\ud800"),
        ("node_id", "\0child"),
        ("status_message_id", "\ud800"),
        ("status_message_id", "\0status"),
        ("session_id", "\ud800"),
    ],
)
async def test_import_rejects_storage_invalid_tree_without_reserving_references(
    storage, tmp_path, field, value
):
    before, after = tree(root="before"), tree(root="after")
    invalid = tree(root=value if field == "root_id" else "bad").to_json()
    root = invalid["root_id"]
    child = value if field == "node_id" else "child"
    invalid["nodes"][child] = {
        "node_id": child,
        "parent_id": root,
        "parent_reference_id": invalid["nodes"][root]["status_message_id"],
        "status_message_id": "shared-reference",
        "state": "completed",
        "session_id": "native-child",
    }
    if field in {"platform", "chat_id"}:
        invalid["scope"][field] = value
    elif field not in {"root_id", "node_id"}:
        invalid["nodes"][child][field] = value
    # A rejected tree must not claim a reference needed by a later valid tree.
    after.nodes["after"]["status_message_id"] = "shared-reference"
    source = tmp_path / "sessions.json"
    original = json.dumps({"trees": [before.to_json(), invalid, after.to_json()]})
    source.write_text(original)

    assert await import_legacy(storage.database, source)
    assert (await storage.load_conversation_snapshot()).trees == {
        before.identity: before,
        after.identity: after,
    }
    assert source.read_text() == original
    assert await import_receipt(storage.database) == {
        "source": "sessions.json",
        "outcome": "partial",
        "trees": 2,
        "messages": 0,
        "skipped": 1,
        "cleanup_pending": 0,
    }
    with closing(sqlite3.connect(storage.database.path)) as connection:
        assert connection.execute("PRAGMA foreign_key_check").fetchall() == []
        assert (
            connection.execute("SELECT count(*) FROM messaging_references").fetchone()[
                0
            ]
            == 4
        )
        assert (
            connection.execute("SELECT count(*) FROM messaging_trees").fetchone()[0]
            == 2
        )


@pytest.mark.parametrize("field", ["platform", "chat_id", "message_id", "ts", "kind"])
@pytest.mark.parametrize("value", ["\ud800", "\0kind"])
async def test_import_message_storage_validation_and_successful_duplicate_ownership(
    storage, tmp_path, field, value
):
    bad = {"message_id": "same", "direction": "in", "kind": "prompt", "ts": "old"}
    key = "telegram:chat"
    if field == "platform":
        key = f"{value}:chat"
    elif field == "chat_id":
        key = f"telegram:{value}"
    else:
        bad[field] = value
    good = {"message_id": "same", "direction": "out", "kind": "notice", "ts": "new"}
    messages = {key: [bad]}
    messages.setdefault("telegram:chat", []).extend([good, {**good, "ts": "duplicate"}])
    source = tmp_path / "sessions.json"
    source.write_text(json.dumps({"managed_messages": messages}))

    rejected = value == "\ud800" or field == "kind"
    assert bool(await import_legacy(storage.database, source)) is rejected
    assert source.exists() is rejected
    rows = await storage.database.run(
        lambda connection: [
            tuple(row)
            for row in connection.execute(
                "SELECT platform,chat_id,message_id,ts,direction,kind FROM messaging_managed_messages ORDER BY sequence"
            )
        ],
        write=False,
    )
    if rejected:
        assert rows == [("telegram", "chat", "same", "new", "out", "notice")]
    else:
        # NUL is legal in fields without a length CHECK. Preserve accepted text.
        assert rows[0] == (
            *key.split(":", 1),
            bad["message_id"],
            bad["ts"],
            "in",
            bad["kind"],
        )
        assert len(rows) == (1 if field == "ts" else 2)
    receipt = await import_receipt(storage.database)
    assert receipt["messages"] == len(rows)
    assert receipt["skipped"] == int(rejected)


@pytest.mark.parametrize("last_invalid", [False, True])
async def test_import_last_tree_identity_wins_even_when_unrecoverable(
    storage, tmp_path, last_invalid
):
    first, last = tree(), tree()
    last.nodes["root"]["session_id"] = "\ud800" if last_invalid else "last-session"
    source = tmp_path / "sessions.json"
    source.write_text(json.dumps({"trees": [first.to_json(), last.to_json()]}))
    assert await import_legacy(storage.database, source)
    assert (await storage.load_conversation_snapshot()).trees == (
        {} if last_invalid else {last.identity: last}
    )
    assert (await import_receipt(storage.database))["skipped"] == 1 + int(last_invalid)
    await storage.commit_trees((tree(root="fresh"),))


async def test_partial_import_survives_reopen_and_clear_without_replay(
    storage, tmp_path
):
    source = tmp_path / "sessions.json"
    source.write_text(
        json.dumps(
            {
                "trees": [tree().to_json()],
                "managed_messages": {
                    "telegram:chat": [
                        {"message_id": "bad", "direction": "in", "kind": "\0"}
                    ]
                },
            }
        )
    )
    assert await import_legacy(storage.database, source)
    receipt = await import_receipt(storage.database)
    await storage.database.close()
    for restart in range(2):
        database = SQLiteDatabase(storage.database.path, tmp_path / "code.lock")
        await database.start()
        try:
            reopened = SQLiteMessagingStore(database)
            assert await import_legacy(database, source) is None
            assert await import_receipt(database) == receipt
            assert (await reopened.load_conversation_snapshot()).is_empty is bool(
                restart
            )
            await reopened.commit_trees((), clear_scope=tree().scope)
        finally:
            await database.close()
    assert source.exists()


@pytest.mark.parametrize("failure_stage", ["receipt", "commit"])
async def test_import_outer_failure_rolls_back_released_units(
    storage, tmp_path, failure_stage
):
    source = tmp_path / "sessions.json"
    source.write_text(
        json.dumps(
            {
                "trees": [tree().to_json()],
                "managed_messages": {
                    "telegram:chat": [
                        {"message_id": "one", "direction": "in", "kind": "prompt"}
                    ]
                },
            }
        )
    )
    transaction = storage.database._transaction
    inserted = []

    def faulting_transaction(pool, operation, *, write):
        def authorize(action, arg1, arg2, database_name, trigger):
            if action == sqlite3.SQLITE_INSERT:
                inserted.append(arg1)
                if failure_stage == "receipt" and arg1 == "messaging_legacy_import":
                    return sqlite3.SQLITE_DENY
            if (
                failure_stage == "commit"
                and action == sqlite3.SQLITE_TRANSACTION
                and arg1 == "COMMIT"
                and "messaging_managed_messages" in inserted
            ):
                return sqlite3.SQLITE_DENY
            return sqlite3.SQLITE_OK

        observed = []

        def faulting(connection):
            observed.append(connection)
            connection.set_authorizer(authorize)
            return operation(connection)

        result = transaction(pool, faulting, write=write)
        # Failed transactions discard their connection; only successful leases
        # need the injected connection state restored before another checkout.
        for connection in observed:
            connection.set_authorizer(None)
        return result

    await storage.database.run(
        lambda connection: connection.execute("SELECT 1").close()
    )
    with (
        patch.object(storage.database, "_transaction", faulting_transaction),
        pytest.raises(sqlite3.DatabaseError, match="not authorized"),
    ):
        await import_legacy(storage.database, source)
    assert "messaging_nodes" in inserted and "messaging_managed_messages" in inserted
    assert source.exists()
    assert (await storage.load_conversation_snapshot()).is_empty
    assert not await storage.get_tracked_message_ids_for_chat("telegram", "chat")
    assert (
        await storage.database.run(
            lambda connection: connection.execute(
                "SELECT count(*) FROM messaging_legacy_import"
            ).fetchone()[0],
            write=False,
        )
        == 0
    )
    assert await import_legacy(storage.database, source) is None
    assert (await import_receipt(storage.database))["trees"] == 1
    assert (await import_receipt(storage.database))["messages"] == 1


@pytest.mark.parametrize("platform", ["none", "telegram"])
async def test_startup_partial_import_preserves_links_scopes_and_code(
    storage, tmp_path, platform
):
    from free_claude_code.application.code_sessions.models import CodeSession
    from free_claude_code.config.settings import Settings
    from free_claude_code.runtime.application import ApplicationRuntime
    from free_claude_code.runtime.configuration import ConfigurationService
    from free_claude_code.runtime.provider_manager import ProviderRuntimeManager

    code = SQLiteCodeStore(storage.database)
    await code.start()
    session = await code.create(
        CodeSession(id="saved-code", cwd=str(tmp_path), model="provider/model")
    )
    valid = tree(root="root-\U0001f600\0suffix")
    parent = valid.root_id
    for node_id in ("child", "grandchild"):
        valid.nodes[node_id] = {
            "node_id": node_id,
            "status_message_id": f"status-{node_id}",
            "parent_id": parent,
            "parent_reference_id": valid.nodes[parent]["status_message_id"],
            "state": "in_progress",
            "session_id": "native-\U0001f600",
        }
        parent = node_id
    inactive = tree("discord", root=valid.root_id)
    conflict = tree(root="status-child")
    source = tmp_path / "sessions.json"
    source.write_text(
        json.dumps(
            {
                "trees": [valid.to_json(), conflict.to_json(), inactive.to_json()],
                "managed_messages": {
                    "telegram:chat": [
                        {
                            "message_id": str(index),
                            "direction": "in",
                            "kind": "\0" if index == 0 else "prompt",
                        }
                        for index in range(4)
                    ]
                },
            }
        )
    )
    manager = ProviderRuntimeManager(
        Settings().model_copy(
            update={
                "messaging_platform": platform,
                "max_message_log_entries_per_chat": 2,
            }
        )
    )
    runtime = ApplicationRuntime(
        manager,
        configuration=AsyncMock(spec=ConfigurationService),
        transcriber=None,
        database=storage.database,
    )
    try:
        with patch(
            "free_claude_code.runtime.messaging_service.messaging_state_dir_path",
            return_value=str(tmp_path),
        ):
            await runtime._messaging._initialize_messaging_storage()
        assert runtime._messaging._messaging_storage_error is None
        assert runtime._messaging._messaging_warning
        assert (await storage.load_conversation_snapshot()).trees == {
            valid.identity: valid,
            inactive.identity: inactive,
        }
        assert await storage.get_tracked_message_ids_for_chat("telegram", "chat") == [
            "2",
            "3",
        ]
        assert (await import_receipt(storage.database))["skipped"] == 2
        assert (await import_receipt(storage.database))["messages"] == 3
        assert await code.get_session(session.id) == session
        assert (
            await storage.database.run(
                lambda connection: connection.execute(
                    "PRAGMA foreign_key_check"
                ).fetchall(),
                write=False,
            )
            == []
        )
    finally:
        await manager.close()
        await code.close()


async def test_failed_admission_never_launches_harness_or_publishes_memory(storage):
    processor = AsyncMock()
    manager = TreeQueueManager(processor, store=storage)
    with (
        patch.object(
            storage, "commit_trees", side_effect=sqlite3.OperationalError("disk full")
        ),
        pytest.raises(sqlite3.OperationalError),
    ):
        await manager.admit(incoming("new"), "status-new")
    assert manager.get_tree_count() == 0
    assert manager.task_count() == 0
    processor.assert_not_awaited()
    assert (await storage.load_conversation_snapshot()).is_empty


async def test_failed_clear_restores_runtime_prompts_queue_and_claim(storage):
    started, release = asyncio.Event(), asyncio.Event()
    prompts = []

    async def process(claim):
        prompts.append(claim.prompt)
        started.set()
        await release.wait()
        await manager.complete_claim(claim, "resumable")

    manager = TreeQueueManager(process, store=storage)
    root = await manager.admit(incoming("root", text="first"), "status-root")
    assert root.claim is not None
    await started.wait()
    await manager.admit(
        incoming("child", text="second"),
        "status-child",
        parent_reference_id="status-root",
    )
    try:
        with (
            patch.object(
                storage,
                "commit_trees",
                side_effect=sqlite3.OperationalError("disk full"),
            ),
            pytest.raises(sqlite3.OperationalError),
        ):
            await manager.clear_scope(root.claim.identity.scope)
        assert manager.task_count() == 1
        assert (
            len(
                (await storage.load_conversation_snapshot())
                .trees[root.claim.identity]
                .nodes
            )
            == 2
        )
    finally:
        release.set()
        await asyncio.wait_for(manager.wait_idle(), 5)
    assert prompts == ["first", "second"]
    child = await manager.get_node(root.claim.identity.scope, "child")
    assert child is not None and child.session_id == "resumable"


async def test_status_subtree_delete_preserves_prompt_sibling_branch(storage):
    original = tree()
    for node, reference in (("status-reply", "status-root"), ("prompt-reply", "root")):
        original.nodes[node] = {
            "node_id": node,
            "status_message_id": f"status-{node}",
            "state": "completed",
            "parent_id": "root",
            "parent_reference_id": reference,
            "session_id": node,
        }
    await storage.commit_trees((original,))
    manager = TreeQueueManager.from_snapshot(
        await storage.load_conversation_snapshot(), AsyncMock(), store=storage
    )
    await manager.remove_message_subtree(original.scope, "status-root")
    persisted = (await storage.load_conversation_snapshot()).trees[original.identity]
    assert set(persisted.nodes) == {"root", "prompt-reply"}
    assert persisted.nodes["root"]["status_message_id"] is None
    assert persisted.nodes["root"]["session_id"] is None
    assert persisted.nodes["prompt-reply"]["parent_reference_id"] == "root"


async def test_failure_after_scope_delete_rolls_back_both_trees_and_message_log(
    storage,
):
    original = tree()
    await storage.commit_trees((original,))
    await storage.record_message_id("telegram", "chat", "tracked", "out", "notice")
    invalid = tree(root="invalid")
    invalid.nodes["invalid"]["state"] = "not-a-state"
    with pytest.raises(ValueError):
        await storage.commit_trees((invalid,), clear_scope=original.scope)
    assert (await storage.load_conversation_snapshot()).trees == {
        original.identity: original
    }
    assert await storage.get_tracked_message_ids_for_chat("telegram", "chat") == [
        "tracked"
    ]


async def test_code_close_does_not_release_shared_database(storage, tmp_path):
    code = SQLiteCodeStore(storage.database)
    await code.start()
    await code.close()
    other = SQLiteDatabase(tmp_path / "fcc.db", tmp_path / "code.lock")
    try:
        with pytest.raises(sqlite3.OperationalError, match="another FCC"):
            await other.start()
        await storage.commit_trees((tree(),))
        assert not (await storage.load_conversation_snapshot()).is_empty
    finally:
        await other.close()


async def test_cancellation_during_commit_preserves_memory_and_database_agreement(
    storage,
):
    entered, release = threading.Event(), threading.Event()
    execute = storage.database.execute

    def blocked(operation, *, write=True):
        entered.set()
        if not release.wait(5):
            raise TimeoutError("test commit barrier")
        return execute(operation, write=write)

    manager = TreeQueueManager(AsyncMock(), store=storage)
    with patch.object(storage.database, "execute", blocked):
        admission = asyncio.create_task(manager.admit(incoming("new"), "status-new"))
        try:
            assert await asyncio.to_thread(entered.wait, 3)
            admission.cancel()
        finally:
            release.set()
        decision = await admission
    assert decision.accepted
    await asyncio.wait_for(manager.wait_idle(), 5)
    assert (await manager.snapshot()).trees == (
        await storage.load_conversation_snapshot()
    ).trees


async def test_restore_does_not_consume_inactive_platform_status_repairs(storage):
    telegram, discord = tree(), tree("discord")
    telegram.nodes["root"]["state"] = "in_progress"
    discord.nodes["root"]["state"] = "pending"
    await storage.commit_trees((telegram, discord))
    workflow = MessagingWorkflow(
        AsyncMock(), AsyncMock(), storage, platform_name="telegram"
    )
    await workflow.restore()
    await workflow.close()
    loaded = await storage.load_conversation_snapshot()
    assert loaded.trees[telegram.identity].nodes["root"]["state"] == "error"
    assert loaded.trees[discord.identity].nodes["root"]["state"] == "pending"
    next_workflow = MessagingWorkflow(
        AsyncMock(), AsyncMock(), storage, platform_name="discord"
    )
    await next_workflow.restore()
    assert any(
        target.scope.platform == "discord"
        for target in next_workflow.tree_queue.restored_stale_targets
    )


@pytest.mark.parametrize("boundary", ["session", "terminal", "failure", "successor"])
async def test_worker_write_failure_interrupts_queue_and_new_reply_recovers(
    storage, boundary
):
    started, release = asyncio.Event(), asyncio.Event()
    processed, interrupted = [], []

    async def process(claim):
        processed.append(claim.node.node_id)
        if claim.node.node_id == "root":
            started.set()
            await release.wait()
            if boundary == "session":
                await manager.record_session(claim, "native")
            elif boundary == "failure":
                await manager.fail_claim(claim)
        await manager.complete_claim(claim, "native")

    manager = TreeQueueManager(
        process, store=storage, unexpected_failure_callback=interrupted.append
    )
    root = await manager.admit(incoming("root"), "status-root")
    assert root.claim is not None
    await started.wait()
    await manager.admit(incoming("child"), "status-child", parent_reference_id="root")
    condition = {
        "session": "NEW.node_id='root' AND NEW.session_id='native'",
        "terminal": "NEW.node_id='root' AND NEW.state='completed'",
        "failure": "NEW.node_id='root' AND NEW.state='error'",
        "successor": "NEW.node_id='child' AND NEW.state='in_progress'",
    }[boundary]
    await storage.database.run(
        lambda connection: connection.execute(
            f"CREATE TRIGGER reject_transition BEFORE UPDATE ON messaging_nodes WHEN {condition} "
            "BEGIN SELECT RAISE(ABORT, 'test storage failure'); END"
        )
    )
    release.set()
    await asyncio.wait_for(manager.wait_idle(), 5)
    assert processed == ["root"]
    assert manager.task_count() == 0
    assert interrupted
    assert "child" in {
        node.node_id for result in interrupted for node in result.affected
    }
    saved = await storage.load_conversation_snapshot()
    assert (await manager.snapshot()).trees == saved.trees
    await storage.database.run(
        lambda connection: connection.execute("DROP TRIGGER reject_transition")
    )
    await manager.admit(incoming("later"), "status-later", parent_reference_id="root")
    await asyncio.wait_for(manager.wait_idle(), 5)
    assert processed == ["root", "later"]
    nodes = (
        (await storage.load_conversation_snapshot()).trees[root.claim.identity].nodes
    )
    assert nodes["root"]["state"] == (
        "completed" if boundary == "successor" else "error"
    )
    assert nodes["child"]["state"] == "error"
    assert nodes["later"]["state"] == "completed"


async def test_shutdown_drains_workers_even_when_interruption_cannot_be_saved(
    storage, mock_platform
):
    started, stopped = asyncio.Event(), asyncio.Event()
    cli = AsyncMock()
    workflow = MessagingWorkflow(mock_platform, cli, storage, platform_name="telegram")

    async def process(claim):
        started.set()
        try:
            await asyncio.Event().wait()
        finally:
            await manager.fail_claim(claim)
            stopped.set()

    manager = TreeQueueManager(process, store=storage)
    workflow._tree_queue = manager
    await manager.admit(incoming("root"), "status-root")
    await started.wait()
    await manager.admit(incoming("child"), "status-child", parent_reference_id="root")
    execute = storage.database.execute
    writes = 0

    def broken(operation, *, write=True):
        nonlocal writes
        if write:
            writes += 1
            raise sqlite3.OperationalError("disk full")
        return execute(operation, write=write)

    try:
        with patch.object(storage.database, "execute", broken):
            await asyncio.wait_for(workflow.close(), 5)
        assert writes == 1
        assert stopped.is_set()
        assert manager.task_count() == 0
        cli.stop_all.assert_awaited()
        assert any(
            call.args[1] == "status-child"
            for call in mock_platform.queue_edit_message.call_args_list
        )
    finally:
        await manager.shutdown()
        await manager.wait_idle()


async def test_persistent_failure_has_no_retries_and_failed_recovery_keeps_history(
    storage,
):
    started, release = asyncio.Event(), asyncio.Event()
    processed = []
    # An outbound failure must not prevent task retirement.
    notify = Mock(side_effect=RuntimeError("platform unavailable"))

    async def process(claim):
        processed.append(claim.node.node_id)
        started.set()
        await release.wait()
        await manager.complete_claim(claim, "native")

    manager = TreeQueueManager(
        process, store=storage, unexpected_failure_callback=notify
    )
    root = await manager.admit(incoming("root"), "status-root")
    await started.wait()
    await manager.admit(incoming("child"), "status-child", parent_reference_id="root")
    original = await storage.load_conversation_snapshot()
    writes = 0
    execute = storage.database.execute

    def broken(operation, *, write=True):
        nonlocal writes
        if write:
            writes += 1
            raise sqlite3.OperationalError("disk full")
        return execute(operation, write=False)

    with patch.object(storage.database, "execute", broken):
        release.set()
        await asyncio.wait_for(manager.wait_idle(), 5)
        assert writes == 1
        assert processed == ["root"]
        assert manager.task_count() == 0
        with pytest.raises(MessagingStorageError):
            await manager.admit(
                incoming("new"), "status-new", parent_reference_id="root"
            )
        assert writes == 2
        assert (await manager.snapshot()) == original
        assert (await storage.load_conversation_snapshot()) == original
    notify.assert_called_once()
    await manager.admit(incoming("new"), "status-new", parent_reference_id="root")
    await asyncio.wait_for(manager.wait_idle(), 5)
    assert processed == ["root", "new"]
    nodes = (
        (await storage.load_conversation_snapshot()).trees[root.claim.identity].nodes
    )
    assert nodes["root"]["state"] == nodes["child"]["state"] == "error"
    assert nodes["new"]["state"] == "completed"


async def test_gated_tree_can_be_cleared_and_replaced_before_old_cleanup_finishes(
    storage, monkeypatch
):
    monkeypatch.setattr(
        "free_claude_code.messaging.trees.manager.CANCEL_TASK_DRAIN_TIMEOUT_S", 0.01
    )
    faulted, cleanup_release = asyncio.Event(), asyncio.Event()
    new_started, new_release = asyncio.Event(), asyncio.Event()
    claims = []
    notifications = []

    async def process(claim):
        claims.append(claim)
        if len(claims) == 1:
            try:
                with patch.object(
                    storage.database,
                    "execute",
                    side_effect=sqlite3.OperationalError("disk full"),
                ):
                    await manager.record_session(claim, "old-session")
            except MessagingStorageError:
                faulted.set()
                while not cleanup_release.is_set():
                    with suppress(asyncio.CancelledError):
                        await cleanup_release.wait()
                # This late update must not affect the same-ID replacement.
                await manager.complete_claim(claim, "old-session")
                raise
        new_started.set()
        await new_release.wait()
        await manager.complete_claim(claim, "new-session")

    manager = TreeQueueManager(
        process, store=storage, unexpected_failure_callback=notifications.append
    )
    old = await manager.admit(incoming("root"), "status-root")
    assert old.claim is not None
    await faulted.wait()
    try:
        with pytest.raises(MessagingStorageError, match="cleaning up"):
            await manager.admit(
                incoming("child"), "status-child", parent_reference_id="root"
            )
        await manager.clear_scope(old.claim.identity.scope)
        replacement = await manager.admit(incoming("root"), "status-root")
        assert replacement.claim is not None
        await new_started.wait()
        assert replacement.claim.claim_id != old.claim.claim_id
        assert manager.task_count() == 2
    finally:
        cleanup_release.set()
        new_release.set()
        await asyncio.wait_for(manager.wait_idle(), 5)
    nodes = (await storage.load_conversation_snapshot()).trees[old.claim.identity].nodes
    assert list(nodes) == ["root"]
    assert nodes["root"]["session_id"] == "new-session"
    assert not notifications