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.

39.7 KB
Raw Blame
from __future__ import annotations

import json

import pytest

from config import paths
from storage import message_deliveries
from storage.background import attach_agent_run_delivery_in_connection
from storage.db import create_sqlite_engine
from storage.importer import ensure_sqlite_state
from storage.models import agent_sessions, messages
from storage.settings_service import upsert_scope
from vibe import cli


def _setup(monkeypatch, tmp_path):
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    paths.ensure_data_dirs()
    ensure_sqlite_state(primary_platform="avibe")
    return create_sqlite_engine(paths.get_sqlite_state_path())


def _seed(engine, sid, *, platform="avibe", native="proj_a", title="T", backend="claude", status="active", title_source=None, last_active="2026-06-09T10:00:00Z"):
    now = "2026-06-09T09:00:00Z"
    scope_type = "project" if platform == "avibe" else "channel"
    metadata = {"title_source": title_source} if title_source else {}
    with engine.begin() as conn:
        scope_id = upsert_scope(conn, platform=platform, scope_type=scope_type, native_id=native, now=now)
        conn.execute(
            agent_sessions.insert().values(
                id=sid, scope_id=scope_id, agent_id="agent_internal_" + sid, agent_name=backend,
                agent_backend=backend, agent_variant="default", session_anchor="anc_" + sid,
                native_session_id="nat_" + sid, title=title, status=status, agent_status="idle",
                metadata_json=json.dumps(metadata), created_at=now, updated_at=now, last_active_at=last_active,
            )
        )
    return scope_id


def _run(cmd, argv, capsys):
    args = cli.build_parser().parse_args(argv)
    code = cmd(args)
    captured = capsys.readouterr()
    stream = captured.out if code == 0 else captured.err
    return code, json.loads(stream)


# --------------------------------------------------------------------------- list


def test_list_excludes_archived_and_orders_by_activity(monkeypatch, tmp_path, capsys):
    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesaaa", platform="avibe", native="proj_a", last_active="2026-06-09T12:00:00Z")
    _seed(engine, "sesbbb", platform="slack", native="C1", last_active="2026-06-09T13:00:00Z")
    _seed(engine, "sesarch", platform="avibe", native="proj_a", status="archived", last_active="2026-06-09T14:00:00Z")

    code, payload = _run(cli.cmd_session_list, ["session", "list"], capsys)
    assert code == 0
    assert payload["kind"] == "agent_sessions"
    ids = [s["id"] for s in payload["sessions"]]
    assert ids == ["sesbbb", "sesaaa"]  # newest activity first; archived excluded
    assert "message" not in payload


def test_list_row_has_only_lean_present_fields(monkeypatch, tmp_path, capsys):
    from core.services import sessions as sessions_service

    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesaaa", platform="slack", native="C1")
    with engine.begin() as conn:
        standalone = sessions_service.create_session(
            conn, scope_id=None, agent_backend="codex", agent_name="codex", visibility="foreground"
        )
    _, payload = _run(cli.cmd_session_list, ["session", "list"], capsys)
    rows = {row["id"]: row for row in payload["sessions"]}
    row = rows["sesaaa"]
    assert set(row) == {"id", "title", "platform", "project_id", "agent_name", "agent_status", "last_active_at"}
    assert row["platform"] == "slack"
    assert "agent_backend" not in row and "status" not in row
    # An untitled standalone Session has no title, platform, or project: the keys are absent.
    assert set(rows[standalone["id"]]) == {"id", "agent_name", "agent_status", "last_active_at"}


def test_list_type_filter(monkeypatch, tmp_path, capsys):
    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesweb", platform="avibe", native="proj_a")
    _seed(engine, "seschat", platform="slack", native="C1")
    _, payload = _run(cli.cmd_session_list, ["session", "list", "--type", "slack"], capsys)
    assert [s["id"] for s in payload["sessions"]] == ["seschat"]


def test_list_avibe_type_includes_foreground_standalone(monkeypatch, tmp_path, capsys):
    from core.services import sessions as sessions_service

    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesweb", platform="avibe", native="proj_a")
    _seed(engine, "seschat", platform="slack", native="C1")
    with engine.begin() as conn:
        standalone = sessions_service.create_session(
            conn,
            scope_id=None,
            agent_backend="codex",
            visibility="foreground",
        )

    _, payload = _run(cli.cmd_session_list, ["session", "list", "--type", "avibe"], capsys)

    assert {session["id"] for session in payload["sessions"]} == {
        "sesweb",
        standalone["id"],
    }


def test_list_uses_shared_pagination_contract(monkeypatch, tmp_path, capsys):
    engine = _setup(monkeypatch, tmp_path)
    for i in range(22):
        _seed(engine, f"ses{i:02d}", platform="slack", native="C1", last_active=f"2026-06-09T10:{i:02d}:00Z")
    _, page1 = _run(cli.cmd_session_list, ["session", "list"], capsys)
    assert len(page1["sessions"]) == 20
    assert page1["pagination"]["has_more"] is True
    assert page1["pagination"]["next_command"] == "vibe session list --page 2 --limit 20"
    _, page2 = _run(cli.cmd_session_list, ["session", "list", "--page", "2", "--limit", "20"], capsys)
    assert len(page2["sessions"]) == 2
    assert page2["pagination"]["has_more"] is False


@pytest.mark.no_sqlite_template
def test_list_on_fresh_home_returns_empty(monkeypatch, tmp_path, capsys):
    # No ensure_sqlite_state(): _open_session_engine must bootstrap the DB itself,
    # so a fresh Avibe home returns a clean empty list, not "no such table" (Codex P2).
    monkeypatch.setenv("AVIBE_HOME", str(tmp_path))
    paths.ensure_data_dirs()
    assert not paths.get_sqlite_state_path().exists()
    code, payload = _run(cli.cmd_session_list, ["session", "list"], capsys)
    assert code == 0
    assert payload["sessions"] == []


def test_list_invalid_type_errors(monkeypatch, tmp_path, capsys):
    _setup(monkeypatch, tmp_path)
    code, payload = _run(cli.cmd_session_list, ["session", "list", "--type", "bogus"], capsys)
    assert code == 1
    assert payload["ok"] is False
    assert payload["code"] == "invalid_session_type"


# ---------------------------------------------------------------------------- get


def test_get_returns_detail_without_status_agentid_anchor(monkeypatch, tmp_path, capsys):
    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesaaa", platform="avibe", native="proj_a")
    code, payload = _run(cli.cmd_session_get, ["session", "get", "--session-id", "sesaaa"], capsys)
    assert code == 0
    s = payload["session"]
    assert s["id"] == "sesaaa"
    assert s["platform"] == "avibe"
    assert s["agent_backend"] == "claude"  # backend kept in detail
    for omitted in ("status", "agent_id", "session_anchor"):
        assert omitted not in s
    assert "message" not in payload


def test_get_defaults_to_caller_session(monkeypatch, tmp_path, capsys):
    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesaaa", platform="avibe", native="proj_a")
    monkeypatch.setenv("AVIBE_SESSION_ID", "sesaaa")

    code, payload = _run(cli.cmd_session_get, ["session", "get"], capsys)

    assert code == 0
    assert payload["session"]["id"] == "sesaaa"
    assert "session_default_notice" not in payload


@pytest.mark.parametrize(
    ("cmd_name", "argv", "help_command"),
    [
        ("cmd_session_get", ["session", "get"], "vibe session get --help"),
        ("cmd_session_update", ["session", "update", "--title", "x"], "vibe session update --help"),
        ("cmd_session_send_now", ["session", "send-now"], "vibe session send-now --help"),
        ("cmd_session_queue_list", ["session", "queue", "list"], "vibe session queue list --help"),
        ("cmd_session_queue_remove", ["session", "queue", "remove", "msg_any"], "vibe session queue remove --help"),
    ],
)
def test_single_session_commands_need_a_caller_or_session_id(monkeypatch, tmp_path, capsys, cmd_name, argv, help_command):
    _setup(monkeypatch, tmp_path)
    monkeypatch.delenv("AVIBE_SESSION_ID", raising=False)

    code, payload = _run(getattr(cli, cmd_name), argv, capsys)

    assert code == 1
    assert payload["code"] == "missing_caller_session"
    assert payload["help_command"] == help_command



def test_get_archived_is_not_found(monkeypatch, tmp_path, capsys):
    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesarch", status="archived")
    code, payload = _run(cli.cmd_session_get, ["session", "get", "--session-id", "sesarch"], capsys)
    assert code == 1
    assert payload["code"] == "session_not_found"


def test_get_missing_is_not_found(monkeypatch, tmp_path, capsys):
    _setup(monkeypatch, tmp_path)
    code, payload = _run(cli.cmd_session_get, ["session", "get", "--session-id", "nope"], capsys)
    assert code == 1
    assert payload["code"] == "session_not_found"


# -------------------------------------------------------------------- send now


def test_send_now_dispatches_an_existing_queue_without_adding_a_message(
    monkeypatch,
    tmp_path,
    capsys,
):
    from vibe import internal_client

    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesaaa")
    called: list[str] = []

    async def _send_now(session_id):
        called.append(session_id)
        return {
            "status_code": 200,
            "body": {
                "ok": True,
                "session_id": session_id,
                "status": "flushed",
            },
        }

    monkeypatch.setattr(internal_client, "send_now", _send_now)

    code, payload = _run(
        cli.cmd_session_send_now,
        ["session", "send-now", "--session-id", "sesaaa"],
        capsys,
    )

    assert code == 0
    assert called == ["sesaaa"]
    assert payload == {
        "schema_version": 1,
        "ok": True,
        "kind": "session_send_now",
        "session_id": "sesaaa",
        "status": "flushed",
        "result": {
            "ok": True,
            "session_id": "sesaaa",
            "status": "flushed",
        },
    }


def test_send_now_surfaces_a_typed_steer_refusal(monkeypatch, tmp_path, capsys):
    from vibe import internal_client

    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesaaa")

    async def _send_now(session_id):
        return {
            "status_code": 409,
            "body": {
                "ok": False,
                "session_id": session_id,
                "code": "send_now_refused",
                "detail": "backend refused steering",
            },
        }

    monkeypatch.setattr(internal_client, "send_now", _send_now)

    code, payload = _run(
        cli.cmd_session_send_now,
        ["session", "send-now", "--session-id", "sesaaa"],
        capsys,
    )

    assert code == 1
    assert payload["code"] == "send_now_refused"
    assert payload["error"] == "backend refused steering"
    assert payload["details"]["session_id"] == "sesaaa"
    assert payload["details"]["controller_status_code"] == 409


def test_send_now_surfaces_an_idle_flush_failure(monkeypatch, tmp_path, capsys):
    from vibe import internal_client

    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesaaa")

    async def _send_now(session_id):
        return {
            "status_code": 503,
            "body": {
                "ok": False,
                "session_id": session_id,
                "code": "flush_failed",
            },
        }

    monkeypatch.setattr(internal_client, "send_now", _send_now)

    code, payload = _run(
        cli.cmd_session_send_now,
        ["session", "send-now", "--session-id", "sesaaa"],
        capsys,
    )

    assert code == 1
    assert payload["code"] == "flush_failed"
    assert payload["details"]["session_id"] == "sesaaa"
    assert payload["details"]["controller_status_code"] == 503


def test_send_now_rejects_an_archived_session_before_controller_call(
    monkeypatch,
    tmp_path,
    capsys,
):
    from vibe import internal_client

    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesarch", status="archived")

    async def _send_now(_session_id):
        raise AssertionError("archived Session must not reach the live controller")

    monkeypatch.setattr(internal_client, "send_now", _send_now)

    code, payload = _run(
        cli.cmd_session_send_now,
        ["session", "send-now", "--session-id", "sesarch"],
        capsys,
    )

    assert code == 1
    assert payload["code"] == "session_not_found"


def test_send_now_accepts_im_while_queue_management_remains_workbench_only(
    monkeypatch,
    tmp_path,
    capsys,
):
    from vibe import internal_client

    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesim", platform="slack", native="C123")

    async def _send_now(session_id):
        return {
            "status_code": 200,
            "body": {
                "ok": True,
                "session_id": session_id,
                "status": "accepted",
            },
        }

    monkeypatch.setattr(internal_client, "send_now", _send_now)

    send_code, send_payload = _run(
        cli.cmd_session_send_now,
        ["session", "send-now", "--session-id", "sesim"],
        capsys,
    )
    list_code, list_payload = _run(
        cli.cmd_session_queue_list,
        ["session", "queue", "list", "--session-id", "sesim"],
        capsys,
    )
    remove_code, remove_payload = _run(
        cli.cmd_session_queue_remove,
        ["session", "queue", "remove", "msg_any", "--session-id", "sesim"],
        capsys,
    )

    assert send_code == 0
    assert send_payload["status"] == "accepted"
    assert list_code == 1
    assert list_payload["code"] == "session_queue_unsupported_target"
    assert remove_code == 1
    assert remove_payload["code"] == "session_queue_unsupported_target"


# ------------------------------------------------------------------------ queue


def test_queue_list_is_paginated_in_fifo_order_and_exposes_run_identity(
    monkeypatch,
    tmp_path,
    capsys,
):
    from storage import messages_service

    engine = _setup(monkeypatch, tmp_path)
    scope_id = _seed(engine, "sesaaa")
    with engine.begin() as conn:
        message_deliveries.enqueue_queued(
            conn,
            scope_id=scope_id,
            session_id="sesaaa",
            text="first",
        )
        message_deliveries.enqueue_queued(
            conn,
            scope_id=scope_id,
            session_id="sesaaa",
            author="harness",
            source="harness",
            text="second",
            metadata={
                "scheduled_provenance": {
                    "platform_specific": {
                        "task_trigger_kind": "agent_run",
                        "task_execution_id": "run_second",
                    }
                }
            },
        )
        message_deliveries.enqueue_queued(
            conn,
            scope_id=scope_id,
            session_id="sesaaa",
            text="third",
        )

    code, page1 = _run(
        cli.cmd_session_queue_list,
        ["session", "queue", "list", "--session-id", "sesaaa", "--limit", "2"],
        capsys,
    )

    assert code == 0
    assert [row["text"] for row in page1["queued"]] == ["first", "second"]
    assert [row["position"] for row in page1["queued"]] == [1, 2]
    assert page1["queued"][0]["run_id"] is None
    assert page1["queued"][1]["run_id"] == "run_second"
    assert page1["pagination"]["next_command"] == (
        "vibe session queue list --session-id sesaaa --page 2 --limit 2"
    )

    code, page2 = _run(
        cli.cmd_session_queue_list,
        ["session", "queue", "list", "--session-id", "sesaaa", "--page", "2", "--limit", "2"],
        capsys,
    )

    assert code == 0
    assert [row["text"] for row in page2["queued"]] == ["third"]
    assert [row["position"] for row in page2["queued"]] == [3]
    assert page2["pagination"]["has_more"] is False


def test_queue_list_reports_server_owned_explicit_retry_hold(monkeypatch, tmp_path, capsys):
    from core.session_turns import SessionTurnManager
    from tests.test_session_delivery_fsm import _Controller

    engine = _setup(monkeypatch, tmp_path)
    scope_id = _seed(engine, "sesaaa")
    manager = SessionTurnManager(_Controller())
    manager._engine = engine
    with engine.begin() as conn:
        payload = message_deliveries.enqueue_queued(
            conn, scope_id=scope_id, session_id="sesaaa", text="保留附件",
            metadata={"requires_explicit_retry": True, "retry_reason": "caller spoof"},
        )
    _, before = _run(cli.cmd_session_queue_list, ["session", "queue", "list", "--session-id", "sesaaa"], capsys)
    assert before["queued"][0]["requires_explicit_retry"] is False
    assert before["queued"][0]["retry_reason"] is None
    for _ in range(3):
        turn_id = message_deliveries.new_turn_id()
        with engine.begin() as conn:
            delivery = message_deliveries.get_delivery(conn, payload["id"])
            message_deliveries.claim_start_batch(
                conn, turn_id=turn_id, session_id="sesaaa", backend="claude",
                deliveries=[delivery], dispatch_text="保留附件",
            )
        manager._settle_durable_prewrite_failure(turn_id, outcome="no_terminal_result")
    code, result = _run(cli.cmd_session_queue_list, ["session", "queue", "list", "--session-id", "sesaaa"], capsys)
    assert code == 0
    assert result["queued"][0]["id"] == payload["id"]
    assert result["queued"][0]["requires_explicit_retry"] is True
    assert result["queued"][0]["retry_reason"] == "no_terminal_result"


def test_queue_remove_deletes_only_the_named_session_row_and_notifies_web(
    monkeypatch,
    tmp_path,
    capsys,
):
    from storage import messages_service

    engine = _setup(monkeypatch, tmp_path)
    scope_id = _seed(engine, "sesaaa")
    _seed(engine, "sesbbb", native="proj_b")
    with engine.begin() as conn:
        queued = message_deliveries.enqueue_queued(
            conn,
            scope_id=scope_id,
            session_id="sesaaa",
            text="obsolete",
        )
    notified: list[str] = []
    monkeypatch.setattr(
        cli,
        "_post_session_queue_updated_to_live_ui",
        lambda session_id: notified.append(session_id),
    )

    code, wrong_session = _run(
        cli.cmd_session_queue_remove,
        ["session", "queue", "remove", queued["id"], "--session-id", "sesbbb"],
        capsys,
    )

    assert code == 0
    assert wrong_session["removed"] is False
    assert wrong_session["status"] == "not_found"
    assert notified == []

    code, removed = _run(
        cli.cmd_session_queue_remove,
        ["session", "queue", "remove", queued["id"], "--session-id", "sesaaa"],
        capsys,
    )

    assert code == 0
    assert removed["removed"] is True
    assert removed["status"] == "removed"
    assert notified == ["sesaaa"]
    with engine.connect() as conn:
        assert message_deliveries.list_queued(conn, "sesaaa") == []


def test_queue_remove_cancels_the_agent_run_owned_by_that_row(
    monkeypatch,
    tmp_path,
    capsys,
):
    from core.scheduled_tasks import TaskExecutionStore
    from storage import messages_service

    engine = _setup(monkeypatch, tmp_path)
    scope_id = _seed(engine, "sesrun")
    store = TaskExecutionStore()
    request = store.enqueue_agent_run(
        session_id="sesrun",
        message="obsolete delegated work",
        agent_name="worker",
    )
    assert store.claim(request.id) is not None
    store.requeue(
        request.id,
        metadata={"workbench_queue_holds_run": True},
    )
    with engine.begin() as conn:
        queued = message_deliveries.enqueue_queued(
            conn,
            scope_id=scope_id,
            session_id="sesrun",
            author="harness",
            source="harness",
            text=request.message or "",
            native_message_id=f"agent_run:{request.id}",
        )
        assert attach_agent_run_delivery_in_connection(
            conn,
            request.id,
            session_id="sesrun",
            delivery_id=queued["id"],
        )
    monkeypatch.setattr(
        cli,
        "_post_session_queue_updated_to_live_ui",
        lambda _session_id: None,
    )

    code, removed = _run(
        cli.cmd_session_queue_remove,
        ["session", "queue", "remove", queued["id"], "--session-id", "sesrun"],
        capsys,
    )

    assert code == 0
    assert removed["removed"] is True
    stored = store.get_run(request.id)
    assert stored is not None
    assert stored["status"] == "canceled"
    assert stored["cancel_requested"] is True
    with engine.connect() as conn:
        assert message_deliveries.list_queued(conn, "sesrun") == []


def test_queue_commands_reject_an_archived_session(monkeypatch, tmp_path, capsys):
    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesarch", status="archived")

    list_code, list_payload = _run(
        cli.cmd_session_queue_list,
        ["session", "queue", "list", "--session-id", "sesarch"],
        capsys,
    )
    remove_code, remove_payload = _run(
        cli.cmd_session_queue_remove,
        ["session", "queue", "remove", "msg_any", "--session-id", "sesarch"],
        capsys,
    )

    assert list_code == 1
    assert list_payload["code"] == "session_not_found"
    assert remove_code == 1
    assert remove_payload["code"] == "session_not_found"


# ------------------------------------------------------------------------- update


def test_update_sets_title(monkeypatch, tmp_path, capsys):
    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesaaa", title="Old")
    code, payload = _run(cli.cmd_session_update, ["session", "update", "--session-id", "sesaaa", "--title", "New name"], capsys)
    assert code == 0
    assert payload["updated"] is True
    assert payload["session"]["title"] == "New name"
    assert "status" not in payload["session"]
    # An agent-set title is sourced "agent" (vs "user" for a human Web UI edit).
    assert payload["session"]["metadata"]["title_source"] == "agent"


def test_update_defaults_to_caller_session(monkeypatch, tmp_path, capsys):
    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesaaa", title="Old")
    monkeypatch.setenv("AVIBE_SESSION_ID", "sesaaa")

    code, payload = _run(cli.cmd_session_update, ["session", "update", "--title", "New name"], capsys)

    assert code == 0
    assert payload["updated"] is True
    assert payload["session"]["id"] == "sesaaa"
    assert payload["session"]["title"] == "New name"
    assert "session_default_notice" not in payload


def test_update_empty_title_clears(monkeypatch, tmp_path, capsys):
    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesaaa", title="Old")
    _, payload = _run(cli.cmd_session_update, ["session", "update", "--session-id", "sesaaa", "--title", ""], capsys)
    assert payload["session"]["title"] is None


@pytest.mark.parametrize(
    ("title_source", "updated"),
    [
        (None, True),
        ("backend", True),
        ("derived_first_prompt", True),
        ("user", False),
        ("agent", False),
    ],
)
def test_update_if_untitled_keeps_only_a_deliberate_title(monkeypatch, tmp_path, capsys, title_source, updated):
    """The Session Title prompt's one call: an automatic title counts as untitled."""
    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesaaa", title="Old", title_source=title_source)

    code, payload = _run(
        cli.cmd_session_update,
        ["session", "update", "--session-id", "sesaaa", "--title", "New name", "--if-untitled"],
        capsys,
    )

    assert code == 0
    assert payload["updated"] is updated
    assert payload["session"]["title"] == ("New name" if updated else "Old")
    assert payload["session"]["metadata"].get("title_source") == ("agent" if updated else title_source)


def test_update_if_untitled_never_overwrites_a_concurrent_user_rename(monkeypatch, tmp_path, capsys):
    """A rename committed while the call waits wins, because the check holds the write lock."""
    import threading
    import time

    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesaaa", title="Auto", title_source="backend")
    args = cli.build_parser().parse_args(
        ["session", "update", "--session-id", "sesaaa", "--title", "Agent name", "--if-untitled"]
    )
    result = {}
    with engine.connect() as web:
        web.exec_driver_sql("BEGIN IMMEDIATE")
        web.execute(
            agent_sessions.update()
            .where(agent_sessions.c.id == "sesaaa")
            .values(title="User name", metadata_json=json.dumps({"title_source": "user"}))
        )
        worker = threading.Thread(target=lambda: result.update(code=cli.cmd_session_update(args)))
        worker.start()
        time.sleep(0.5)  # let the CLI reach the lock before the rename commits
        web.commit()
        worker.join(timeout=10)

    assert result["code"] == 0
    assert json.loads(capsys.readouterr().out)["updated"] is False
    with engine.connect() as conn:
        assert conn.execute(
            agent_sessions.select().where(agent_sessions.c.id == "sesaaa")
        ).mappings().one()["title"] == "User name"


@pytest.mark.parametrize(
    "extra",
    [[], ["--title", "x", "--hidden"], ["--title", "x", "--scope-id", "none"]],
)
def test_update_if_untitled_applies_only_to_title(monkeypatch, tmp_path, capsys, extra):
    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesaaa", title="Old")

    code, payload = _run(
        cli.cmd_session_update,
        ["session", "update", "--session-id", "sesaaa", "--if-untitled", *extra],
        capsys,
    )

    assert code == 1
    assert payload["code"] == "invalid_arguments"


def test_update_help_teaches_visibility_sugar(capsys):
    parser = cli.build_parser()

    with pytest.raises(SystemExit) as exc:
        parser.parse_args(["session", "update", "--help"])

    assert exc.value.code == 0
    help_text = capsys.readouterr().out
    assert "--visible" in help_text
    assert "--hidden" in help_text
    assert "--visibility" not in help_text


@pytest.mark.parametrize(
    ("flag", "expected"),
    [("--visible", "foreground"), ("--hidden", "background")],
)
def test_update_visibility_sugar_parses(flag, expected):
    args = cli.build_parser().parse_args(["session", "update", "--session-id", "sesaaa", flag])

    assert args.visibility == expected


@pytest.mark.parametrize(
    "visibility_args",
    [
        ["--visible", "--hidden"],
    ],
)
def test_update_visibility_sugar_rejects_conflicts(visibility_args, capsys):
    parser = cli.build_parser()

    with pytest.raises(SystemExit) as exc:
        parser.parse_args(["session", "update", "--session-id", "sesaaa", *visibility_args])

    assert exc.value.code == 2
    payload = json.loads(capsys.readouterr().err)
    assert payload["code"] == "invalid_arguments"
    assert "not allowed with argument" in payload["error"]


def test_update_visibility_and_make_standalone_keeps_workdir(monkeypatch, tmp_path, capsys):
    engine = _setup(monkeypatch, tmp_path)
    original_scope_id = _seed(engine, "sesaaa", title="Old")
    posted: dict = {}
    monkeypatch.setattr(
        cli,
        "_post_session_activity_to_live_ui",
        lambda session_id, **kwargs: posted.update(session_id=session_id, **kwargs),
    )
    with engine.begin() as conn:
        conn.execute(
            agent_sessions.update()
            .where(agent_sessions.c.id == "sesaaa")
            .values(workdir=str(tmp_path / "original-workdir"))
        )
        original_workdir = conn.execute(
            agent_sessions.select().where(agent_sessions.c.id == "sesaaa")
        ).mappings().one()["workdir"]

    code, payload = _run(
        cli.cmd_session_update,
        [
            "session",
            "update",
            "--session-id",
            "sesaaa",
            "--hidden",
            "--scope-id",
            "none",
        ],
        capsys,
    )

    assert code == 0
    assert payload["session"]["visibility"] == "background"
    assert payload["session"]["scope_id"] is None
    assert payload["session"]["project_id"] is None
    assert payload["session"]["workdir"] == original_workdir
    assert posted == {
        "session_id": "sesaaa",
        "previous_scope_id": original_scope_id,
        "previous_visibility": "foreground",
    }
    with engine.connect() as conn:
        anchor = conn.execute(
            agent_sessions.select().where(agent_sessions.c.id == "sesaaa")
        ).mappings().one()["session_anchor"]
    assert anchor == "sesaaa"


def test_update_archived_is_not_found(monkeypatch, tmp_path, capsys):
    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesarch", status="archived", title="Old")
    code, payload = _run(cli.cmd_session_update, ["session", "update", "--session-id", "sesarch", "--title", "x"], capsys)
    assert code == 1
    assert payload["code"] == "session_not_found"
    # title must not have been written to the soft-deleted row
    with engine.connect() as conn:
        from sqlalchemy import select

        title = conn.execute(select(agent_sessions.c.title).where(agent_sessions.c.id == "sesarch")).scalar_one()
    assert title == "Old"


# ------------------------------------------------------------------- IM linkage


def test_im_messages_link_to_session(monkeypatch, tmp_path):
    import core.message_mirror as mm
    from modules.im.base import MessageContext
    from sqlalchemy import select

    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesim", platform="slack", native="C777")

    spec = {"agent_session_id": "sesim", "vibe_agent_name": "claude", "vibe_agent_backend": "claude"}
    # agent reply rides the source session_id; scope stays the delivery channel
    mm.persist_agent_message(
        MessageContext(user_id="U", channel_id="C777", platform="slack", thread_id="t1", platform_specific=spec),
        "result", "answer",
    )
    # human inbound is scope-keyed first, then back-filled
    mm.mirror_inbound(MessageContext(user_id="U", channel_id="C777", platform="slack", thread_id="t1", message_id="m1"), "question")
    mm.link_inbound_message_session(platform="slack", native_message_id="m1", session_id="sesim")
    # harness prompt carrying a source session links too
    mm.mirror_harness_inbound(
        MessageContext(user_id="s", channel_id="C777", platform="slack", message_id="h1",
                       platform_specific={"agent_session_id": "sesim", "task_trigger_kind": "scheduled", "task_definition_id": "d1"}),
        "reminder",
    )

    with engine.connect() as conn:
        rows = list(conn.execute(select(messages.c.author, messages.c.session_id)).mappings())
    assert len(rows) == 3
    assert all(r["session_id"] == "sesim" for r in rows)


def test_link_inbound_is_noop_when_already_linked(monkeypatch, tmp_path):
    import core.message_mirror as mm
    from modules.im.base import MessageContext
    from sqlalchemy import select

    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesim", platform="slack", native="C777")
    _seed(engine, "sesother", platform="slack", native="C777")
    mm.mirror_inbound(MessageContext(user_id="U", channel_id="C777", platform="slack", message_id="m1"), "q")
    mm.link_inbound_message_session(platform="slack", native_message_id="m1", session_id="sesim")
    # a second, different back-fill must not overwrite an already-linked row
    mm.link_inbound_message_session(platform="slack", native_message_id="m1", session_id="sesother")
    with engine.connect() as conn:
        sid = conn.execute(select(messages.c.session_id).where(messages.c.native_message_id == "m1")).scalar_one()
    assert sid == "sesim"


# ------------------------------------------------------------ title prompt


def _injection_for(session_id, *, platform="avibe", platform_specific=None):
    from core.system_prompt_injection import build_system_prompt_injection
    from modules.im.base import MessageContext

    payload = {"agent_session_id": session_id}
    if platform_specific:
        payload.update(platform_specific)

    ctx = MessageContext(
        user_id="u", channel_id="c", platform=platform,
        platform_specific=payload,
    )
    return build_system_prompt_injection(context=ctx)


def test_web_title_prompt_defaults_to_current_session():
    out = _injection_for("sesweb")
    title_prompt = out[out.index("## Session Title") :]
    assert "## Session Title" in out
    # One call: the CLI keeps a deliberate title, so no `vibe session get` first.
    assert '`vibe session update --title "<short title>" --if-untitled`' in title_prompt
    assert "vibe session get" not in title_prompt
    assert "sesweb" not in title_prompt
    assert "keeps a title the user or an Agent already set" in out
    assert "silently set one concise, human-scannable Session title" in out
    assert "without waiting for the user" in out
    assert "do not rename it again" in out
    assert len(title_prompt.strip()) < 450
    assert "not set yet" not in out
    assert "auto-generated" not in out


def test_im_title_prompt_is_not_injected():
    out = _injection_for("sesim", platform="slack")
    assert "## Session Title" not in out
    assert "vibe session update sesim --title" not in out
    assert "Current Session Reminder" not in out


def test_forked_session_prompt_marks_target_session_id_authoritative():
    out = _injection_for(
        "sestarget",
        platform_specific={
            "agent_session_target": {
                "id": "sestarget",
                "native_session_fork": {
                    "source_session_id": "sessource",
                    "source_native_session_id": "native-source",
                    "source_backend": "codex",
                },
            },
        },
    )

    assert "Current session id: `sestarget`" in out
    assert "This Agent Session was forked from `sessource`." in out
    assert "The authoritative Avibe session id for this fork is `sestarget`." in out
    assert "If copied source context mentions another Avibe session id" in out
    assert "treat it as historical source-context only" in out
    assert "for Show Pages, Harness commands, tasks, watches, callbacks, and session updates" not in out


def test_forked_session_prompt_can_use_persisted_metadata():
    out = _injection_for(
        "sestarget",
        platform_specific={
            "agent_session_target": {
                "id": "sestarget",
                "metadata": {
                    "created_via": "session_fork",
                    "fork_source_session_id": "sessource",
                    "fork_source_native_session_id": "native-source",
                    "fork_source_backend": "opencode",
                },
            },
        },
    )

    assert "This Agent Session was forked from `sessource`." in out
    assert "The authoritative Avibe session id for this fork is `sestarget`." in out


# ------------------------------------------------ live session.activity endpoint


def test_cli_activity_endpoint_publishes_with_token(monkeypatch):
    # The publish-only endpoint the CLI pings after vibe session update: with a valid
    # local CLI token it re-reads the row and broadcasts session.activity 'updated'.
    import vibe.sse_broker as sse_broker
    from core.show_pages import SHOW_CLI_EVENT_TOKEN_HEADER, show_cli_event_token
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from vibe.ui_server import app

    ensure_sqlite_state(primary_platform="avibe")  # conftest already isolated the home
    engine = create_sqlite_engine(paths.get_sqlite_state_path())
    _seed(engine, "seslive", title="Renamed", title_source="agent")

    published: list = []
    monkeypatch.setattr(sse_broker.broker, "publish", lambda topic, data: published.append((topic, data)))

    resp = app.test_client().post(
        "/api/sessions/seslive/cli-activity",
        json={},
        headers={"X-Vibe-Show-Client": "cli", SHOW_CLI_EVENT_TOKEN_HEADER: show_cli_event_token()},
    )
    assert resp.status_code == 200
    events = [data for topic, data in published if topic == "session.activity"]
    assert events and events[0]["session_id"] == "seslive"
    assert events[0]["event"] == "updated" and events[0]["title"] == "Renamed"


def test_cli_activity_endpoint_publishes_queue_updates_with_token(monkeypatch):
    import vibe.sse_broker as sse_broker
    from core.show_pages import SHOW_CLI_EVENT_TOKEN_HEADER, show_cli_event_token
    from vibe.ui_server import app

    published: list[tuple[str, dict]] = []
    monkeypatch.setattr(
        sse_broker.broker,
        "publish",
        lambda topic, data: published.append((topic, data)),
    )

    resp = app.test_client().post(
        "/api/sessions/sesqueue/cli-activity",
        json={"event": "queue_updated"},
        headers={
            "X-Vibe-Show-Client": "cli",
            SHOW_CLI_EVENT_TOKEN_HEADER: show_cli_event_token(),
        },
    )

    assert resp.status_code == 200
    assert published == [("queue.updated", {"session_id": "sesqueue"})]


def test_cli_activity_placement_events_match_patch(monkeypatch):
    import vibe.sse_broker as sse_broker
    from core.services import sessions as sessions_service
    from core.show_pages import SHOW_CLI_EVENT_TOKEN_HEADER, show_cli_event_token
    from storage.db import create_sqlite_engine
    from storage.importer import ensure_sqlite_state
    from tests.ui_server_test_helpers import csrf_headers
    from vibe.ui_server import app

    ensure_sqlite_state(primary_platform="avibe")
    engine = create_sqlite_engine(paths.get_sqlite_state_path())
    scope_id = _seed(engine, "sesplacement", title="Placement")
    published: list[tuple[str, dict]] = []
    monkeypatch.setattr(
        sse_broker.broker,
        "publish",
        lambda topic, data: published.append((topic, data)),
    )

    client = app.test_client()
    response = client.patch(
        "/api/sessions/sesplacement",
        json={"visibility": "background"},
        headers=csrf_headers(client),
    )
    assert response.status_code == 200
    patch_events = [data for topic, data in published if topic == "session.activity"]

    with engine.begin() as conn:
        sessions_service.update_session(
            conn,
            "sesplacement",
            visibility="foreground",
        )
        previous = sessions_service.get_session(conn, "sesplacement")
        sessions_service.update_session(
            conn,
            "sesplacement",
            visibility="background",
        )
    published.clear()

    response = client.post(
        "/api/sessions/sesplacement/cli-activity",
        json={
            "previous_scope_id": previous["scope_id"],
            "previous_visibility": previous["visibility"],
        },
        headers={
            "X-Vibe-Show-Client": "cli",
            SHOW_CLI_EVENT_TOKEN_HEADER: show_cli_event_token(),
        },
    )
    assert response.status_code == 200
    cli_events = [data for topic, data in published if topic == "session.activity"]

    assert previous["scope_id"] == scope_id
    assert cli_events == patch_events


def test_cli_activity_endpoint_rejects_without_token(monkeypatch):
    from tests.ui_server_test_helpers import csrf_headers
    from vibe.ui_server import app

    client = app.test_client()
    # Valid CSRF (passes the mutation guard) but NO local CLI token -> handler 403.
    resp = client.post("/api/sessions/whatever/cli-activity", json={}, headers=csrf_headers(client))
    assert resp.status_code == 403


def test_backfill_does_not_overwrite_agent_title(monkeypatch, tmp_path):
    # Backend auto-fill must never clobber a deliberately agent-set title.
    from core.services import sessions as sessions_service

    engine = _setup(monkeypatch, tmp_path)
    _seed(engine, "sesagent", title="Kept", title_source="agent")
    with engine.begin() as conn:
        result = sessions_service.backfill_session_title(
            conn, "sesagent", title="Auto Title", backend="claude"
        )
    assert result is None  # skipped
    with engine.connect() as conn:
        from sqlalchemy import select

        title = conn.execute(select(agent_sessions.c.title).where(agent_sessions.c.id == "sesagent")).scalar_one()
    assert title == "Kept"