Skip to content

armgit / avibe

Public Imported from GitHub
0

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

42.5 KB
Raw Blame
from __future__ import annotations

import asyncio
import json
import sqlite3
from types import SimpleNamespace
from unittest.mock import AsyncMock, Mock, patch

import pytest

from modules.agents.base import AgentRequest
from modules.agents.opencode.session import (
    OpenCodeResumeUnavailableError,
    OpenCodeSessionManager,
    requires_message_order_repair,
)
from modules.im import MessageContext
from modules.sessions_facade import SessionsFacade


def _request() -> AgentRequest:
    return AgentRequest(
        context=MessageContext(user_id="U1", channel_id="C1", platform_specific={}),
        message="hello",
        user_message="hello",
        working_path="/repo",
        base_session_id="base-1",
        composite_session_id="base-1:/repo",
        session_key="slack::channel::C1",
    )


def _opencode_message(message_id: str, role: str, created: int) -> dict:
    return {
        "info": {
            "id": message_id,
            "role": role,
            "time": {"created": created},
        },
        "parts": [],
    }


def _legacy_opencode_message_id(created: int, counter: int = 1) -> str:
    clock = ((created << 12) + counter) % (1 << 48)
    return f"msg_{clock:012x}AAAA"


def test_opencode_message_order_repair_detects_completed_id_wrap() -> None:
    messages = [
        _opencode_message("msg_fff000000001AAAA", "user", 1),
        _opencode_message("msg_fff000000002AAAA", "assistant", 2),
        _opencode_message("msg_000100000001AAAA", "user", 3),
        _opencode_message("msg_000100000002AAAA", "assistant", 4),
    ]

    assert requires_message_order_repair(messages, now_ms=0x10000) is True


def test_opencode_message_order_repair_detects_wrap_before_first_new_message() -> None:
    period_ms = 1 << 36
    old_created = (2 * period_ms) - 0x10000
    now_ms = (2 * period_ms) + 0x10000
    messages = [
        _opencode_message(_legacy_opencode_message_id(old_created), "user", old_created),
        _opencode_message(
            _legacy_opencode_message_id(old_created + 1),
            "assistant",
            old_created + 1,
        ),
    ]

    assert requires_message_order_repair(messages, now_ms=now_ms) is True


def test_opencode_message_order_repair_detects_prior_cycle_lower_half() -> None:
    period_ms = 1 << 36
    old_created = period_ms + 0x2000
    now_ms = (2 * period_ms) + 0x1000
    messages = [
        _opencode_message(_legacy_opencode_message_id(old_created), "user", old_created),
    ]

    assert requires_message_order_repair(messages, now_ms=now_ms) is True


def test_opencode_message_order_repair_ignores_monotonic_history() -> None:
    messages = [
        _opencode_message("msg_000000001001AAAA", "user", 1),
        _opencode_message("msg_000000001002AAAA", "assistant", 2),
        _opencode_message("msg_000000002001AAAA", "user", 3),
        _opencode_message("msg_000000002002AAAA", "assistant", 4),
    ]

    assert requires_message_order_repair(messages, now_ms=0x10000) is False


def test_opencode_message_order_repair_forks_and_rebinds_full_history() -> None:
    sessions = SimpleNamespace(
        replace_agent_session_native=Mock(return_value="sesk8m4q2p7x"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(
        get_version=AsyncMock(return_value="1.18.5"),
        fork_session=AsyncMock(return_value={"id": "oc-reindexed"}),
    )
    request = _request()
    request.context.platform_specific = {
        "agent_session_id": "sesk8m4q2p7x",
        "agent_session_target": {
            "id": "sesk8m4q2p7x",
            "native_session_id": "oc-wrapped",
        },
    }
    messages = [
        _opencode_message("msg_fff000000001AAAA", "user", 1),
        _opencode_message("msg_000100000001AAAA", "user", 2),
    ]

    session_id = asyncio.run(manager.repair_message_order(request, server, "oc-wrapped", messages))

    assert session_id == "oc-reindexed"
    server.fork_session.assert_awaited_once_with(
        "oc-wrapped",
        directory="/repo",
        message_id=None,
    )
    sessions.replace_agent_session_native.assert_called_once_with(
        "sesk8m4q2p7x",
        expected_native_session_id="oc-wrapped",
        replacement_native_session_id="oc-reindexed",
    )
    assert request.context.platform_specific["agent_session_target"]["native_session_id"] == "oc-reindexed"


def test_opencode_message_order_repair_skips_fixed_runtime() -> None:
    sessions = SimpleNamespace(replace_agent_session_native=Mock())
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(
        get_version=AsyncMock(return_value="1.18.15"),
        fork_session=AsyncMock(),
    )
    request = _request()
    messages = [
        _opencode_message("msg_fff000000001AAAA", "user", 1),
        _opencode_message("msg_000100000001AAAA", "user", 2),
    ]

    session_id = asyncio.run(manager.repair_message_order(request, server, "oc-fixed", messages))

    assert session_id == "oc-fixed"
    server.fork_session.assert_not_awaited()
    sessions.replace_agent_session_native.assert_not_called()


def _seed_opencode_messages(tmp_path, native_session_id: str, roles: list[str]) -> None:
    db_path = tmp_path / "opencode" / "opencode.db"
    db_path.parent.mkdir(parents=True, exist_ok=True)
    with sqlite3.connect(db_path) as conn:
        conn.execute("CREATE TABLE message (id TEXT PRIMARY KEY, data TEXT)")
        conn.execute(
            "CREATE TABLE part (id TEXT PRIMARY KEY, session_id TEXT, message_id TEXT, time_created INTEGER, data TEXT)"
        )
        for index, role in enumerate(roles, start=1):
            message_id = f"oc-msg-{index}"
            conn.execute(
                "INSERT INTO message (id, data) VALUES (?, ?)",
                (message_id, json.dumps({"role": role})),
            )
            conn.execute(
                "INSERT INTO part (id, session_id, message_id, time_created, data) VALUES (?, ?, ?, ?, ?)",
                (f"part-{index}", native_session_id, message_id, index, json.dumps({"type": "text"})),
            )


def _seed_opencode_completed_messages(tmp_path, native_session_id: str, roles: list[str]) -> None:
    db_path = tmp_path / "opencode" / "opencode.db"
    db_path.parent.mkdir(parents=True, exist_ok=True)
    with sqlite3.connect(db_path) as conn:
        conn.execute("CREATE TABLE message (id TEXT PRIMARY KEY, data TEXT)")
        conn.execute(
            "CREATE TABLE part (id TEXT PRIMARY KEY, session_id TEXT, message_id TEXT, time_created INTEGER, data TEXT)"
        )
        for index, role in enumerate(roles, start=1):
            message_id = f"oc-msg-{index}"
            data = {"role": role}
            if role == "assistant":
                data["time"] = {"completed": index}
            conn.execute(
                "INSERT INTO message (id, data) VALUES (?, ?)",
                (message_id, json.dumps(data)),
            )
            conn.execute(
                "INSERT INTO part (id, session_id, message_id, time_created, data) VALUES (?, ?, ?, ?, ?)",
                (f"part-{index}", native_session_id, message_id, index, json.dumps({"type": "text"})),
            )


def _seed_opencode_tool_call_messages(tmp_path, native_session_id: str) -> None:
    db_path = tmp_path / "opencode" / "opencode.db"
    db_path.parent.mkdir(parents=True, exist_ok=True)
    with sqlite3.connect(db_path) as conn:
        conn.execute("CREATE TABLE message (id TEXT PRIMARY KEY, data TEXT)")
        conn.execute(
            "CREATE TABLE part (id TEXT PRIMARY KEY, session_id TEXT, message_id TEXT, time_created INTEGER, data TEXT)"
        )
        messages = [
            {"role": "user"},
            {
                "role": "assistant",
                "time": {"completed": 2},
                "finish": "tool-calls",
            },
        ]
        for index, data in enumerate(messages, start=1):
            message_id = f"oc-msg-{index}"
            conn.execute(
                "INSERT INTO message (id, data) VALUES (?, ?)",
                (message_id, json.dumps(data)),
            )
            conn.execute(
                "INSERT INTO part (id, session_id, message_id, time_created, data) VALUES (?, ?, ?, ?, ?)",
                (f"part-{index}", native_session_id, message_id, index, json.dumps({"type": "text"})),
            )


def test_opencode_reused_session_attaches_agent_session_id() -> None:
    sessions = SimpleNamespace(
        get_agent_session_id=Mock(return_value="oc-session-1"),
        ensure_agent_session_id=Mock(return_value="sesk8m4q2p7x"),
        bind_agent_session=Mock(return_value="sesk8m4q2p7x"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(get_session=AsyncMock(return_value={"id": "oc-session-1"}))
    request = _request()

    session_id = asyncio.run(manager.get_or_create_session_id(request, server))

    assert session_id == "oc-session-1"
    assert request.context.platform_specific["agent_session_id"] == "sesk8m4q2p7x"
    # Anchor is the bare base now (cwd is per-request, not part of the key) —
    # one OpenCode session per (scope, anchor), reused across working dirs.
    sessions.ensure_agent_session_id.assert_called_once_with(
        "slack::channel::C1",
        "opencode",
        "base-1",
    )
    sessions.bind_agent_session.assert_called_once_with(
        "slack::channel::C1",
        "opencode",
        "base-1",
        "oc-session-1",
        workdir="/repo",
    )


def test_opencode_topic_run_target_binds_by_resolved_row_id() -> None:
    sessions = SimpleNamespace(
        bind_agent_session_by_id=Mock(return_value="ses-topic"),
        bind_agent_session=Mock(return_value="ses-parent"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    request = _request()
    request.context.platform_specific = {
        "agent_run_target": {
            "agent_session_id": "ses-topic",
            "workdir": "/repo",
        }
    }

    result = manager.bind_agent_session_id(request, "base-1", "oc-topic")

    assert result == "ses-topic"
    sessions.bind_agent_session_by_id.assert_called_once_with(
        "ses-topic",
        "oc-topic",
        workdir="/repo",
        vibe_agent_id=None,
        vibe_agent_name=None,
        vibe_agent_backend=None,
    )
    sessions.bind_agent_session.assert_not_called()


def test_opencode_create_session_does_not_pass_vibe_title() -> None:
    sessions = SimpleNamespace(
        get_agent_session_id=Mock(return_value=None),
        ensure_agent_session_id=Mock(return_value="sesk8m4q2p7x"),
        bind_agent_session=Mock(return_value="sesk8m4q2p7x"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(create_session=AsyncMock(return_value={"id": "oc-session-1"}))
    request = _request()

    session_id = asyncio.run(manager.get_or_create_session_id(request, server))

    assert session_id == "oc-session-1"
    server.create_session.assert_awaited_once_with(directory="/repo")


def test_opencode_forks_pending_native_source() -> None:
    sessions = SimpleNamespace(
        get_agent_session_id=Mock(return_value=None),
        ensure_agent_session_id=Mock(return_value="ses-fork"),
        bind_agent_session=Mock(return_value="ses-fork"),
        bind_agent_session_by_id=Mock(return_value="ses-fork"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(
        fork_session=AsyncMock(return_value={"id": "oc-fork"}),
        create_session=AsyncMock(),
        list_messages=AsyncMock(),
    )
    request = _request()
    request.context.platform_specific = {
        "agent_session_id": "ses-fork",
        "agent_session_target": {
            "id": "ses-fork",
            "agent_backend": "opencode",
            "native_session_id": "",
            "native_session_fork": {
                "source_session_id": "ses-source",
                "source_native_session_id": "oc-source",
                "source_backend": "opencode",
            },
        },
    }

    session_id = asyncio.run(manager.get_or_create_session_id(request, server))

    assert session_id == "oc-fork"
    server.fork_session.assert_awaited_once_with("oc-source", directory="/repo", message_id=None)
    server.create_session.assert_not_awaited()
    sessions.bind_agent_session_by_id.assert_called_once_with(
        "ses-fork",
        "oc-fork",
        workdir="/repo",
        vibe_agent_id=None,
        vibe_agent_name=None,
        vibe_agent_backend=None,
    )


def test_opencode_idle_fork_ignores_stale_native_message_point() -> None:
    sessions = SimpleNamespace(
        get_agent_session_id=Mock(return_value=None),
        ensure_agent_session_id=Mock(return_value="ses-fork"),
        bind_agent_session=Mock(return_value="ses-fork"),
        bind_agent_session_by_id=Mock(return_value="ses-fork"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(
        fork_session=AsyncMock(return_value={"id": "oc-fork"}),
        create_session=AsyncMock(),
        list_messages=AsyncMock(),
    )
    request = _request()
    request.context.platform_specific = {
        "agent_session_id": "ses-fork",
        "agent_session_target": {
            "id": "ses-fork",
            "agent_backend": "opencode",
            "native_session_id": "",
            "native_session_fork": {
                "source_session_id": "ses-source",
                "source_native_session_id": "oc-source",
                "source_backend": "opencode",
                "trim_latest_running_turn": False,
                "opencode_fork_message_id": "oc-msg-prev",
            },
        },
    }

    session_id = asyncio.run(manager.get_or_create_session_id(request, server))

    assert session_id == "oc-fork"
    server.fork_session.assert_awaited_once_with("oc-source", directory="/repo", message_id=None)
    server.list_messages.assert_not_awaited()
    server.create_session.assert_not_awaited()


def test_opencode_startup_window_fork_does_not_infer_message_point() -> None:
    sessions = SimpleNamespace(
        get_agent_session_id=Mock(return_value=None),
        ensure_agent_session_id=Mock(return_value="ses-fork"),
        bind_agent_session=Mock(return_value="ses-fork"),
        bind_agent_session_by_id=Mock(return_value="ses-fork"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(
        fork_session=AsyncMock(return_value={"id": "oc-fork"}),
        create_session=AsyncMock(),
        list_messages=AsyncMock(),
    )
    request = _request()
    request.context.platform_specific = {
        "agent_session_id": "ses-fork",
        "agent_session_target": {
            "id": "ses-fork",
            "agent_backend": "opencode",
            "native_session_id": "",
            "native_session_fork": {
                "source_session_id": "ses-source",
                "source_native_session_id": "oc-source",
                "source_backend": "opencode",
                "trim_latest_running_turn": True,
                "native_turn_started": False,
            },
        },
    }

    session_id = asyncio.run(manager.get_or_create_session_id(request, server))

    assert session_id == "oc-fork"
    server.fork_session.assert_awaited_once_with("oc-source", directory="/repo", message_id=None)
    server.list_messages.assert_not_awaited()
    server.create_session.assert_not_awaited()


def test_opencode_running_fork_uses_persisted_native_message_point() -> None:
    sessions = SimpleNamespace(
        get_agent_session_id=Mock(return_value=None),
        ensure_agent_session_id=Mock(return_value="ses-fork"),
        bind_agent_session=Mock(return_value="ses-fork"),
        bind_agent_session_by_id=Mock(return_value="ses-fork"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(
        fork_session=AsyncMock(return_value={"id": "oc-fork"}),
        create_session=AsyncMock(),
        list_messages=AsyncMock(),
    )
    request = _request()
    request.context.platform_specific = {
        "agent_session_id": "ses-fork",
        "agent_session_target": {
            "id": "ses-fork",
            "agent_backend": "opencode",
            "native_session_id": "",
            "native_session_fork": {
                "source_session_id": "ses-source",
                "source_native_session_id": "oc-source",
                "source_backend": "opencode",
                "trim_latest_running_turn": True,
                "native_turn_started": True,
                "opencode_fork_message_id": "oc-msg-3",
            },
        },
    }

    session_id = asyncio.run(manager.get_or_create_session_id(request, server))

    assert session_id == "oc-fork"
    server.list_messages.assert_not_awaited()
    server.fork_session.assert_awaited_once_with("oc-source", directory="/repo", message_id="oc-msg-3")
    server.create_session.assert_not_awaited()


def test_opencode_running_first_turn_fork_uses_user_boundary() -> None:
    sessions = SimpleNamespace(
        get_agent_session_id=Mock(return_value=None),
        ensure_agent_session_id=Mock(return_value="ses-fork"),
        bind_agent_session=Mock(return_value="ses-fork"),
        bind_agent_session_by_id=Mock(return_value="ses-fork"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(
        fork_session=AsyncMock(return_value={"id": "oc-fork"}),
        create_session=AsyncMock(),
        list_messages=AsyncMock(),
    )
    request = _request()
    request.context.platform_specific = {
        "agent_session_id": "ses-fork",
        "agent_session_target": {
            "id": "ses-fork",
            "agent_backend": "opencode",
            "native_session_id": "",
            "native_session_fork": {
                "source_session_id": "ses-source",
                "source_native_session_id": "oc-source",
                "source_backend": "opencode",
                "trim_latest_running_turn": True,
                "native_turn_started": True,
                "opencode_fork_message_id": "oc-msg-1",
            },
        },
    }

    session_id = asyncio.run(manager.get_or_create_session_id(request, server))

    assert session_id == "oc-fork"
    server.list_messages.assert_not_awaited()
    server.fork_session.assert_awaited_once_with("oc-source", directory="/repo", message_id="oc-msg-1")
    server.create_session.assert_not_awaited()


def test_opencode_running_fork_without_persisted_point_rechecks_native_boundary(
    tmp_path, monkeypatch: pytest.MonkeyPatch
) -> None:
    monkeypatch.setenv("XDG_DATA_HOME", str(tmp_path))
    _seed_opencode_messages(tmp_path, "oc-source", ["user", "assistant", "user"])
    sessions = SimpleNamespace(
        get_agent_session_id=Mock(return_value=None),
        ensure_agent_session_id=Mock(return_value="ses-fork"),
        bind_agent_session=Mock(return_value="ses-fork"),
        bind_agent_session_by_id=Mock(return_value="ses-fork"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(
        fork_session=AsyncMock(return_value={"id": "oc-fork"}),
        create_session=AsyncMock(),
        list_messages=AsyncMock(),
    )
    request = _request()
    request.context.platform_specific = {
        "agent_session_id": "ses-fork",
        "agent_session_target": {
            "id": "ses-fork",
            "agent_backend": "opencode",
            "native_session_id": "",
            "native_session_fork": {
                "source_session_id": "ses-source",
                "source_native_session_id": "oc-source",
                "source_backend": "opencode",
                "trim_latest_running_turn": True,
                "native_turn_started": False,
            },
        },
    }

    session_id = asyncio.run(manager.get_or_create_session_id(request, server))

    assert session_id == "oc-fork"
    server.list_messages.assert_not_awaited()
    server.fork_session.assert_awaited_once_with("oc-source", directory="/repo", message_id="oc-msg-3")
    server.create_session.assert_not_awaited()


def test_opencode_tool_call_turn_without_persisted_point_rechecks_native_boundary(
    tmp_path, monkeypatch: pytest.MonkeyPatch
) -> None:
    monkeypatch.setenv("XDG_DATA_HOME", str(tmp_path))
    _seed_opencode_tool_call_messages(tmp_path, "oc-source")
    sessions = SimpleNamespace(
        get_agent_session_id=Mock(return_value=None),
        ensure_agent_session_id=Mock(return_value="ses-fork"),
        bind_agent_session=Mock(return_value="ses-fork"),
        bind_agent_session_by_id=Mock(return_value="ses-fork"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(
        fork_session=AsyncMock(return_value={"id": "oc-fork"}),
        create_session=AsyncMock(),
        list_messages=AsyncMock(),
    )
    request = _request()
    request.context.platform_specific = {
        "agent_session_id": "ses-fork",
        "agent_session_target": {
            "id": "ses-fork",
            "agent_backend": "opencode",
            "native_session_id": "",
            "native_session_fork": {
                "source_session_id": "ses-source",
                "source_native_session_id": "oc-source",
                "source_backend": "opencode",
                "trim_latest_running_turn": True,
                "native_turn_started": False,
            },
        },
    }

    session_id = asyncio.run(manager.get_or_create_session_id(request, server))

    assert session_id == "oc-fork"
    server.list_messages.assert_not_awaited()
    server.fork_session.assert_awaited_once_with("oc-source", directory="/repo", message_id="oc-msg-1")
    server.create_session.assert_not_awaited()


def test_opencode_stale_saved_boundary_rechecks_current_native_boundary(
    tmp_path, monkeypatch: pytest.MonkeyPatch
) -> None:
    monkeypatch.setenv("XDG_DATA_HOME", str(tmp_path))
    _seed_opencode_messages(tmp_path, "oc-source", ["user", "assistant", "user"])
    sessions = SimpleNamespace(
        get_agent_session_id=Mock(return_value=None),
        ensure_agent_session_id=Mock(return_value="ses-fork"),
        bind_agent_session=Mock(return_value="ses-fork"),
        bind_agent_session_by_id=Mock(return_value="ses-fork"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(
        fork_session=AsyncMock(return_value={"id": "oc-fork"}),
        create_session=AsyncMock(),
        list_messages=AsyncMock(),
    )
    request = _request()
    request.context.platform_specific = {
        "agent_session_id": "ses-fork",
        "agent_session_target": {
            "id": "ses-fork",
            "agent_backend": "opencode",
            "native_session_id": "",
            "native_session_fork": {
                "source_session_id": "ses-source",
                "source_native_session_id": "oc-source",
                "source_backend": "opencode",
                "source_message_id": "msg-user",
                "trim_latest_running_turn": True,
                "native_turn_started": True,
                "opencode_fork_message_id": "oc-msg-1",
            },
        },
    }

    with patch(
        "modules.agents.opencode.session.fork_source_state",
        return_value=SimpleNamespace(
            anchor_is_terminal_agent_output=False,
            has_messages_after_anchor=True,
            has_terminal_agent_output_after_anchor=False,
        ),
    ):
        session_id = asyncio.run(manager.get_or_create_session_id(request, server))

    assert session_id == "oc-fork"
    server.list_messages.assert_not_awaited()
    server.fork_session.assert_awaited_once_with("oc-source", directory="/repo", message_id="oc-msg-3")
    server.create_session.assert_not_awaited()


def test_opencode_saved_boundary_is_ignored_when_source_completed_before_anchor() -> None:
    sessions = SimpleNamespace(
        get_agent_session_id=Mock(return_value=None),
        ensure_agent_session_id=Mock(return_value="ses-fork"),
        bind_agent_session=Mock(return_value="ses-fork"),
        bind_agent_session_by_id=Mock(return_value="ses-fork"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(
        fork_session=AsyncMock(return_value={"id": "oc-fork"}),
        create_session=AsyncMock(),
        list_messages=AsyncMock(),
    )
    request = _request()
    request.context.platform_specific = {
        "agent_session_id": "ses-fork",
        "agent_session_target": {
            "id": "ses-fork",
            "agent_backend": "opencode",
            "native_session_id": "",
            "native_session_fork": {
                "source_session_id": "ses-source",
                "source_native_session_id": "oc-source",
                "source_backend": "opencode",
                "source_message_id": "msg-result",
                "trim_latest_running_turn": True,
                "native_turn_started": True,
                "opencode_fork_message_id": "oc-msg-user",
            },
        },
    }

    with patch(
        "modules.agents.opencode.session.fork_source_state",
        return_value=SimpleNamespace(
            anchor_is_terminal_agent_output=True,
            has_terminal_agent_output_after_anchor=False,
        ),
    ):
        session_id = asyncio.run(manager.get_or_create_session_id(request, server))

    assert session_id == "oc-fork"
    server.list_messages.assert_not_awaited()
    server.fork_session.assert_awaited_once_with("oc-source", directory="/repo", message_id=None)
    server.create_session.assert_not_awaited()


def test_opencode_active_run_boundary_survives_terminal_avibe_anchor() -> None:
    sessions = SimpleNamespace(
        get_agent_session_id=Mock(return_value=None),
        ensure_agent_session_id=Mock(return_value="ses-fork"),
        bind_agent_session=Mock(return_value="ses-fork"),
        bind_agent_session_by_id=Mock(return_value="ses-fork"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(
        fork_session=AsyncMock(return_value={"id": "oc-fork"}),
        create_session=AsyncMock(),
        list_messages=AsyncMock(),
    )
    request = _request()
    request.context.platform_specific = {
        "agent_session_id": "ses-fork",
        "agent_session_target": {
            "id": "ses-fork",
            "agent_backend": "opencode",
            "native_session_id": "",
            "native_session_fork": {
                "source_session_id": "ses-source",
                "source_native_session_id": "oc-source",
                "source_backend": "opencode",
                "source_message_id": "msg-result",
                "trim_latest_running_turn": True,
                "native_turn_started": True,
                "opencode_fork_message_id": "oc-msg-user",
                "opencode_boundary_from_active_run": True,
            },
        },
    }

    with patch(
        "modules.agents.opencode.session.fork_source_state",
        return_value=SimpleNamespace(
            anchor_is_terminal_agent_output=True,
            has_terminal_agent_output_after_anchor=False,
        ),
    ):
        session_id = asyncio.run(manager.get_or_create_session_id(request, server))

    assert session_id == "oc-fork"
    server.list_messages.assert_not_awaited()
    server.fork_session.assert_awaited_once_with("oc-source", directory="/repo", message_id="oc-msg-user")
    server.create_session.assert_not_awaited()


def test_opencode_saved_boundary_is_ignored_when_source_completed_after_anchor() -> None:
    sessions = SimpleNamespace(
        get_agent_session_id=Mock(return_value=None),
        ensure_agent_session_id=Mock(return_value="ses-fork"),
        bind_agent_session=Mock(return_value="ses-fork"),
        bind_agent_session_by_id=Mock(return_value="ses-fork"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(
        fork_session=AsyncMock(return_value={"id": "oc-fork"}),
        create_session=AsyncMock(),
        list_messages=AsyncMock(),
    )
    request = _request()
    request.context.platform_specific = {
        "agent_session_id": "ses-fork",
        "agent_session_target": {
            "id": "ses-fork",
            "agent_backend": "opencode",
            "native_session_id": "",
            "native_session_fork": {
                "source_session_id": "ses-source",
                "source_native_session_id": "oc-source",
                "source_backend": "opencode",
                "source_message_id": "msg-user",
                "trim_latest_running_turn": True,
                "native_turn_started": True,
                "opencode_fork_message_id": "oc-msg-user",
            },
        },
    }

    with patch(
        "modules.agents.opencode.session.fork_source_state",
        return_value=SimpleNamespace(
            anchor_is_terminal_agent_output=False,
            anchor_author="assistant",
            anchor_type="assistant",
            has_terminal_agent_output_after_anchor=True,
        ),
    ):
        session_id = asyncio.run(manager.get_or_create_session_id(request, server))

    assert session_id == "oc-fork"
    server.list_messages.assert_not_awaited()
    server.fork_session.assert_awaited_once_with("oc-source", directory="/repo", message_id=None)
    server.create_session.assert_not_awaited()


@pytest.mark.parametrize(
    ("anchor_author", "anchor_type"),
    [("user", "user"), ("harness", "harness")],
)
def test_opencode_saved_input_boundary_survives_source_completion_before_fork_starts(
    anchor_author: str,
    anchor_type: str,
) -> None:
    sessions = SimpleNamespace(
        get_agent_session_id=Mock(return_value=None),
        ensure_agent_session_id=Mock(return_value="ses-fork"),
        bind_agent_session=Mock(return_value="ses-fork"),
        bind_agent_session_by_id=Mock(return_value="ses-fork"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(
        fork_session=AsyncMock(return_value={"id": "oc-fork"}),
        create_session=AsyncMock(),
        list_messages=AsyncMock(),
    )
    request = _request()
    request.context.platform_specific = {
        "agent_session_id": "ses-fork",
        "agent_session_target": {
            "id": "ses-fork",
            "agent_backend": "opencode",
            "native_session_id": "",
            "native_session_fork": {
                "source_session_id": "ses-source",
                "source_native_session_id": "oc-source",
                "source_backend": "opencode",
                "source_message_id": "msg-user",
                "trim_latest_running_turn": True,
                "native_turn_started": True,
                "opencode_fork_message_id": "oc-msg-user",
            },
        },
    }

    with patch(
        "modules.agents.opencode.session.fork_source_state",
        return_value=SimpleNamespace(
            anchor_is_terminal_agent_output=False,
            anchor_author=anchor_author,
            anchor_type=anchor_type,
            has_messages_after_anchor=True,
            has_terminal_agent_output_after_anchor=True,
        ),
    ):
        session_id = asyncio.run(manager.get_or_create_session_id(request, server))

    assert session_id == "oc-fork"
    server.list_messages.assert_not_awaited()
    server.fork_session.assert_awaited_once_with("oc-source", directory="/repo", message_id="oc-msg-user")
    server.create_session.assert_not_awaited()


def test_opencode_saved_boundary_is_used_when_anchor_is_not_completed() -> None:
    sessions = SimpleNamespace(
        get_agent_session_id=Mock(return_value=None),
        ensure_agent_session_id=Mock(return_value="ses-fork"),
        bind_agent_session=Mock(return_value="ses-fork"),
        bind_agent_session_by_id=Mock(return_value="ses-fork"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(
        fork_session=AsyncMock(return_value={"id": "oc-fork"}),
        create_session=AsyncMock(),
        list_messages=AsyncMock(),
    )
    request = _request()
    request.context.platform_specific = {
        "agent_session_id": "ses-fork",
        "agent_session_target": {
            "id": "ses-fork",
            "agent_backend": "opencode",
            "native_session_id": "",
            "native_session_fork": {
                "source_session_id": "ses-source",
                "source_native_session_id": "oc-source",
                "source_backend": "opencode",
                "source_message_id": "msg-user",
                "trim_latest_running_turn": True,
                "native_turn_started": True,
                "opencode_fork_message_id": "oc-msg-user",
            },
        },
    }

    with patch(
        "modules.agents.opencode.session.fork_source_state",
        return_value=SimpleNamespace(
            anchor_is_terminal_agent_output=False,
            has_terminal_agent_output_after_anchor=False,
        ),
    ):
        session_id = asyncio.run(manager.get_or_create_session_id(request, server))

    assert session_id == "oc-fork"
    server.list_messages.assert_not_awaited()
    server.fork_session.assert_awaited_once_with("oc-source", directory="/repo", message_id="oc-msg-user")
    server.create_session.assert_not_awaited()


def test_opencode_completed_source_turn_without_saved_boundary_preserves_source_history(
    tmp_path, monkeypatch: pytest.MonkeyPatch
) -> None:
    monkeypatch.setenv("XDG_DATA_HOME", str(tmp_path))
    _seed_opencode_completed_messages(tmp_path, "oc-source", ["user", "assistant"])
    sessions = SimpleNamespace(
        get_agent_session_id=Mock(return_value=None),
        ensure_agent_session_id=Mock(return_value="ses-fork"),
        bind_agent_session=Mock(return_value="ses-fork"),
        bind_agent_session_by_id=Mock(return_value="ses-fork"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(
        fork_session=AsyncMock(return_value={"id": "oc-fork"}),
        create_session=AsyncMock(),
        list_messages=AsyncMock(),
    )
    request = _request()
    request.context.platform_specific = {
        "agent_session_id": "ses-fork",
        "agent_session_target": {
            "id": "ses-fork",
            "agent_backend": "opencode",
            "native_session_id": "",
            "native_session_fork": {
                "source_session_id": "ses-source",
                "source_native_session_id": "oc-source",
                "source_backend": "opencode",
                "source_message_id": "msg-user",
                "trim_latest_running_turn": True,
                "native_turn_started": False,
            },
        },
    }

    session_id = asyncio.run(manager.get_or_create_session_id(request, server))

    assert session_id == "oc-fork"
    server.list_messages.assert_not_awaited()
    server.fork_session.assert_awaited_once_with("oc-source", directory="/repo", message_id=None)
    server.create_session.assert_not_awaited()


def test_opencode_reserved_agent_session_id_is_not_replaced() -> None:
    sessions = SimpleNamespace(
        get_agent_session_id=Mock(return_value="oc-session-1"),
        ensure_agent_session_id=Mock(return_value="ses-different"),
        bind_agent_session=Mock(return_value="ses-different"),
        bind_agent_session_by_id=Mock(return_value="ses-reserved"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(get_session=AsyncMock(return_value={"id": "oc-session-1"}))
    request = _request()
    request.context.platform_specific = {
        "agent_session_id": "ses-reserved",
        "agent_session_target": {"id": "ses-reserved"},
    }

    session_id = asyncio.run(manager.get_or_create_session_id(request, server))

    assert session_id == "oc-session-1"
    assert request.context.platform_specific["agent_session_id"] == "ses-reserved"
    sessions.ensure_agent_session_id.assert_not_called()
    sessions.bind_agent_session.assert_not_called()
    sessions.bind_agent_session_by_id.assert_called_once_with(
        "ses-reserved",
        "oc-session-1",
        workdir="/repo",
        vibe_agent_id=None,
        vibe_agent_name=None,
        vibe_agent_backend=None,
    )


def test_opencode_resumes_reserved_native_session_id() -> None:
    """When the reserved workbench row carries a native session id, resume from
    THAT (by-PK), NOT the (session_key, anchor) projection. This is the restart-
    resume fix: the by-PK bind WRITE and the resume READ must agree, else avibe
    forks a fresh OpenCode session after a controller restart and loses context."""
    sessions = SimpleNamespace(
        # If this projection lookup were used, resume would pick the WRONG (or no)
        # session — the test asserts it is never consulted.
        get_agent_session_id=Mock(return_value="oc-from-projection"),
        ensure_agent_session_id=Mock(return_value="ses-different"),
        bind_agent_session=Mock(return_value="ses-different"),
        bind_agent_session_by_id=Mock(return_value="ses-reserved"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(get_session=AsyncMock(return_value={"id": "oc-native-reserved"}))
    request = _request()
    request.context.platform_specific = {
        "agent_session_id": "ses-reserved",
        "agent_session_target": {"id": "ses-reserved", "native_session_id": "oc-native-reserved"},
    }

    session_id = asyncio.run(manager.get_or_create_session_id(request, server))

    assert session_id == "oc-native-reserved"
    # The reserved native short-circuits the projection lookup entirely.
    sessions.get_agent_session_id.assert_not_called()
    sessions.ensure_agent_session_id.assert_not_called()
    # Validated against the server, then re-bound to the reserved row by PK.
    server.get_session.assert_awaited_once_with("oc-native-reserved", "/repo", raise_on_error=True)
    sessions.bind_agent_session_by_id.assert_called_once_with(
        "ses-reserved",
        "oc-native-reserved",
        workdir="/repo",
        vibe_agent_id=None,
        vibe_agent_name=None,
        vibe_agent_backend=None,
    )


def test_opencode_subagent_uses_reserved_native_session_id() -> None:
    sessions = SimpleNamespace(
        get_agent_session_id=Mock(return_value="oc-subagent"),
        ensure_agent_session_id=Mock(return_value="ses-subagent"),
        bind_agent_session=Mock(return_value="ses-subagent"),
        bind_agent_session_by_id=Mock(return_value="ses-reserved"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(get_session=AsyncMock(return_value={"id": "oc-subagent"}))
    request = _request()
    request.subagent_name = "reviewer"
    request.context.platform_specific = {
        "agent_session_id": "ses-reserved",
        "agent_session_target": {
            "id": "ses-reserved",
            "native_session_id": "oc-main",
            "agent_backend": "opencode",
        },
    }

    session_id = asyncio.run(manager.get_or_create_session_id(request, server))

    assert session_id == "oc-main"
    sessions.get_agent_session_id.assert_not_called()
    server.get_session.assert_awaited_once_with("oc-main", "/repo", raise_on_error=True)
    sessions.bind_agent_session.assert_not_called()
    sessions.bind_agent_session_by_id.assert_called_once_with(
        "ses-reserved",
        "oc-main",
        workdir="/repo",
        vibe_agent_id=None,
        vibe_agent_name=None,
        vibe_agent_backend=None,
    )
    assert request.context.platform_specific["agent_session_id"] == "ses-reserved"


def test_opencode_fails_loud_when_existing_session_invalid() -> None:
    """An existing mapped session that no longer validates on the server must
    RAISE (context loss), not silently create a fresh session and hide it."""
    sessions = SimpleNamespace(
        get_agent_session_id=Mock(return_value="oc-existing"),
        ensure_agent_session_id=Mock(return_value="ses-1"),
        bind_agent_session=Mock(return_value="ses-1"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    create = AsyncMock(return_value={"id": "oc-new"})
    server = SimpleNamespace(get_session=AsyncMock(return_value=None), create_session=create)
    request = _request()

    with pytest.raises(OpenCodeResumeUnavailableError):
        asyncio.run(manager.get_or_create_session_id(request, server))
    create.assert_not_awaited()  # must NOT silently recreate


def test_opencode_transport_error_during_validation_is_not_mislabeled_expiry() -> None:
    """A transport/connection error validating an existing session must propagate
    as-is (transient), NOT be converted into a session-expiry error."""
    sessions = SimpleNamespace(
        get_agent_session_id=Mock(return_value="oc-existing"),
        ensure_agent_session_id=Mock(return_value="ses-1"),
        bind_agent_session=Mock(return_value="ses-1"),
    )
    manager = OpenCodeSessionManager(SimpleNamespace(sessions=sessions), "opencode")
    server = SimpleNamespace(
        get_session=AsyncMock(side_effect=ConnectionError("server down")),
        create_session=AsyncMock(),
    )
    request = _request()

    with pytest.raises(ConnectionError):
        asyncio.run(manager.get_or_create_session_id(request, server))


def test_session_facade_ensure_fallback_does_not_clear_existing_native_session() -> None:
    class _LegacyStore:
        def __init__(self):
            self.maps = {"slack::channel::C1": {"codex": {"base-1": "thread-old"}}}

        def get_agent_map(self, user_id, agent_name):
            return self.maps.setdefault(user_id, {}).setdefault(agent_name, {})

    facade = SessionsFacade(_LegacyStore())

    assert facade.ensure_agent_session_id("slack::channel::C1", "codex", "base-1") is None
    assert facade.get_agent_session_id("slack::channel::C1", "base-1", "codex") == "thread-old"


def test_sessions_facade_remove_agent_session_delegates_to_store() -> None:
    class _Store:
        def __init__(self):
            self.removed = []

        def remove_agent_session(self, user_id, agent_name, thread_id):
            self.removed.append((user_id, agent_name, thread_id))
            return True

    store = _Store()
    facade = SessionsFacade(store)

    assert facade.remove_agent_session("telegram::user::58181121", "claude", "telegram_58181121") is True
    facade.clear_agent_session_mapping("telegram::user::58181121", "claude", "telegram_58181121")

    assert store.removed == [
        ("telegram::user::58181121", "claude", "telegram_58181121"),
        ("telegram::user::58181121", "claude", "telegram_58181121"),
    ]