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.
Python agentagent-osaiai-agentsai-partnerchatopsclaudeclaude-codecodexdevtoolsdiscord-botlark-botllmlocal-firstlong-term-memoryopencodeslack-botvibe-codingvibeywechat
"""Unified background-work banner — union derivation.
Covers the presentation-layer union assembled at runtime-state build time
(docs/plans/unified-background-work-banner.md): backend activities from the
process-local ``SessionActivityRegistry`` joined with harness items
(watches / scheduled tasks / delegated agent runs) derived LIVE from the durable
store. The harness items must derive from the DB, never from the registry, so the
banner stays correct across a restart.
"""
from __future__ import annotations
import json
from contextlib import nullcontext
from pathlib import Path
from types import SimpleNamespace
from sqlalchemy import insert, select
from core.session_activities import SessionActivityRegistry
from core.session_turns import SessionTurnManager
from storage import message_deliveries as delivery_store
from storage.agent_session_rows import create_agent_session_row
from storage.background import SQLiteBackgroundTaskStore, task_resume_block
from storage.db import create_sqlite_engine
from storage.importer import ensure_sqlite_state
from storage.models import agent_runs, agent_sessions, run_definitions
from storage.session_reclaim import RECLAIM_DELETE, RECLAIM_PAUSE, reclaim_bound_definitions
from storage.workbench_sessions_service import (
count_bound_resources,
derive_session_harness_activities,
)
_NOW = "2026-07-16T00:00:00Z"
def _make_engine(tmp_path: Path):
db_path = tmp_path / "state" / "vibe.sqlite"
ensure_sqlite_state(db_path=db_path, primary_platform="avibe")
return create_sqlite_engine(db_path), db_path
def _insert_definition(engine, **overrides) -> str:
values = {
"id": overrides.pop("id"),
"definition_type": overrides.pop("definition_type"),
"name": None,
"session_id": None,
"prompt": None,
"message": None,
"enabled": 1,
"deleted_at": None,
"created_at": _NOW,
"updated_at": _NOW,
"metadata_json": "{}",
}
values.update(overrides)
with engine.begin() as conn:
conn.execute(insert(run_definitions).values(**values))
return values["id"]
def _insert_run(engine, **overrides) -> str:
values = {
"id": overrides.pop("id"),
"run_type": "agent_run",
"status": "running",
"agent_name": None,
"agent_backend": None,
"message": None,
"prompt": None,
"session_id": None,
"callback_session_id": None,
# Async delegated runs carry a pending callback while running; the banner
# only surfaces these (sync --sync runs leave callback_status null).
"callback_status": "pending",
"created_at": _NOW,
"started_at": _NOW,
"updated_at": _NOW,
"metadata_json": "{}",
}
values.update(overrides)
with engine.begin() as conn:
conn.execute(insert(agent_runs).values(**values))
return values["id"]
def _insert_queued_delivery(engine, *, delivery_id: str, session_id: str, now: str) -> None:
with engine.begin() as conn:
if (
conn.execute(
select(agent_sessions.c.id).where(agent_sessions.c.id == session_id)
).scalar_one_or_none()
is None
):
create_agent_session_row(
conn,
scope_id=None,
session_id=session_id,
session_anchor=session_id,
agent_backend="codex",
workdir="/tmp",
now=now,
)
delivery_store.insert_delivery(
conn,
delivery_id=delivery_id,
session_id=session_id,
priority="p3",
state="queued",
snapshot=delivery_store.message_snapshot(
scope_id=None,
session_id=session_id,
platform="avibe",
author="user",
source="harness",
text="audit the contract",
),
dispatch_text="audit the contract",
now=now,
)
def _accept_delivery_turn(
engine,
*,
session_id: str,
turn_id: str,
delivery_ids: list[str],
) -> None:
with engine.begin() as conn:
deliveries = [
delivery_store.get_delivery(conn, delivery_id)
for delivery_id in delivery_ids
]
assert all(deliveries)
claimed = delivery_store.claim_start_batch(
conn,
turn_id=turn_id,
session_id=session_id,
backend="codex",
deliveries=[deliveries[0]],
dispatch_text=str(deliveries[0]["dispatch_text"]),
attempt_id=f"attempt:start:{turn_id}",
)
turn = claimed["turn"]
native_turn_id = f"native:{turn_id}"
assert delivery_store.bind_native_start(
conn,
turn_id,
expected_version=int(turn["version"]),
runtime_key=f"runtime:{turn_id}",
runtime_turn_id=f"runtime-turn:{turn_id}",
native_turn_id=native_turn_id,
) is not None
assert delivery_store.materialize_start_acceptance(
conn,
turn_id=turn_id,
evidence={"kind": "test_native_acceptance"},
)
if len(deliveries) == 1:
return
steer_attempt_id = f"attempt:steer:{turn_id}"
steered = delivery_store.open_steer_attempt_batch(
conn,
deliveries=deliveries[1:],
turn_id=turn_id,
attempt_id=steer_attempt_id,
expected_native_turn_id=native_turn_id,
)
assert delivery_store.materialize_steer_acceptance(
conn,
leader_delivery_id=str(steered[0]["id"]),
expected_attempt_id=steer_attempt_id,
turn_id=turn_id,
evidence={"kind": "test_native_acceptance"},
)
def test_each_harness_source_contributes_one_row(tmp_path: Path):
engine, _ = _make_engine(tmp_path)
_insert_definition(
engine,
id="watch-1",
definition_type="watch",
name="deploy watch",
session_id="ses-1",
)
_insert_definition(
engine,
id="task-1",
definition_type="scheduled",
name="nightly report",
session_id="ses-1",
schedule_type="cron",
)
_insert_run(
engine,
id="run-1",
agent_name="worker",
message="audit the contract",
session_id="ses-delegate",
callback_session_id="ses-1",
)
with engine.connect() as conn:
items = derive_session_harness_activities(conn, "ses-1")
by_kind = {item["item_kind"]: item for item in items}
assert set(by_kind) == {"watch", "task", "agent_run"}
assert by_kind["watch"]["id"] == "watch:watch-1"
assert by_kind["watch"]["label"] == "deploy watch"
assert by_kind["watch"]["schedule_type"] is None
assert by_kind["task"]["id"] == "task:task-1"
assert by_kind["task"]["label"] == "nightly report"
assert by_kind["task"]["schedule_type"] == "cron"
assert by_kind["agent_run"]["id"] == "agent_run:run-1"
assert by_kind["agent_run"]["label"] == "worker: audit the contract"
assert by_kind["agent_run"]["status"] == "running"
assert by_kind["agent_run"]["schedule_type"] is None
# ``since`` and a stable id are present on every unified item.
assert all(item["since"] == _NOW for item in items)
assert all(item["id"] for item in items)
def test_queued_delivery_projects_delegated_run_as_queued(tmp_path: Path):
engine, _ = _make_engine(tmp_path)
queued_at = "2026-07-16T00:00:01Z"
_insert_queued_delivery(
engine,
delivery_id="delivery-queued",
session_id="ses-delegate",
now=queued_at,
)
_insert_run(
engine,
id="run-queued-delivery",
agent_name="worker",
message="audit the contract",
session_id="ses-delegate",
callback_session_id="ses-caller",
delivery_id="delivery-queued",
status="running",
started_at="2026-07-16T00:00:02Z",
)
with engine.connect() as conn:
items = derive_session_harness_activities(conn, "ses-caller")
assert len(items) == 1
assert items[0]["status"] == "queued"
assert items[0]["since"] == queued_at
def test_agent_run_banner_collapses_accepted_turn_and_keeps_queued_deliveries(
tmp_path: Path,
):
"""MESSAGE-DELIVERY-315: one active row per Turn, but one queued row per Delivery."""
engine, _ = _make_engine(tmp_path)
accepted_b = ["delivery-b-1", "delivery-b-2", "delivery-b-3"]
accepted_c = ["delivery-c-1"]
queued_b = ["delivery-b-queued-1", "delivery-b-queued-2"]
delivery_ids = [*accepted_b, *accepted_c, *queued_b]
for offset, delivery_id in enumerate(delivery_ids, start=1):
session_id = (
"ses-target-c"
if delivery_id.startswith("delivery-c")
else "ses-target-b"
)
_insert_queued_delivery(
engine,
delivery_id=delivery_id,
session_id=session_id,
now=f"2026-07-16T00:00:{offset:02d}Z",
)
_accept_delivery_turn(
engine,
session_id="ses-target-b",
turn_id="turn-b",
delivery_ids=accepted_b,
)
_accept_delivery_turn(
engine,
session_id="ses-target-c",
turn_id="turn-c",
delivery_ids=accepted_c,
)
run_specs = (
("run-b-1", accepted_b[0], "first accepted", "2026-07-16T00:10:05Z"),
("run-b-2", accepted_b[1], "second accepted", "2026-07-16T00:10:04Z"),
# The latest Turn position is deliberately not the newest Run timestamp.
("run-b-3", accepted_b[2], "last accepted", "2026-07-16T00:10:01Z"),
("run-c-1", accepted_c[0], "other target", "2026-07-16T00:10:02Z"),
("run-b-queued-1", queued_b[0], "queued first", "2026-07-16T00:10:03Z"),
("run-b-queued-2", queued_b[1], "queued second", "2026-07-16T00:10:06Z"),
)
for run_id, delivery_id, message, created_at in run_specs:
session_id = (
"ses-target-c"
if delivery_id.startswith("delivery-c")
else "ses-target-b"
)
_insert_run(
engine,
id=run_id,
agent_name="worker",
message=message,
session_id=session_id,
callback_session_id="ses-caller",
delivery_id=delivery_id,
created_at=created_at,
started_at=created_at,
updated_at=created_at,
)
with engine.connect() as conn:
items = derive_session_harness_activities(conn, "ses-caller")
assert {item["id"] for item in items} == {
"agent_run:run-b-3",
"agent_run:run-c-1",
"agent_run:run-b-queued-1",
"agent_run:run-b-queued-2",
}
by_id = {item["id"]: item for item in items}
assert by_id["agent_run:run-b-3"]["label"] == "worker: last accepted"
assert by_id["agent_run:run-c-1"]["status"] == "running"
assert by_id["agent_run:run-b-queued-1"]["status"] == "queued"
assert by_id["agent_run:run-b-queued-2"]["status"] == "queued"
def test_task_schedule_type_comes_from_the_durable_definition(tmp_path: Path):
engine, _ = _make_engine(tmp_path)
_insert_definition(
engine,
id="task-once",
definition_type="scheduled",
name="title says every day but is one-shot",
session_id="ses-1",
schedule_type="at",
)
_insert_definition(
engine,
id="task-recurring",
definition_type="scheduled",
name="title says one-off but is recurring",
session_id="ses-1",
schedule_type="cron",
)
with engine.connect() as conn:
items = derive_session_harness_activities(conn, "ses-1")
assert {item["id"]: item["schedule_type"] for item in items} == {
"task:task-once": "at",
"task:task-recurring": "cron",
}
def test_task_label_falls_back_to_prompt_when_unnamed(tmp_path: Path):
engine, _ = _make_engine(tmp_path)
_insert_definition(
engine,
id="task-2",
definition_type="scheduled",
name=None,
prompt="summarize the daily standup notes",
session_id="ses-1",
)
with engine.connect() as conn:
items = derive_session_harness_activities(conn, "ses-1")
assert len(items) == 1
assert items[0]["label"] == "summarize the daily standup notes"
def test_definition_banner_uses_creation_owner_before_execution_target(tmp_path: Path):
"""SCT-060: pending definitions belong to their creating Session, not their fire target."""
engine, _ = _make_engine(tmp_path)
owner_metadata = json.dumps(
{"created_by": {"caller": {"session_id": "ses-owner"}}}
)
with engine.begin() as conn:
for session_id, session_anchor in (
("ses-owner", "banner-owner"),
("ses-other", "banner-other"),
):
create_agent_session_row(
conn,
scope_id=None,
session_id=session_id,
session_anchor=session_anchor,
agent_backend="codex",
workdir="/tmp",
now=_NOW,
)
_insert_definition(
engine,
id="task-per-run",
definition_type="scheduled",
name="per run",
metadata_json=owner_metadata,
)
_insert_definition(
engine,
id="task-command",
definition_type="scheduled",
name="command",
metadata_json=owner_metadata,
)
_insert_definition(
engine,
id="task-create-once",
definition_type="scheduled",
name="new session",
session_id="ses-execution",
metadata_json=owner_metadata,
)
# A legacy row has no creation provenance and keeps the old bound-session
# fallback. A row with provenance pointing elsewhere must not leak through
# its execution target.
_insert_definition(
engine,
id="task-legacy",
definition_type="scheduled",
name="legacy",
session_id="ses-owner",
)
_insert_definition(
engine,
id="task-owned-elsewhere",
definition_type="scheduled",
name="owned elsewhere",
session_id="ses-owner",
metadata_json=json.dumps(
{"created_by": {"caller": {"session_id": "ses-other"}}}
),
)
# Schema-invalid owner values must not suppress the legacy bound-session fallback.
for task_id, owner_value in (
("task-owner-object", {}),
("task-owner-number", 42),
):
_insert_definition(
engine,
id=task_id,
definition_type="scheduled",
name=task_id,
session_id="ses-owner",
metadata_json=json.dumps(
{"created_by": {"caller": {"session_id": owner_value}}}
),
)
with engine.connect() as conn:
owner_items = derive_session_harness_activities(conn, "ses-owner")
execution_items = derive_session_harness_activities(conn, "ses-execution")
assert {item["id"] for item in owner_items} == {
"task:task-per-run",
"task:task-command",
"task:task-create-once",
"task:task-legacy",
"task:task-owner-object",
"task:task-owner-number",
}
assert {item["id"] for item in execution_items} == set()
def test_definition_banner_falls_back_to_live_target_when_owner_is_gone(tmp_path: Path):
"""Orphaned Owner provenance falls back to the live execution target."""
engine, _ = _make_engine(tmp_path)
with engine.begin() as conn:
create_agent_session_row(
conn,
scope_id=None,
session_id="ses-execution",
session_anchor="banner-execution",
agent_backend="codex",
workdir="/tmp",
now=_NOW,
)
create_agent_session_row(
conn,
scope_id=None,
session_id="ses-archived-owner",
session_anchor="banner-archived-owner",
agent_backend="codex",
workdir="/tmp",
status="archived",
now=_NOW,
)
for task_id, owner_session_id in (
("task-missing-owner", "ses-removed-owner"),
("task-archived-owner", "ses-archived-owner"),
):
_insert_definition(
engine,
id=task_id,
definition_type="scheduled",
name=task_id,
session_id="ses-execution",
metadata_json=json.dumps(
{"created_by": {"caller": {"session_id": owner_session_id}}}
),
)
with engine.connect() as conn:
execution_items = derive_session_harness_activities(conn, "ses-execution")
assert {item["id"] for item in execution_items} == {
"task:task-missing-owner",
"task:task-archived-owner",
}
def test_owner_session_teardown_reclaims_task_even_when_execution_target_differs(
tmp_path: Path,
):
"""Teardown covers both the managing owner and a dying execution target."""
engine, _ = _make_engine(tmp_path)
owner_metadata = json.dumps(
{"created_by": {"caller": {"session_id": "ses-owner"}}}
)
foreign_owner_metadata = json.dumps(
{"created_by": {"caller": {"session_id": "ses-other"}}}
)
with engine.begin() as conn:
create_agent_session_row(
conn,
scope_id=None,
session_id="ses-owner",
session_anchor="anchor-owner",
agent_backend="codex",
workdir="/tmp",
now=_NOW,
)
create_agent_session_row(
conn,
scope_id=None,
session_id="ses-execution",
session_anchor="anchor-execution",
agent_backend="codex",
workdir="/tmp",
now=_NOW,
)
_insert_definition(
engine,
id="task-owner-targeted",
definition_type="scheduled",
name="owner-targeted",
session_id="ses-execution",
metadata_json=owner_metadata,
)
_insert_definition(
engine,
id="task-target-only",
definition_type="scheduled",
name="target-only",
session_id="ses-execution",
metadata_json=foreign_owner_metadata,
)
with engine.begin() as conn:
assert count_bound_resources(conn, "ses-owner")["tasks"] == 1
summary = reclaim_bound_definitions(
conn,
"ses-owner",
mode=RECLAIM_DELETE,
reason="archive_session:ses-owner",
)
row = conn.execute(
select(run_definitions.c.deleted_at).where(
run_definitions.c.id == "task-owner-targeted"
)
).scalar_one()
assert count_bound_resources(conn, "ses-execution")["tasks"] == 1
target_summary = reclaim_bound_definitions(
conn,
"ses-execution",
mode=RECLAIM_DELETE,
reason="archive_session:ses-execution",
)
target_row = conn.execute(
select(run_definitions.c.deleted_at).where(
run_definitions.c.id == "task-target-only"
)
).scalar_one()
assert summary["deleted"] == 1
assert row is not None
assert target_summary["deleted"] == 1
assert target_row is not None
def test_owner_session_pause_marks_unbound_task_as_not_resumable(tmp_path: Path):
"""Live /new teardown and upgrade reconciliation share one resume policy."""
engine, _ = _make_engine(tmp_path)
with engine.begin() as conn:
create_agent_session_row(
conn,
scope_id=None,
session_id="ses-owner",
session_anchor="anchor-owner",
agent_backend="codex",
workdir="/tmp",
now=_NOW,
)
_insert_definition(
engine,
id="task-owner-only",
definition_type="scheduled",
name="owner-only",
session_id=" ",
metadata_json=json.dumps(
{"created_by": {"caller": {"session_id": "ses-owner"}}}
),
)
with engine.begin() as conn:
summary = reclaim_bound_definitions(
conn,
"ses-owner",
mode=RECLAIM_PAUSE,
reason="session cleared by /new",
)
row = (
conn.execute(
select(
run_definitions.c.enabled,
run_definitions.c.session_id,
run_definitions.c.metadata_json,
).where(run_definitions.c.id == "task-owner-only")
)
.mappings()
.one()
)
metadata = json.loads(row["metadata_json"])
assert summary["paused"] == 1
assert row["enabled"] == 0
assert task_resume_block(metadata, row["session_id"]) == {
"code": "task_owner_session_unavailable",
"owner_session_id": "ses-owner",
}
def test_archived_owner_teardown_reclaims_task_by_creation_provenance(tmp_path: Path):
"""Teardown still uses archived Owner identity even though projection falls back."""
engine, _ = _make_engine(tmp_path)
owner_metadata = json.dumps(
{"created_by": {"caller": {"session_id": "ses-archived-owner"}}}
)
with engine.begin() as conn:
create_agent_session_row(
conn,
scope_id=None,
session_id="ses-archived-owner",
session_anchor="archive-owner",
agent_backend="codex",
workdir="/tmp",
status="archived",
now=_NOW,
)
_insert_definition(
engine,
id="task-archived-owner",
definition_type="scheduled",
name="archived-owner",
session_id="ses-execution",
metadata_json=owner_metadata,
)
with engine.begin() as conn:
assert count_bound_resources(conn, "ses-archived-owner")["tasks"] == 1
summary = reclaim_bound_definitions(
conn,
"ses-archived-owner",
mode=RECLAIM_DELETE,
reason="archive_session:ses-archived-owner",
)
deleted_at = conn.execute(
select(run_definitions.c.deleted_at).where(
run_definitions.c.id == "task-archived-owner"
)
).scalar_one()
assert summary["deleted"] == 1
assert deleted_at is not None
def test_excludes_disabled_deleted_and_foreign_and_terminal(tmp_path: Path):
engine, _ = _make_engine(tmp_path)
# Disabled watch: paused, not ongoing background work.
_insert_definition(
engine, id="w-off", definition_type="watch", session_id="ses-1", enabled=0
)
# Soft-deleted task.
_insert_definition(
engine,
id="t-del",
definition_type="scheduled",
session_id="ses-1",
deleted_at=_NOW,
)
# Watch bound to a different session.
_insert_definition(
engine, id="w-other", definition_type="watch", session_id="ses-2"
)
# Delegated run whose callback returns to a different session.
_insert_run(
engine, id="r-other", callback_session_id="ses-2", session_id="ses-x"
)
# Terminal delegated run (already finished) — not pending work.
_insert_run(
engine,
id="r-done",
status="succeeded",
callback_session_id="ses-1",
session_id="ses-x",
)
with engine.connect() as conn:
items = derive_session_harness_activities(conn, "ses-1")
assert items == []
def test_self_run_is_not_counted_as_dispatched_work(tmp_path: Path):
# A run whose callback target equals its execution session is the session's
# own turn (reported via ``foreground``), not delegated background work.
engine, _ = _make_engine(tmp_path)
_insert_run(
engine, id="r-self", callback_session_id="ses-1", session_id="ses-1"
)
with engine.connect() as conn:
items = derive_session_harness_activities(conn, "ses-1")
assert items == []
def test_sync_run_without_pending_callback_is_excluded(tmp_path: Path):
# A synchronous ``--sync`` delegated run carries callback_session_id but a
# null callback_status (caller waits inline; no callback owed), so it is NOT
# background work this session is waiting on.
engine, _ = _make_engine(tmp_path)
_insert_run(
engine,
id="r-sync",
callback_session_id="ses-1",
session_id="ses-delegate",
callback_status=None,
)
with engine.connect() as conn:
items = derive_session_harness_activities(conn, "ses-1")
assert items == []
def test_a_watch_a_delegated_run_left_stays_after_the_run_answers(tmp_path: Path):
# The PM dispatched a worker; the worker answered ("the Watch will continue")
# and left a forever Watch on review and CI in its own session. The run is
# finished, but the work it dispatched is not, so the PM still sees it, routed
# to the worker's session (where the Harness filter finds it).
engine, _ = _make_engine(tmp_path)
_insert_run(
engine,
id="run-worker",
agent_name="claude",
status="succeeded",
callback_status="sent",
session_id="ses-worker",
callback_session_id="ses-pm",
)
created_by = {"created_by": {"kind": "caller_context", "caller": {"session_id": "ses-worker", "run_id": "run-worker"}}}
_insert_definition(
engine,
id="w-review",
definition_type="watch",
name="pr-2821 review",
session_id="ses-worker",
metadata_json=json.dumps(created_by),
)
# Not this session's work: a Watch the worker removed or paused, and one left
# by a run another session dispatched.
_insert_definition(engine, id="w-removed", definition_type="watch", session_id="ses-worker", deleted_at=_NOW, metadata_json=json.dumps(created_by))
_insert_definition(engine, id="w-paused", definition_type="watch", session_id="ses-worker", enabled=0, metadata_json=json.dumps(created_by))
_insert_run(engine, id="run-other", status="succeeded", session_id="ses-worker", callback_session_id="ses-other")
_insert_definition(
engine,
id="w-foreign",
definition_type="watch",
session_id="ses-worker",
metadata_json=json.dumps({"created_by": {"caller": {"session_id": "ses-worker", "run_id": "run-other"}}}),
)
_insert_definition(engine, id="w-unreadable", definition_type="watch", session_id="ses-worker", metadata_json="not json")
with engine.connect() as conn:
items = derive_session_harness_activities(conn, "ses-pm")
assert [(item["id"], item["label"], item["session_id"], item["status"]) for item in items] == [
("watch:w-review", "claude: pr-2821 review", "ses-worker", "enabled"),
]
def test_delegated_watches_are_read_through_live_definitions_only(tmp_path: Path):
# The banner is re-read on every runtime-state build. A removed Watch keeps
# ``enabled = 1``, so seeking (definition_type, enabled) alone walks every Watch
# ever removed; the read must touch live definitions and each creator Run by
# its key, never a scan of either growing table.
import sqlite3
from sqlalchemy import event
engine, db_path = _make_engine(tmp_path)
_insert_run(engine, id="run-worker", status="succeeded", session_id="ses-worker", callback_session_id="ses-pm")
for index in range(20):
_insert_definition(engine, id=f"w-removed-{index}", definition_type="watch", session_id="ses-worker", deleted_at=_NOW)
captured: list[tuple[str, object]] = []
def capture(conn, cursor, statement, parameters, context, executemany):
if "json_extract" in statement and "agent_runs" in statement:
captured.append((statement, parameters))
event.listen(engine, "before_cursor_execute", capture)
try:
with engine.connect() as conn:
derive_session_harness_activities(conn, "ses-pm")
finally:
event.remove(engine, "before_cursor_execute", capture)
[(statement, parameters)] = captured
raw = sqlite3.connect(str(db_path))
try:
plan = "\n".join(row[-1] for row in raw.execute("EXPLAIN QUERY PLAN " + statement, parameters))
finally:
raw.close()
assert "SEARCH run_definitions USING INDEX ix_run_definitions_live (definition_type=? AND enabled=?)" in plan, plan
assert "SEARCH agent_runs USING INDEX sqlite_autoindex_agent_runs_1 (id=?)" in plan, plan
assert "SCAN" not in plan.replace("USE TEMP B-TREE", ""), plan
def test_items_derive_from_db_so_banner_survives_restart(tmp_path: Path):
# The registry is process-local and empty after a restart; harness items must
# come from the durable store. Simulate a restart by disposing the engine and
# opening a fresh one on the same DB file — the item must still derive.
engine, db_path = _make_engine(tmp_path)
_insert_definition(
engine, id="watch-r", definition_type="watch", name="w", session_id="ses-1"
)
engine.dispose()
reopened = create_sqlite_engine(db_path)
with reopened.connect() as conn:
items = derive_session_harness_activities(conn, "ses-1")
assert [item["id"] for item in items] == ["watch:watch-r"]
assert items[0]["item_kind"] == "watch"
def test_turn_state_unions_backend_activities_and_harness_items(tmp_path: Path):
# End-to-end at the assembly point: registry backend activity + DB-derived
# harness items land in one ``background_activities`` list, tagged by kind.
engine, _ = _make_engine(tmp_path)
_insert_definition(
engine, id="watch-u", definition_type="watch", name="w", session_id="ses-1"
)
_insert_run(
engine,
id="run-u",
agent_name="worker",
message="go",
session_id="ses-delegate",
callback_session_id="ses-1",
)
registry = SessionActivityRegistry()
registry.start(
backend="claude",
runtime_key="runtime-1",
session_id="ses-1",
activity_id="bg-1",
kind="background_task",
description="Running checks",
)
manager = SessionTurnManager(
controller=SimpleNamespace(agent_service=SimpleNamespace(activities=registry))
)
manager._engine = engine
state = manager.turn_state("ses-1")
activities = state["background_activities"]
kinds = [item["item_kind"] for item in activities]
assert kinds.count("backend_activity") == 1
assert kinds.count("watch") == 1
assert kinds.count("agent_run") == 1
backend_item = next(i for i in activities if i["item_kind"] == "backend_activity")
assert backend_item["id"] == "bg-1"
assert backend_item["label"] == "Running checks"
assert backend_item["since"] == backend_item["started_at"]
def test_turn_state_survives_harness_derivation_failure(tmp_path: Path):
# A harness query failure must degrade to registry-only activities, never
# break the turn-state payload.
registry = SessionActivityRegistry()
registry.start(
backend="claude",
runtime_key="runtime-1",
session_id="ses-1",
activity_id="bg-1",
kind="background_task",
)
manager = SessionTurnManager(
controller=SimpleNamespace(agent_service=SimpleNamespace(activities=registry))
)
# A bare object() as the connection makes derive_session_harness_activities
# raise inside turn_state's guarded block.
manager._engine = SimpleNamespace(begin=lambda: nullcontext(object()))
import core.session_turns as session_turns
original = session_turns.delivery_store.list_queued
session_turns.delivery_store.list_queued = lambda conn, sid: []
try:
state = manager.turn_state("ses-1")
finally:
session_turns.delivery_store.list_queued = original
assert [item["id"] for item in state["background_activities"]] == ["bg-1"]
assert state["background_activities"][0]["item_kind"] == "backend_activity"
def test_banner_enabled_pref_round_trip(tmp_path: Path):
# Global toggle (spec req 2): default ON, persisted in state_meta, hermetic
# via explicit db_path (never touches real state).
from core.workbench_prefs import (
get_background_work_banner_enabled,
set_background_work_banner_enabled,
)
db_path = tmp_path / "state" / "vibe.sqlite"
ensure_sqlite_state(db_path=db_path, primary_platform="avibe")
assert get_background_work_banner_enabled(db_path=db_path) is True # default ON
assert set_background_work_banner_enabled(False, db_path=db_path) is False
assert get_background_work_banner_enabled(db_path=db_path) is False
assert set_background_work_banner_enabled(True, db_path=db_path) is True
assert get_background_work_banner_enabled(db_path=db_path) is True
def test_definition_session_filter_scopes_watches_and_tasks_by_owner(tmp_path: Path):
# The Harness "只看本会话" chip follows the same creation-owner rule as
# the banner. Legacy definitions without provenance still use their bound
# session as the fallback.
engine, db_path = _make_engine(tmp_path)
with engine.begin() as conn:
for session_id, session_anchor in (("ses-A", "filter-a"), ("ses-B", "filter-b")):
create_agent_session_row(
conn,
scope_id=None,
session_id=session_id,
session_anchor=session_anchor,
agent_backend="codex",
workdir="/tmp",
now=_NOW,
)
_insert_definition(engine, id="w-a", definition_type="watch", name="wa", session_id="ses-A")
_insert_definition(engine, id="w-b", definition_type="watch", name="wb", session_id="ses-B")
_insert_definition(
engine,
id="w-callback-wins",
definition_type="watch",
name="wc",
session_id="ses-B",
metadata_json=json.dumps(
{"created_by": {"caller": {"session_id": "ses-A"}}}
),
)
_insert_definition(engine, id="t-a", definition_type="scheduled", name="ta", session_id="ses-A")
_insert_definition(engine, id="t-b", definition_type="scheduled", name="tb", session_id="ses-B")
owner_metadata = json.dumps(
{"created_by": {"caller": {"session_id": "ses-A"}}}
)
_insert_definition(
engine,
id="t-owner-only",
definition_type="scheduled",
name="owner-only",
session_id=None,
metadata_json=owner_metadata,
)
_insert_definition(
engine,
id="t-owner-wins",
definition_type="scheduled",
name="owner-wins",
session_id="ses-B",
metadata_json=owner_metadata,
)
_insert_definition(
engine,
id="t-orphan-owner",
definition_type="scheduled",
name="orphan-owner",
session_id="ses-B",
metadata_json=json.dumps(
{"created_by": {"caller": {"session_id": "ses-removed"}}}
),
)
store = SQLiteBackgroundTaskStore(db_path=db_path)
try:
watches_a = store.list_watches_page(session_id="ses-A", page_request=None)
assert [w["id"] for w in watches_a.items] == ["w-a"]
watches_b = store.list_watches_page(session_id="ses-B", page_request=None)
assert {w["id"] for w in watches_b.items} == {"w-b", "w-callback-wins"}
tasks_a = store.list_scheduled_tasks_page(session_id="ses-A", page_request=None)
assert {t["id"] for t in tasks_a.items} == {"t-a", "t-owner-only", "t-owner-wins"}
tasks_b = store.list_scheduled_tasks_page(session_id="ses-B", page_request=None)
assert {t["id"] for t in tasks_b.items} == {"t-b", "t-orphan-owner"}
assert store.count_watches(session_id="ses-A")["total"] == 1
assert store.count_scheduled_tasks(session_id="ses-B")["total"] == 2
# No filter → both sessions' definitions are returned.
assert len(store.list_watches_page(page_request=None).items) == 3
assert len(store.list_scheduled_tasks_page(page_request=None).items) == 5
finally:
store.close()