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
from __future__ import annotations
import hashlib
import json
import pytest
from sqlalchemy import select
from config.v2_config import V2Config
from storage import resource_access_service
from storage.background import SQLiteBackgroundTaskStore
from storage.db import create_sqlite_engine
from storage.message_deliveries import enqueue_queued
from storage.migrations import run_migrations
from storage.models import agent_runs, agent_sessions, message_deliveries, resource_access_policies, run_definitions, state_meta
from vibe import permissions
def _context(
subject: str,
*,
organization_id: str | None = "org-1",
group_ids: frozenset[str] | None = frozenset(),
role: str | None = "member",
instance_role: str = "editor",
access_source: str = "organization_group",
instance_kind: str | None = None,
) -> resource_access_service.ResourceUserContext:
return resource_access_service.ResourceUserContext(
subject=subject,
organization_id=organization_id,
organization_member_id="member-1" if organization_id else None,
organization_role=role,
group_ids=group_ids,
instance_role=instance_role,
instance_access_source=access_source,
is_remote=True,
instance_kind=instance_kind,
)
def _seed_policies(connection) -> None:
resource_access_service.ensure_resource_policy(
connection,
resource_kind="agent",
resource_id="private-agent",
organization_id="org-1",
owner_user_id="owner-1",
access_level="private",
)
resource_access_service.ensure_resource_policy(
connection,
resource_kind="agent",
resource_id="public-agent",
organization_id="org-1",
owner_user_id="owner-1",
access_level="public",
)
resource_access_service.ensure_resource_policy(
connection,
resource_kind="agent",
resource_id="scoped-agent",
organization_id="org-1",
owner_user_id="owner-1",
access_level="scope",
group_ids=["group-engineering"],
)
def test_resource_acl_is_enforced_for_editors_and_unknown_kinds_fail_closed(tmp_path, sqlite_schema_db_factory) -> None:
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
engine = create_sqlite_engine(db)
try:
with engine.begin() as connection:
_seed_policies(connection)
owner = _context("owner-1", instance_role="owner", access_source="owner")
engineering_member = _context("member-2", group_ids=frozenset({"group-engineering"}))
member_without_groups = _context("member-3", group_ids=None)
member_other_group = _context("member-4", group_ids=frozenset({"group-sales"}))
outside_org = _context("member-5", organization_id="org-2", group_ids=frozenset({"group-engineering"}))
assert resource_access_service.can_use_resource(owner, "agent", "private-agent", connection=connection)
assert resource_access_service.can_use_resource(owner, "agent", "public-agent", connection=connection) is True
assert resource_access_service.can_use_resource(engineering_member, "agent", "scoped-agent", connection=connection)
assert not resource_access_service.can_use_resource(member_without_groups, "agent", "scoped-agent", connection=connection)
assert not resource_access_service.can_use_resource(member_other_group, "agent", "scoped-agent", connection=connection)
assert not resource_access_service.can_use_resource(outside_org, "agent", "public-agent", connection=connection)
with pytest.raises(resource_access_service.ResourceAccessError, match="invalid_resource_kind"):
resource_access_service.can_use_resource(
engineering_member, "future_resource", "future-1", connection=connection
)
finally:
engine.dispose()
def test_personal_editor_uses_all_agents_without_organization_acl(tmp_path, sqlite_schema_db_factory) -> None:
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
engine = create_sqlite_engine(db)
try:
with engine.begin() as connection:
_seed_policies(connection)
personal_editor = _context(
"personal-user",
organization_id=None,
role=None,
access_source="owner",
instance_kind="personal",
)
organization_editor = _context(
"organization-user",
instance_kind="organization",
)
assert resource_access_service.can_use_resource(
personal_editor, "agent", "private-agent", connection=connection
)
assert resource_access_service.can_use_resource(
personal_editor, "agent", "scoped-agent", connection=connection
)
assert resource_access_service.can_use_resource(
personal_editor, "agent", "unmanaged-agent", connection=connection
)
assert resource_access_service.filter_accessible_resources(
personal_editor,
"agent",
[
{"id": "private-agent"},
{"id": "scoped-agent"},
{"id": "unmanaged-agent"},
],
connection=connection,
) == [
{"id": "private-agent"},
{"id": "scoped-agent"},
{"id": "unmanaged-agent"},
]
assert not resource_access_service.can_use_resource(
organization_editor, "agent", "private-agent", connection=connection
)
finally:
engine.dispose()
def test_show_page_is_no_longer_a_resource_kind(monkeypatch, tmp_path, sqlite_schema_db_factory) -> None:
"""§3.2 retired show_page from the Resource ACL: every entry point fails
closed with ``invalid_resource_kind`` and nothing reads or writes a
``resource_access_policies`` row for it.
"""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
engine = create_sqlite_engine(db)
owner = _context("owner-1", instance_role="owner", access_source="owner")
try:
with engine.begin() as connection:
with pytest.raises(resource_access_service.ResourceAccessError, match="invalid_resource_kind"):
resource_access_service.ensure_resource_policy(
connection,
resource_kind="show_page",
resource_id="legacy-page",
organization_id=None,
owner_user_id="owner-1",
access_level="private",
)
with engine.connect() as connection:
for call in (
lambda: resource_access_service.can_use_resource(
owner, "show_page", "legacy-page", connection=connection
),
lambda: resource_access_service.can_manage_resource_acl(
owner, "show_page", "legacy-page", connection=connection
),
lambda: resource_access_service.can_control_resource_sharing(
owner, "show_page", "legacy-page", connection=connection
),
lambda: resource_access_service.filter_accessible_resources(
owner,
"show_page",
[{"session_id": "legacy-page"}],
connection=connection,
),
lambda: resource_access_service.get_resource_policy(
"show_page", "legacy-page", connection=connection
),
):
with pytest.raises(resource_access_service.ResourceAccessError, match="invalid_resource_kind"):
call()
assert "show_page" not in resource_access_service.RESOURCE_KINDS
finally:
engine.dispose()
def _insert_legacy_show_page_policy(connection, *, organization_id: str | None, resource_id: str = "legacy-page") -> None:
"""Write a retired-kind policy row exactly as an older release shipped it."""
now = "2026-07-27T20:00:00.000000+00:00"
connection.execute(
resource_access_policies.insert().values(
resource_kind="show_page",
resource_id=resource_id,
organization_id=organization_id,
owner_user_id="owner-1",
owner_email=None,
access_level="public",
created_by_user_id="owner-1",
updated_by_user_id="owner-1",
policy_revision=1,
last_applied_control_plane_revision=1,
created_at=now,
updated_at=now,
)
)
def test_retired_show_page_rows_stay_inert_in_unscoped_queries(tmp_path, sqlite_schema_db_factory) -> None:
"""§3.2 kept legacy ``show_page`` policy rows in place for load safety, but
unscoped queries must not resurrect them: neither the sync organization
enumeration nor an unscoped policy listing may surface a retired kind.
"""
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
engine = create_sqlite_engine(db)
try:
with engine.begin() as connection:
_seed_policies(connection)
_insert_legacy_show_page_policy(connection, organization_id="legacy-org")
with engine.connect() as connection:
# The row is present on disk, so any exclusion below is a query
# filter, not a failed insert.
retained = connection.execute(
resource_access_policies.select().where(
resource_access_policies.c.resource_kind == "show_page"
)
).mappings().all()
assert len(retained) == 1
assert resource_access_service.list_resource_organization_ids(connection=connection) == ["org-1"]
policies = resource_access_service.list_resource_policies(connection=connection)
assert [policy["resource_kind"] for policy in policies] == [
"agent",
"agent",
"agent",
]
assert all(policy["organization_id"] == "org-1" for policy in policies)
finally:
engine.dispose()
def test_show_page_instance_ownership_fence_survives_config_failure(
monkeypatch,
tmp_path,
) -> None:
"""The pairing fence moved to ``vibe.permissions`` and still fails closed
to ``configuration_unavailable`` when the config cannot be loaded.
"""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
V2Config.default().save()
def fail_load(_cls, *_args, **_kwargs):
raise OSError("config unavailable")
monkeypatch.setattr(V2Config, "load", classmethod(fail_load))
resolved = permissions.resolve_current_instance_ownership()
assert resolved["mode"] == permissions.SHOW_PAGE_OWNERSHIP_CONFIGURATION_UNAVAILABLE
assert resolved["organization_id"] is None
def test_show_page_instance_ownership_is_unmanaged_without_pairing(
monkeypatch,
tmp_path,
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
V2Config.default().save()
ownership = permissions.current_show_page_instance_ownership()
assert ownership == {
"mode": "unmanaged",
"instance_id": None,
"organization_id": None,
"source": "config",
}
@pytest.mark.parametrize(
("previous_level", "previous_groups", "updated_level", "updated_groups", "expected"),
[
("public", [], "public", [], False),
("public", [], "scope", ["group-engineering"], True),
("public", [], "private", [], True),
("scope", ["group-engineering"], "public", [], False),
("scope", ["group-engineering"], "scope", ["group-engineering", "group-sales"], False),
("scope", ["group-engineering", "group-sales"], "scope", ["group-engineering"], True),
("scope", ["group-engineering"], "private", [], True),
("private", [], "private", [], False),
("private", [], "public", [], False),
("private", [], "scope", ["group-sales"], True),
],
)
def test_resource_policy_narrowing_matrix(
previous_level: str,
previous_groups: list[str],
updated_level: str,
updated_groups: list[str],
expected: bool,
) -> None:
assert (
resource_access_service.resource_policy_narrowed(
{"access_level": previous_level, "group_ids": previous_groups},
{"access_level": updated_level, "group_ids": updated_groups},
)
is expected
)
def test_active_org_members_can_use_legacy_resources_without_forging_local_identity(tmp_path, sqlite_schema_db_factory) -> None:
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
engine = create_sqlite_engine(db)
try:
with engine.connect() as connection:
member = _context("member-1", group_ids=frozenset({"group-engineering"}))
owner = _context("owner-1", instance_role="owner", access_source="owner")
diagnostic_owner = _context("member-2", instance_role="viewer", access_source="owner")
non_member_owner = _context(
"legacy-owner",
organization_id=None,
role=None,
instance_role="owner",
access_source="owner",
)
local = resource_access_service.instance_owner_context()
assert not resource_access_service.can_use_resource(member, "agent", "legacy-agent", connection=connection)
assert resource_access_service.can_use_resource(owner, "agent", "legacy-agent", connection=connection)
assert not resource_access_service.can_use_resource(
diagnostic_owner, "agent", "legacy-agent", connection=connection
)
assert resource_access_service.can_use_resource(
non_member_owner, "agent", "legacy-agent", connection=connection
)
assert resource_access_service.can_use_resource(local, "agent", "legacy-agent", connection=connection)
finally:
engine.dispose()
def test_non_member_role_rank_does_not_bypass_organization_resource_acl(tmp_path, sqlite_schema_db_factory) -> None:
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
engine = create_sqlite_engine(db)
try:
with engine.begin() as connection:
_seed_policies(connection)
resource_access_service.ensure_resource_policy(
connection,
resource_kind="agent",
resource_id="personal-agent",
organization_id=None,
owner_user_id="owner-1",
access_level="private",
)
removed_owner = _context(
"owner-1",
organization_id=None,
role=None,
instance_role="owner",
access_source="email_invitation",
)
assert resource_access_service.can_use_resource(
removed_owner, "agent", "private-agent", connection=connection
)
assert resource_access_service.can_manage_resource_acl(
removed_owner, "agent", "private-agent", connection=connection
)
# Direct service calls retain ordinary role plus resource-policy
# semantics; HTTP admission rejects this non-member before runtime
# APIs can reach the service.
assert resource_access_service.can_use_resource(
removed_owner, "agent", "personal-agent", connection=connection
)
assert resource_access_service.can_manage_resource_acl(
removed_owner, "agent", "personal-agent", connection=connection
)
finally:
engine.dispose()
def test_request_context_resolution_failure_does_not_become_trusted_local(monkeypatch) -> None:
from vibe.ui_server import app
monkeypatch.setattr(
resource_access_service,
"current_resource_context",
lambda *args, **kwargs: resource_access_service.ResourceUserContext(),
)
with app.test_request_context("/api/agents", base_url="https://alex.avibe.bot"):
request_context = resource_access_service.resolve_resource_access_context()
local_context = resource_access_service.resolve_resource_access_context()
assert request_context.is_instance_owner is False
assert local_context.is_instance_owner is True
def test_http_resource_services_reuse_the_parsed_authorization_context() -> None:
from vibe.ui_compat import g
from vibe.ui_server import app
context = _context("member-1")
with app.test_request_context("/api/agents", base_url="https://alex.avibe.bot"):
g.authorization_context = context
assert resource_access_service.current_resource_context() is context
assert resource_access_service.resolve_resource_access_context() is context
def test_deferred_remote_context_remains_valid_past_authorization_refresh_boundary(
monkeypatch,
tmp_path,
) -> None:
from vibe import remote_access
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
config = V2Config.default()
config.remote_access.vibe_cloud.enabled = True
config.remote_access.vibe_cloud.instance_id = "organization-instance"
config.remote_access.vibe_cloud.instance_kind = "organization"
config.remote_access.vibe_cloud.instance_secret = "instance-secret"
config.save()
from storage import remote_access_authorization_service as _auth
started = _auth.begin_instance_binding_transition(
instance_id="organization-instance",
instance_kind="organization",
)
_auth.complete_instance_binding_transition(
instance_id="organization-instance",
instance_kind="organization",
generation=started["generation"],
)
issued_at = 1_700_000_000
context = resource_access_service.ResourceUserContext(
subject="member-1",
organization_id="org-1",
organization_member_id="organization-member-1",
organization_role="member",
group_ids=frozenset({"group-engineering"}),
membership_version="membership-v2",
instance_role="viewer",
instance_access_source="organization_group",
instance_kind="organization",
instance_id="organization-instance",
claims_issued_at=issued_at,
is_remote=True,
)
metadata = resource_access_service.metadata_with_resource_user_context({}, context)
expires_at = issued_at + remote_access.SESSION_AUTHORIZATION_REFRESH_SECONDS
# The refresh boundary is recorded for audit but is no longer a hard
# execution cutoff: durable Harness automation must keep running past the
# creating browser session's refresh window. Active Organization membership
# is re-derived from the signed claims at execution time (avibe#1343 P1).
before = resource_access_service.resource_user_context_from_metadata(
metadata,
now=expires_at - 1,
)
after = resource_access_service.resource_user_context_from_metadata(
metadata,
now=expires_at + 86_400, # well past the 12h refresh window
)
assert before is not None and after is not None
assert before.subject == after.subject == "member-1"
assert after.is_active_organization_member is True
def test_deferred_personal_context_keeps_instance_kind(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
config = V2Config.default()
config.remote_access.vibe_cloud.enabled = True
config.remote_access.vibe_cloud.instance_id = "personal-instance"
config.remote_access.vibe_cloud.instance_kind = "personal"
config.remote_access.vibe_cloud.instance_secret = "instance-secret"
config.save()
from storage import remote_access_authorization_service as _auth
started = _auth.begin_instance_binding_transition(
instance_id="personal-instance",
instance_kind="personal",
)
_auth.complete_instance_binding_transition(
instance_id="personal-instance",
instance_kind="personal",
generation=started["generation"],
)
context = resource_access_service.ResourceUserContext(
subject="personal-user",
instance_id="personal-instance",
instance_role="editor",
instance_access_source="owner",
instance_kind="personal",
is_remote=True,
)
metadata = resource_access_service.metadata_with_resource_user_context({}, context)
restored = resource_access_service.resource_user_context_from_metadata(metadata)
assert restored is not None
assert restored.is_personal_instance
def test_deferred_context_from_previous_pairing_is_rejected(monkeypatch, tmp_path) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
config = V2Config.default()
config.remote_access.vibe_cloud.enabled = True
config.remote_access.vibe_cloud.instance_id = "current-instance"
config.remote_access.vibe_cloud.instance_kind = "organization"
config.remote_access.vibe_cloud.instance_secret = "instance-secret"
config.save()
stale_context = resource_access_service.ResourceUserContext(
subject="personal-user",
instance_id="previous-instance",
instance_role="editor",
instance_access_source="owner",
instance_kind="personal",
is_remote=True,
)
metadata = resource_access_service.metadata_with_resource_user_context({}, stale_context)
assert resource_access_service.resource_user_context_from_metadata(metadata) is None
assert not resource_access_service.metadata_allows_harness_runtime(metadata)
def test_deferred_context_does_not_project_personal_bypass_while_reconciling(
monkeypatch,
tmp_path,
) -> None:
"""Non-interactive metadata must fail closed while the binding is reconciling."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
config = V2Config.default()
config.remote_access.vibe_cloud.enabled = True
config.remote_access.vibe_cloud.instance_id = "current-instance"
config.remote_access.vibe_cloud.instance_kind = "personal"
config.remote_access.vibe_cloud.instance_secret = "instance-secret"
config.save()
from storage import remote_access_authorization_service
from storage.importer import ensure_sqlite_state
ensure_sqlite_state()
remote_access_authorization_service.begin_instance_binding_transition(
instance_id="current-instance",
instance_kind="personal",
)
personal_context = resource_access_service.ResourceUserContext(
subject="personal-user",
instance_id="current-instance",
instance_role="editor",
instance_access_source="owner",
instance_kind="personal",
is_remote=True,
)
metadata = resource_access_service.metadata_with_resource_user_context({}, personal_context)
assert resource_access_service.resource_user_context_from_metadata(metadata) is None
assert not resource_access_service.metadata_allows_harness_runtime(metadata)
@pytest.mark.parametrize("pairing_state", ["disabled", "unreadable", "partial"])
def test_explicit_deferred_context_requires_current_pairing(
monkeypatch,
tmp_path,
pairing_state: str,
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
config = V2Config.default()
config.remote_access.vibe_cloud.enabled = pairing_state != "disabled"
config.remote_access.vibe_cloud.instance_id = "personal-instance"
config.remote_access.vibe_cloud.instance_kind = "personal"
if pairing_state != "partial":
config.remote_access.vibe_cloud.instance_secret = "instance-secret"
config.save()
if pairing_state == "unreadable":
def fail_load(_cls, *_args, **_kwargs):
raise OSError("config unavailable")
monkeypatch.setattr(V2Config, "load", classmethod(fail_load))
context = resource_access_service.ResourceUserContext(
subject="personal-user",
instance_id="personal-instance",
instance_role="editor",
instance_access_source="owner",
instance_kind="personal",
is_remote=True,
)
metadata = resource_access_service.metadata_with_resource_user_context({}, context)
assert resource_access_service.resource_user_context_from_metadata(metadata) is None
assert not resource_access_service.metadata_allows_harness_runtime(metadata)
@pytest.mark.parametrize(
("paired_kind", "expected_kind", "should_restore"),
[
("personal", "personal", False),
("organization", "organization", False),
("", None, True),
],
)
def test_unbound_legacy_deferred_context_cannot_adopt_current_pairing_kind(
monkeypatch,
tmp_path,
paired_kind: str,
expected_kind: str | None,
should_restore: bool,
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
config = V2Config.default()
config.remote_access.vibe_cloud.enabled = True
config.remote_access.vibe_cloud.instance_kind = paired_kind
config.remote_access.vibe_cloud.instance_id = "paired-instance"
config.remote_access.vibe_cloud.instance_secret = "instance-secret"
config.save()
legacy_metadata = {
resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY: {
"sub": "legacy-user",
"vibe_instance_role": "editor",
"vibe_instance_access_source": "email",
"claims_issued_at": 1_700_000_000,
}
}
restored = resource_access_service.resource_user_context_from_metadata(legacy_metadata)
assert (restored is not None) is should_restore
if restored is not None:
assert restored.instance_kind == expected_kind
def test_kindless_deferred_context_adopts_matching_validated_pairing(
monkeypatch,
tmp_path,
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
config = V2Config.default()
config.remote_access.vibe_cloud.enabled = True
config.remote_access.vibe_cloud.instance_id = "paired-instance"
config.remote_access.vibe_cloud.instance_kind = "personal"
config.remote_access.vibe_cloud.instance_secret = "instance-secret"
config.save()
legacy_metadata = {
resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY: {
"sub": "legacy-user",
"vibe_instance_id": "paired-instance",
"vibe_instance_role": "editor",
"vibe_instance_access_source": "owner",
"vibe_instance_kind": None,
"claims_issued_at": 1_700_000_000,
}
}
from storage import remote_access_authorization_service as _auth
started = _auth.begin_instance_binding_transition(
instance_id="paired-instance",
instance_kind="personal",
)
_auth.complete_instance_binding_transition(
instance_id="paired-instance",
instance_kind="personal",
generation=started["generation"],
)
restored = resource_access_service.resource_user_context_from_metadata(legacy_metadata)
assert restored is not None
assert restored.is_personal_instance
@pytest.mark.parametrize(
("paired_kind", "access_source", "organization_claims"),
[
("personal", "owner", False),
("organization", "organization_group", True),
("organization", "email", False),
],
)
@pytest.mark.parametrize(("instance_role", "completed_marker"), [("editor", False), ("member", False), ("member", True)])
def test_migrate_legacy_deferred_contexts_binds_definitions_and_queued_deliveries(
monkeypatch,
tmp_path,
paired_kind: str,
access_source: str,
organization_claims: bool, sqlite_schema_db_factory, instance_role, completed_marker,
) -> None:
"""PERMISSIONS-014: released metadata reaches Harness and queued-chat consumers."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
config = V2Config.default()
config.remote_access.vibe_cloud.enabled = True
config.remote_access.vibe_cloud.instance_id = "paired-instance"
config.remote_access.vibe_cloud.instance_kind = paired_kind
config.remote_access.vibe_cloud.instance_secret = "instance-secret"
config.save()
legacy_context = {
"sub": "legacy-user α",
"vibe_instance_role": instance_role,
"vibe_instance_access_source": access_source,
"claims_issued_at": 1_700_000_000,
}
if organization_claims:
legacy_context.update(
{
"vibe_organization_id": "org-1",
"vibe_organization_member_id": "member-1",
"vibe_organization_role": "member",
"vibe_group_ids": ["group-1"],
}
)
legacy_metadata = {resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY: legacy_context}
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
store = SQLiteBackgroundTaskStore(db)
engine = create_sqlite_engine(db)
try:
assert store.upsert_scheduled_task(
{
"id": "legacy-task",
"name": "legacy task",
"message": "run",
"schedule_type": "interval",
"created_at": "2026-08-20T00:00:00Z",
"updated_at": "2026-08-20T00:00:00Z",
"metadata": legacy_metadata,
}
)
assert store.upsert_watch(
{
"id": "legacy-watch",
"name": "legacy watch",
"message": "watch",
"created_at": "2026-08-20T00:00:00Z",
"updated_at": "2026-08-20T00:00:00Z",
"metadata": legacy_metadata,
}
)
assert store.enqueue_definition_run(
{
"id": "run-1",
"definition_id": "legacy-task",
"run_type": "scheduled",
"source_kind": "scheduler",
"prompt": "run",
"message": "run",
"created_at": "2026-08-20T00:00:00Z",
"updated_at": "2026-08-20T00:00:00Z",
"metadata": legacy_metadata,
}
) is not None
with engine.begin() as connection:
connection.execute(
agent_sessions.insert().values(
id="session-1",
scope_id=None,
agent_id=None,
agent_name="default",
agent_backend="opencode",
agent_variant="default",
model=None,
reasoning_effort=None,
session_anchor="anchor-1",
workdir=None,
native_session_id="native-1",
title=None,
status="active",
visibility="foreground",
pinned=0,
agent_status="idle",
composer_draft_text=None,
composer_draft_updated_at=None,
metadata_json="{}",
created_at="2026-08-20T00:00:00Z",
updated_at="2026-08-20T00:00:00Z",
last_active_at=None,
)
)
enqueue_queued(
connection,
scope_id=None,
session_id="session-1",
text="queued",
metadata=legacy_metadata,
now="2026-08-20T00:00:00Z",
)
from storage.importer import _run_sqlite_data_migrations
_seed_ready_binding(connection, instance_id="paired-instance", instance_kind=paired_kind)
if completed_marker:
connection.execute(state_meta.insert().values(
key=resource_access_service.LEGACY_DEFERRED_CONTEXT_MIGRATION_KEY,
value_json=json.dumps({
"schema_version": 2, "state": "completed", "instance_id": "paired-instance",
"instance_kind": paired_kind, "completed_at": "2026-08-21T00:00:00Z",
}), updated_at="2026-08-21T00:00:00Z",
))
counts = _run_sqlite_data_migrations(connection)
assert _migration_counts(counts) == {
"legacy_deferred_definitions": 2,
"legacy_deferred_runs": 1,
"legacy_deferred_deliveries": 1,
}
definition_rows = connection.execute(
select(run_definitions.c.metadata_json).where(
run_definitions.c.id.in_(("legacy-task", "legacy-watch"))
)
).scalars()
for raw_metadata in definition_rows:
metadata = json.loads(raw_metadata)
snapshot = metadata[resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY]
assert snapshot["vibe_instance_id"] == "paired-instance"
assert snapshot["vibe_instance_kind"] == paired_kind
from storage import remote_access_authorization_service as _auth
started = _auth.begin_instance_binding_transition(
instance_id="paired-instance",
instance_kind=paired_kind,
)
_auth.complete_instance_binding_transition(
instance_id="paired-instance",
instance_kind=paired_kind,
generation=started["generation"],
)
restored = resource_access_service.resource_user_context_from_metadata(metadata)
assert restored is not None and restored.instance_role == instance_role
assert restored.subject == "legacy-user α"
assert resource_access_service.metadata_allows_harness_runtime(metadata)
run_metadata = connection.execute(
select(agent_runs.c.metadata_json).where(agent_runs.c.definition_id == "legacy-task")
).scalar_one()
run_snapshot = json.loads(run_metadata)[
resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY
]
assert run_snapshot["vibe_instance_id"] == "paired-instance"
assert run_snapshot["vibe_instance_kind"] == paired_kind
assert resource_access_service.metadata_allows_harness_runtime(json.loads(run_metadata))
delivery = connection.execute(
select(message_deliveries).where(
message_deliveries.c.session_id == "session-1"
)
).mappings().one()
snapshot = json.loads(delivery["snapshot_json"])
metadata = json.loads(snapshot["metadata_json"])
assert metadata[resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY][
"vibe_instance_id"
] == "paired-instance"
assert metadata[resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY][
"vibe_instance_kind"
] == paired_kind
assert delivery["snapshot_sha256"] == hashlib.sha256(
delivery["snapshot_json"].encode("utf-8")
).hexdigest()
if instance_role == "member":
from core.session_turns import SessionTurnManager
assert SessionTurnManager._remote_delivery_execution_denial(connection, dict(delivery)) is None
marker_after = _stored_migration_marker(connection)
if completed_marker:
assert json.loads(marker_after)["completed_at"] == "2026-08-21T00:00:00Z"
# A later imported/unbound row is not a new migration opportunity.
enqueue_queued(connection, scope_id=None, session_id="session-1", text="later", metadata=legacy_metadata)
assert _migration_counts(_run_sqlite_data_migrations(
connection
)) == {
"legacy_deferred_definitions": 0,
"legacy_deferred_runs": 0,
"legacy_deferred_deliveries": 0,
}
assert _stored_migration_marker(connection) == marker_after
later = connection.execute(select(message_deliveries).where(message_deliveries.c.id != delivery["id"])).mappings().one()
assert "vibe_instance_id" not in json.loads(json.loads(later["snapshot_json"])["metadata_json"])[
resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY
]
finally:
store.close()
engine.dispose()
@pytest.mark.parametrize("case", [
"sealed", "missing_kind", "invalid_kind", "other_instance", "other_kind",
"corrupt", "unknown_state", "unknown_version", "missing_cutoff", "invalid_cutoff",
"naive_cutoff", "reconciling", "binding_mismatch", "binding_absent",
"snapshot_instance", "snapshot_kind", "snapshot_unknown_kind", "snapshot_org", "editor",
"new_row", "changed_row", "equal_second", "invalid_timestamp",
])
def test_completed_member_repair_preserves_unproven_rows(monkeypatch, tmp_path, sqlite_schema_db_factory, case):
"""PERMISSIONS-014: a completed marker cannot attribute later or foreign work."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
_paired_cloud_config(tmp_path)
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
engine = create_sqlite_engine(db)
old = "2026-08-20T00:00:00Z"
cutoff = "2026-08-21T00:00:00Z"
marker = {
"schema_version": 2, "state": "completed", "instance_id": "same-instance",
"instance_kind": "personal", "completed_at": cutoff,
}
overrides = {
"sealed": {"state": "sealed_unattributed"},
"missing_kind": {"instance_kind": None},
"invalid_kind": {"instance_kind": "enterprise"},
"other_instance": {"instance_id": "other-instance"},
"other_kind": {"instance_kind": "organization"},
"unknown_state": {"state": "future-state"},
"unknown_version": {"schema_version": 999},
"missing_cutoff": {"completed_at": None},
"invalid_cutoff": {"completed_at": "yesterday"},
"naive_cutoff": {"completed_at": "2026-08-21T00:00:00"},
}
marker.update(overrides.get(case, {}))
marker_json = "corrupt" if case == "corrupt" else json.dumps(marker)
snapshot = {"sub": "legacy-member α", "vibe_instance_role": "member", "vibe_instance_access_source": "email"}
snapshot.update({
"snapshot_instance": {"vibe_instance_id": "other-instance"},
"snapshot_kind": {"vibe_instance_kind": "organization"},
"snapshot_unknown_kind": {"vibe_instance_kind": "enterprise"},
"snapshot_org": {"vibe_organization_id": "old-org"},
"editor": {"vibe_instance_role": "editor"},
}.get(case, {}))
metadata_json = json.dumps({resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY: snapshot})
later = "2026-08-22T00:00:00Z"
created_at = later if case == "new_row" else cutoff if case == "equal_second" else old
updated_at = later if case in {"new_row", "changed_row"} else cutoff if case == "equal_second" else old
if case == "invalid_timestamp":
updated_at = "invalid"
try:
with engine.begin() as conn:
conn.execute(state_meta.insert().values(
key=resource_access_service.LEGACY_DEFERRED_CONTEXT_MIGRATION_KEY,
value_json=marker_json, updated_at=cutoff,
))
if case != "binding_absent":
_seed_ready_binding(conn, instance_id="other" if case == "binding_mismatch" else "same-instance", instance_kind="personal")
if case == "reconciling":
conn.execute(state_meta.update().where(state_meta.c.key == "remote_access.instance_binding.v1").values(
value_json=json.dumps({"schema_version": 1, "state": "reconciling", "instance_id": "same-instance",
"instance_kind": "personal", "generation": 1}),
))
for kind in ("scheduled", "watch"):
conn.execute(run_definitions.insert().values(
id=kind, definition_type=kind, enabled=1, metadata_json=metadata_json,
created_at=created_at, updated_at=updated_at,
))
conn.execute(agent_runs.insert().values(
id="run", run_type="scheduled", status="queued", metadata_json=metadata_json,
created_at=created_at, updated_at=updated_at,
))
conn.execute(agent_sessions.insert().values(
id="session", agent_backend="codex", agent_variant="default", session_anchor="session",
native_session_id="native", status="active", metadata_json="{}", created_at=old, updated_at=old,
))
enqueue_queued(conn, scope_id=None, session_id="session", text="你好", metadata=json.loads(metadata_json), now=created_at)
conn.execute(message_deliveries.update().values(updated_at=updated_at))
tables = (run_definitions, agent_runs, message_deliveries)
before = [[dict(row) for row in conn.execute(select(table)).mappings()] for table in tables]
for _ in range(2):
assert _migration_counts(resource_access_service.migrate_legacy_deferred_resource_contexts(conn)) == _EMPTY_MIGRATION_COUNTS
assert [[dict(row) for row in conn.execute(select(table)).mappings()] for table in tables] == before
if case in overrides or case in {"corrupt", "reconciling", "binding_mismatch", "binding_absent"}:
assert _stored_migration_marker(conn) == marker_json
finally:
engine.dispose()
@pytest.mark.parametrize("completed_marker", [False, True])
def test_member_migration_preserves_terminal_records(monkeypatch, tmp_path, sqlite_schema_db_factory, completed_marker):
"""Queued/reserved work may bind; retired Deliveries and completed Runs stay intact."""
from storage.delivery_states import DELIVERY_STATE_MATRIX
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
_paired_cloud_config(tmp_path)
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
engine = create_sqlite_engine(db)
old = "2026-08-20T00:00:00Z"
metadata = {resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY: {
"sub": "member", "vibe_instance_role": "member", "vibe_instance_access_source": "email",
}}
try:
with engine.begin() as conn:
_seed_ready_binding(conn, instance_id="same-instance", instance_kind="personal")
if completed_marker:
conn.execute(state_meta.insert().values(
key=resource_access_service.LEGACY_DEFERRED_CONTEXT_MIGRATION_KEY,
value_json=json.dumps({"schema_version": 2, "state": "completed", "instance_id": "same-instance",
"instance_kind": "personal", "completed_at": "2026-08-21T00:00:00Z"}), updated_at=old,
))
conn.execute(agent_sessions.insert().values(
id="session", agent_backend="codex", agent_variant="default", session_anchor="session",
native_session_id="native", status="active", metadata_json="{}", created_at=old, updated_at=old,
))
deliveries = {}
for state in ("reserved", "queued", "retired"):
payload = enqueue_queued(conn, scope_id=None, session_id="session", text=state, metadata=metadata, now=old)
delivery_id = payload["id"]
conn.execute(message_deliveries.update().where(message_deliveries.c.id == delivery_id).values(state=state))
deliveries[state] = dict(conn.execute(select(message_deliveries).where(message_deliveries.c.id == delivery_id)).mappings().one())
terminal_run = dict(id="terminal-run", run_type="agent_run", status="completed", metadata_json=json.dumps(metadata), created_at=old, updated_at=old)
conn.execute(agent_runs.insert().values(**terminal_run))
terminal_before = dict(conn.execute(select(agent_runs)).mappings().one())
counts = resource_access_service.migrate_legacy_deferred_resource_contexts(conn)
assert counts["legacy_deferred_deliveries"] == 2
assert dict(conn.execute(select(agent_runs)).mappings().one()) == terminal_before
for state, before in deliveries.items():
after = dict(conn.execute(select(message_deliveries).where(message_deliveries.c.id == before["id"])).mappings().one())
if DELIVERY_STATE_MATRIX[state].ordering == "terminal":
assert after == before
else:
assert after["state"] == state
assert after["snapshot_sha256"] == hashlib.sha256(after["snapshot_json"].encode()).hexdigest()
assert json.loads(json.loads(after["snapshot_json"])["metadata_json"])[resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY]["vibe_instance_id"] == "same-instance"
finally:
engine.dispose()
def test_legacy_migration_keeps_opposite_instance_semantics_unbound(monkeypatch, tmp_path, sqlite_schema_db_factory) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
config = V2Config.default()
config.remote_access.vibe_cloud.enabled = True
config.remote_access.vibe_cloud.instance_id = "personal-instance"
config.remote_access.vibe_cloud.instance_kind = "personal"
config.remote_access.vibe_cloud.instance_secret = "instance-secret"
config.save()
legacy_metadata = {
resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY: {
"sub": "organization-user",
"vibe_instance_role": "editor",
"vibe_instance_access_source": "organization_group",
"vibe_organization_id": "org-1",
"vibe_organization_member_id": "member-1",
"vibe_organization_role": "member",
}
}
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
store = SQLiteBackgroundTaskStore(db)
engine = create_sqlite_engine(db)
try:
assert store.upsert_scheduled_task(
{
"id": "organization-task",
"name": "organization task",
"message": "run",
"schedule_type": "interval",
"created_at": "2026-08-20T00:00:00Z",
"updated_at": "2026-08-20T00:00:00Z",
"metadata": legacy_metadata,
}
)
from storage.importer import _run_sqlite_data_migrations
with engine.begin() as connection:
assert _migration_counts(_run_sqlite_data_migrations(connection)) == {
"legacy_deferred_definitions": 0,
"legacy_deferred_runs": 0,
"legacy_deferred_deliveries": 0,
}
raw_metadata = connection.execute(
select(run_definitions.c.metadata_json).where(
run_definitions.c.id == "organization-task"
)
).scalar_one()
metadata = json.loads(raw_metadata)
assert "vibe_instance_id" not in metadata[
resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY
]
assert resource_access_service.resource_user_context_from_metadata(metadata) is None
finally:
store.close()
engine.dispose()
def test_legacy_migration_does_not_bind_after_later_pairing(monkeypatch, tmp_path, sqlite_schema_db_factory) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
config = V2Config.default()
config.remote_access.vibe_cloud.enabled = False
config.save()
legacy_metadata = {
resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY: {
"sub": "legacy-user",
"vibe_instance_role": "editor",
"vibe_instance_access_source": "owner",
"claims_issued_at": 1_700_000_000,
}
}
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
store = SQLiteBackgroundTaskStore(db)
engine = create_sqlite_engine(db)
try:
assert store.upsert_scheduled_task(
{
"id": "legacy-task",
"name": "legacy task",
"message": "run",
"schedule_type": "interval",
"created_at": "2026-08-20T00:00:00Z",
"updated_at": "2026-08-20T00:00:00Z",
"metadata": legacy_metadata,
}
)
from storage.importer import _run_sqlite_data_migrations
with engine.begin() as connection:
assert _migration_counts(_run_sqlite_data_migrations(connection)) == {
"legacy_deferred_definitions": 0,
"legacy_deferred_runs": 0,
"legacy_deferred_deliveries": 0,
}
assert connection.execute(
select(state_meta.c.value_json).where(
state_meta.c.key
== resource_access_service.LEGACY_DEFERRED_CONTEXT_MIGRATION_KEY
)
).scalar_one_or_none()
config.remote_access.vibe_cloud.enabled = True
config.remote_access.vibe_cloud.instance_id = "later-instance"
config.remote_access.vibe_cloud.instance_kind = "personal"
config.remote_access.vibe_cloud.instance_secret = "instance-secret"
config.save()
with engine.begin() as connection:
assert _migration_counts(_run_sqlite_data_migrations(connection)) == {
"legacy_deferred_definitions": 0,
"legacy_deferred_runs": 0,
"legacy_deferred_deliveries": 0,
}
raw_metadata = connection.execute(
select(run_definitions.c.metadata_json).where(
run_definitions.c.id == "legacy-task"
)
).scalar_one()
metadata = json.loads(raw_metadata)
snapshot = metadata[resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY]
assert "vibe_instance_id" not in snapshot
assert resource_access_service.resource_user_context_from_metadata(metadata) is None
finally:
store.close()
engine.dispose()
def test_legacy_migration_retries_when_same_pairing_kind_is_backfilled(
monkeypatch,
tmp_path, sqlite_schema_db_factory,
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
config = V2Config.default()
config.remote_access.vibe_cloud.enabled = True
config.remote_access.vibe_cloud.instance_id = "same-instance"
config.remote_access.vibe_cloud.instance_kind = ""
config.remote_access.vibe_cloud.instance_secret = "instance-secret"
config.save()
legacy_metadata = {
resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY: {
"sub": "legacy-user",
"vibe_instance_role": "editor",
"vibe_instance_access_source": "email",
"claims_issued_at": 1_700_000_000,
}
}
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
store = SQLiteBackgroundTaskStore(db)
engine = create_sqlite_engine(db)
try:
assert store.upsert_scheduled_task(
{
"id": "legacy-task",
"name": "legacy task",
"message": "run",
"schedule_type": "interval",
"created_at": "2026-08-20T00:00:00Z",
"updated_at": "2026-08-20T00:00:00Z",
"metadata": legacy_metadata,
}
)
from storage.importer import _run_sqlite_data_migrations
with engine.begin() as connection:
assert _migration_counts(_run_sqlite_data_migrations(connection)) == {
"legacy_deferred_definitions": 0,
"legacy_deferred_runs": 0,
"legacy_deferred_deliveries": 0,
}
config.remote_access.vibe_cloud.instance_kind = "personal"
config.save()
with engine.begin() as connection:
_seed_ready_binding(connection, instance_id="same-instance", instance_kind="personal")
assert _migration_counts(_run_sqlite_data_migrations(connection)) == {
"legacy_deferred_definitions": 1,
"legacy_deferred_runs": 0,
"legacy_deferred_deliveries": 0,
}
raw_metadata = connection.execute(
select(run_definitions.c.metadata_json).where(
run_definitions.c.id == "legacy-task"
)
).scalar_one()
snapshot = json.loads(raw_metadata)[
resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY
]
assert snapshot["vibe_instance_id"] == "same-instance"
assert snapshot["vibe_instance_kind"] == "personal"
finally:
store.close()
engine.dispose()
def test_legacy_migration_preserves_instance_id_while_pairing_is_partial(
monkeypatch,
tmp_path, sqlite_schema_db_factory,
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
config = V2Config.default()
config.remote_access.vibe_cloud.enabled = True
config.remote_access.vibe_cloud.instance_id = "same-instance"
config.remote_access.vibe_cloud.instance_kind = "personal"
config.remote_access.vibe_cloud.instance_secret = ""
config.save()
legacy_metadata = {
resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY: {
"sub": "legacy-user",
"vibe_instance_role": "editor",
"vibe_instance_access_source": "email",
"claims_issued_at": 1_700_000_000,
}
}
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
store = SQLiteBackgroundTaskStore(db)
engine = create_sqlite_engine(db)
try:
assert store.upsert_scheduled_task(
{
"id": "legacy-task",
"name": "legacy task",
"message": "run",
"schedule_type": "interval",
"created_at": "2026-08-20T00:00:00Z",
"updated_at": "2026-08-20T00:00:00Z",
"metadata": legacy_metadata,
}
)
from storage.importer import _run_sqlite_data_migrations
with engine.begin() as connection:
assert _migration_counts(_run_sqlite_data_migrations(connection)) == {
"legacy_deferred_definitions": 0,
"legacy_deferred_runs": 0,
"legacy_deferred_deliveries": 0,
}
marker = json.loads(
connection.execute(
select(state_meta.c.value_json).where(
state_meta.c.key
== resource_access_service.LEGACY_DEFERRED_CONTEXT_MIGRATION_KEY
)
).scalar_one()
)
assert marker["state"] == "pending"
assert marker["instance_id"] == "same-instance"
config.remote_access.vibe_cloud.instance_secret = "instance-secret"
config.save()
with engine.begin() as connection:
_seed_ready_binding(connection, instance_id="same-instance", instance_kind="personal")
assert _migration_counts(_run_sqlite_data_migrations(connection)) == {
"legacy_deferred_definitions": 1,
"legacy_deferred_runs": 0,
"legacy_deferred_deliveries": 0,
}
raw_metadata = connection.execute(
select(run_definitions.c.metadata_json).where(
run_definitions.c.id == "legacy-task"
)
).scalar_one()
snapshot = json.loads(raw_metadata)[
resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY
]
assert snapshot["vibe_instance_id"] == "same-instance"
assert snapshot["vibe_instance_kind"] == "personal"
finally:
store.close()
engine.dispose()
def test_typed_binding_reader_preserves_partial_identity_and_does_not_latch_read_failure(
monkeypatch,
tmp_path, sqlite_schema_db_factory,
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
config = V2Config.default()
cloud = config.remote_access.vibe_cloud
cloud.enabled = True
cloud.instance_id = "same-instance"
cloud.instance_kind = "personal"
cloud.instance_secret = ""
config.save()
partial = resource_access_service._configured_resource_state()
assert partial.status == resource_access_service.RESOURCE_BINDING_STATE_PARTIAL
assert partial.instance_id == "same-instance"
assert partial.instance_kind == "personal"
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
engine = create_sqlite_engine(db)
marker = {
"schema_version": 2,
"state": "pending",
"instance_id": "same-instance",
"updated_at": "before-read-failure",
}
try:
with engine.begin() as connection:
connection.execute(
state_meta.insert().values(
key=resource_access_service.LEGACY_DEFERRED_CONTEXT_MIGRATION_KEY,
value_json=json.dumps(marker),
updated_at="before-read-failure",
)
)
monkeypatch.setattr(
V2Config,
"load",
classmethod(lambda cls, *args, **kwargs: (_ for _ in ()).throw(OSError("temporary read"))),
)
unavailable = resource_access_service._configured_resource_state()
assert unavailable.status == resource_access_service.RESOURCE_BINDING_STATE_UNAVAILABLE
with engine.begin() as connection:
assert _migration_counts(resource_access_service.migrate_legacy_deferred_resource_contexts(connection)) == {
"legacy_deferred_definitions": 0,
"legacy_deferred_runs": 0,
"legacy_deferred_deliveries": 0,
}
stored = connection.execute(
select(state_meta.c.value_json).where(
state_meta.c.key == resource_access_service.LEGACY_DEFERRED_CONTEXT_MIGRATION_KEY
)
).scalar_one()
assert json.loads(stored) == marker
finally:
engine.dispose()
_EMPTY_MIGRATION_COUNTS = {
"legacy_deferred_definitions": 0,
"legacy_deferred_runs": 0,
"legacy_deferred_deliveries": 0,
}
def _migration_counts(result: dict) -> dict[str, int]:
"""Numeric migration counts, ignoring the typed binding-status field."""
return {
key: int(result[key])
for key in (
"legacy_deferred_definitions",
"legacy_deferred_runs",
"legacy_deferred_deliveries",
)
}
def _paired_cloud_config(
tmp_path,
*,
enabled: bool = True,
instance_id: str = "same-instance",
instance_kind: str = "personal",
instance_secret: str = "instance-secret",
) -> V2Config:
config = V2Config.default()
cloud = config.remote_access.vibe_cloud
cloud.enabled = enabled
cloud.instance_id = instance_id
cloud.instance_kind = instance_kind
cloud.instance_secret = instance_secret
config.save()
return config
def _seed_ready_binding(connection, *, instance_id: str, instance_kind: str, generation: int = 1) -> None:
"""Write a validated ready binding onto THIS connection's database."""
payload = json.dumps(
{
"schema_version": 1,
"state": "ready",
"instance_id": instance_id,
"instance_kind": instance_kind,
"generation": generation,
"updated_at": "1",
},
sort_keys=True,
separators=(",", ":"),
)
connection.execute(
state_meta.insert().values(
key="remote_access.instance_binding.v1",
value_json=payload,
updated_at="1",
)
)
def _seed_legacy_scheduled_task(store, *, definition_id: str, snapshot: dict) -> None:
assert store.upsert_scheduled_task(
{
"id": definition_id,
"name": definition_id,
"message": "run",
"schedule_type": "interval",
"created_at": "2026-08-20T00:00:00Z",
"updated_at": "2026-08-20T00:00:00Z",
"metadata": {resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY: snapshot},
}
)
def _legacy_definition_metadata(connection, definition_id: str) -> dict:
raw = connection.execute(
select(run_definitions.c.metadata_json).where(run_definitions.c.id == definition_id)
).scalar_one()
return json.loads(raw)
def _stored_migration_marker(connection) -> str | None:
return connection.execute(
select(state_meta.c.value_json).where(
state_meta.c.key == resource_access_service.LEGACY_DEFERRED_CONTEXT_MIGRATION_KEY
)
).scalar_one_or_none()
def test_partial_pairing_marker_records_configured_instance_without_claiming_a_kind(
monkeypatch,
tmp_path, sqlite_schema_db_factory,
) -> None:
"""A deferred opportunity keeps its identity but never a guessed kind."""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
_paired_cloud_config(tmp_path, instance_secret="")
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
engine = create_sqlite_engine(db)
try:
from storage.importer import _run_sqlite_data_migrations
with engine.begin() as connection:
assert _migration_counts(_run_sqlite_data_migrations(connection)) == _EMPTY_MIGRATION_COUNTS
marker = json.loads(_stored_migration_marker(connection))
assert marker["schema_version"] == 2
assert marker["state"] == "pending"
assert marker["instance_id"] == "same-instance"
# A partial pairing cannot prove its kind, so the marker must not
# record one and must not look terminal to a later startup.
assert "instance_kind" not in marker
assert "completed_at" not in marker
finally:
engine.dispose()
def test_credential_repair_on_the_same_pairing_completes_the_deferred_migration(
monkeypatch,
tmp_path, sqlite_schema_db_factory,
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
config = _paired_cloud_config(tmp_path, instance_secret="")
legacy_snapshot = {
"sub": "legacy-user",
"vibe_instance_role": "editor",
"vibe_instance_access_source": "email",
"claims_issued_at": 1_700_000_000,
}
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
store = SQLiteBackgroundTaskStore(db)
engine = create_sqlite_engine(db)
try:
_seed_legacy_scheduled_task(store, definition_id="legacy-task", snapshot=legacy_snapshot)
from storage.importer import _run_sqlite_data_migrations
with engine.begin() as connection:
assert _migration_counts(_run_sqlite_data_migrations(connection)) == _EMPTY_MIGRATION_COUNTS
config.remote_access.vibe_cloud.instance_secret = "instance-secret"
config.save()
with engine.begin() as connection:
_seed_ready_binding(connection, instance_id="same-instance", instance_kind="personal")
assert _migration_counts(_run_sqlite_data_migrations(connection)) == {
**_EMPTY_MIGRATION_COUNTS,
"legacy_deferred_definitions": 1,
}
metadata = _legacy_definition_metadata(connection, "legacy-task")
snapshot = metadata[resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY]
assert snapshot["vibe_instance_id"] == "same-instance"
assert snapshot["vibe_instance_kind"] == "personal"
from storage import remote_access_authorization_service as _auth
started = _auth.begin_instance_binding_transition(
instance_id="same-instance",
instance_kind="personal",
)
_auth.complete_instance_binding_transition(
instance_id="same-instance",
instance_kind="personal",
generation=started["generation"],
)
assert resource_access_service.resource_user_context_from_metadata(metadata) is not None
completed = json.loads(_stored_migration_marker(connection))
assert completed["state"] == "completed"
assert completed["instance_id"] == "same-instance"
assert completed["instance_kind"] == "personal"
assert completed["completed_at"]
with engine.begin() as connection:
assert _migration_counts(_run_sqlite_data_migrations(connection)) == _EMPTY_MIGRATION_COUNTS
assert json.loads(_stored_migration_marker(connection)) == completed
assert (
_legacy_definition_metadata(connection, "legacy-task") == metadata
)
finally:
store.close()
engine.dispose()
def test_transient_configuration_failure_leaves_the_migration_retryable(
monkeypatch,
tmp_path, sqlite_schema_db_factory,
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
_paired_cloud_config(tmp_path)
legacy_snapshot = {
"sub": "legacy-user",
"vibe_instance_role": "editor",
"vibe_instance_access_source": "email",
"claims_issued_at": 1_700_000_000,
}
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
store = SQLiteBackgroundTaskStore(db)
engine = create_sqlite_engine(db)
try:
_seed_legacy_scheduled_task(store, definition_id="legacy-task", snapshot=legacy_snapshot)
from storage.importer import _run_sqlite_data_migrations
real_load = V2Config.load
with monkeypatch.context() as unreadable:
unreadable.setattr(
V2Config,
"load",
classmethod(
lambda cls, *args, **kwargs: (_ for _ in ()).throw(OSError("temporary read"))
),
)
with engine.begin() as connection:
assert _migration_counts(_run_sqlite_data_migrations(connection)) == _EMPTY_MIGRATION_COUNTS
# No first migration opportunity may be recorded from a read
# failure; otherwise the retry below would be fenced out.
assert _stored_migration_marker(connection) is None
assert V2Config.load.__func__ is real_load.__func__
with engine.begin() as connection:
_seed_ready_binding(connection, instance_id="same-instance", instance_kind="personal")
assert _migration_counts(_run_sqlite_data_migrations(connection)) == {
**_EMPTY_MIGRATION_COUNTS,
"legacy_deferred_definitions": 1,
}
metadata = _legacy_definition_metadata(connection, "legacy-task")
from storage import remote_access_authorization_service as _auth
started = _auth.begin_instance_binding_transition(
instance_id="same-instance",
instance_kind="personal",
)
_auth.complete_instance_binding_transition(
instance_id="same-instance",
instance_kind="personal",
generation=started["generation"],
)
assert resource_access_service.resource_user_context_from_metadata(metadata) is not None
finally:
store.close()
engine.dispose()
def test_unpaired_first_opportunity_cannot_be_adopted_by_a_later_pairing(
monkeypatch,
tmp_path, sqlite_schema_db_factory,
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
config = _paired_cloud_config(
tmp_path,
enabled=False,
instance_id="",
instance_kind="",
instance_secret="",
)
legacy_snapshot = {
"sub": "legacy-user",
"vibe_instance_role": "editor",
"vibe_instance_access_source": "owner",
"claims_issued_at": 1_700_000_000,
}
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
store = SQLiteBackgroundTaskStore(db)
engine = create_sqlite_engine(db)
try:
_seed_legacy_scheduled_task(store, definition_id="legacy-task", snapshot=legacy_snapshot)
from storage.importer import _run_sqlite_data_migrations
with engine.begin() as connection:
assert _migration_counts(_run_sqlite_data_migrations(connection)) == _EMPTY_MIGRATION_COUNTS
sealed = json.loads(_stored_migration_marker(connection))
assert sealed["state"] == "sealed_unattributed"
assert sealed["instance_id"] is None
cloud = config.remote_access.vibe_cloud
cloud.enabled = True
cloud.instance_id = "later-instance"
cloud.instance_kind = "personal"
cloud.instance_secret = "instance-secret"
config.save()
with engine.begin() as connection:
assert _migration_counts(_run_sqlite_data_migrations(connection)) == _EMPTY_MIGRATION_COUNTS
metadata = _legacy_definition_metadata(connection, "legacy-task")
snapshot = metadata[resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY]
assert "vibe_instance_id" not in snapshot
assert resource_access_service.resource_user_context_from_metadata(metadata) is None
assert json.loads(_stored_migration_marker(connection))["state"] == "sealed_unattributed"
finally:
store.close()
engine.dispose()
def test_pending_marker_for_one_instance_cannot_be_adopted_by_another_instance(
monkeypatch,
tmp_path, sqlite_schema_db_factory,
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
config = _paired_cloud_config(tmp_path, instance_id="instance-a", instance_secret="")
legacy_snapshot = {
"sub": "legacy-user",
"vibe_instance_role": "editor",
"vibe_instance_access_source": "email",
"claims_issued_at": 1_700_000_000,
}
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
store = SQLiteBackgroundTaskStore(db)
engine = create_sqlite_engine(db)
try:
_seed_legacy_scheduled_task(store, definition_id="legacy-task", snapshot=legacy_snapshot)
from storage.importer import _run_sqlite_data_migrations
with engine.begin() as connection:
assert _migration_counts(_run_sqlite_data_migrations(connection)) == _EMPTY_MIGRATION_COUNTS
pending = json.loads(_stored_migration_marker(connection))
assert pending["state"] == "pending"
assert pending["instance_id"] == "instance-a"
cloud = config.remote_access.vibe_cloud
cloud.instance_id = "instance-b"
cloud.instance_secret = "instance-secret"
config.save()
with engine.begin() as connection:
assert _migration_counts(_run_sqlite_data_migrations(connection)) == _EMPTY_MIGRATION_COUNTS
sealed = json.loads(_stored_migration_marker(connection))
assert sealed["state"] == "sealed_unattributed"
# The original owner stays recorded so no later pairing, including
# instance A itself, can reopen the sealed opportunity.
assert sealed["instance_id"] == "instance-a"
cloud.instance_id = "instance-a"
config.save()
with engine.begin() as connection:
assert _migration_counts(_run_sqlite_data_migrations(connection)) == _EMPTY_MIGRATION_COUNTS
metadata = _legacy_definition_metadata(connection, "legacy-task")
snapshot = metadata[resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY]
assert "vibe_instance_id" not in snapshot
assert resource_access_service.resource_user_context_from_metadata(metadata) is None
finally:
store.close()
engine.dispose()
@pytest.mark.parametrize("paired_kind", ["organization", "personal"])
@pytest.mark.parametrize("access_source", ["email", "email_domain", "public_instance"])
def test_shared_access_source_snapshots_migrate_for_either_pairing_kind(
monkeypatch,
tmp_path,
paired_kind: str,
access_source: str, sqlite_schema_db_factory,
) -> None:
"""``email``/``email_domain``/``public_instance`` are kind-agnostic.
Neither their presence nor the absence of Organization membership claims
is instance-kind evidence, so the still-current pairing decides.
"""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
_paired_cloud_config(tmp_path, instance_id="paired-instance", instance_kind=paired_kind)
legacy_snapshot = {
"sub": "legacy-editor",
"vibe_instance_role": "editor",
"vibe_instance_access_source": access_source,
"claims_issued_at": 1_700_000_000,
}
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
store = SQLiteBackgroundTaskStore(db)
engine = create_sqlite_engine(db)
try:
_seed_legacy_scheduled_task(store, definition_id="legacy-task", snapshot=legacy_snapshot)
from storage.importer import _run_sqlite_data_migrations
with engine.begin() as connection:
_seed_ready_binding(connection, instance_id="paired-instance", instance_kind=paired_kind)
assert _migration_counts(_run_sqlite_data_migrations(connection)) == {
**_EMPTY_MIGRATION_COUNTS,
"legacy_deferred_definitions": 1,
}
metadata = _legacy_definition_metadata(connection, "legacy-task")
snapshot = metadata[resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY]
assert snapshot["vibe_instance_id"] == "paired-instance"
assert snapshot["vibe_instance_kind"] == paired_kind
from storage import remote_access_authorization_service as _auth
started = _auth.begin_instance_binding_transition(
instance_id="paired-instance",
instance_kind=paired_kind,
)
_auth.complete_instance_binding_transition(
instance_id="paired-instance",
instance_kind=paired_kind,
generation=started["generation"],
)
restored = resource_access_service.resource_user_context_from_metadata(metadata)
assert restored is not None
assert restored.is_personal_instance is (paired_kind == "personal")
# Organization membership is never synthesized by the migration.
assert "vibe_organization_id" not in snapshot
finally:
store.close()
engine.dispose()
@pytest.mark.parametrize(
("marker_json", "expected_state", "expect_marker_preserved"),
[
pytest.param(
json.dumps(
{
"schema_version": 1,
"state": "completed",
"instance_id": None,
"completed_at": "2026-08-19T00:00:00Z",
"updated_at": "2026-08-19T00:00:00Z",
}
),
"sealed_unattributed",
True,
id="released_completed_without_instance",
),
pytest.param(
json.dumps(
{
"schema_version": 1,
"state": "completed",
"instance_id": "same-instance",
"completed_at": "2026-08-19T00:00:00Z",
"updated_at": "2026-08-19T00:00:00Z",
}
),
"completed",
True,
id="released_completed_for_current_instance",
),
pytest.param(
json.dumps({"instance_id": "same-instance", "completed_at": "2026-08-19T00:00:00Z"}),
"completed",
True,
id="released_marker_without_state_field",
),
pytest.param(
json.dumps({"instance_id": None}),
"sealed_unattributed",
False,
id="released_marker_without_state_or_instance",
),
pytest.param(
json.dumps({"state": "pending", "instance_id": " "}),
None,
True,
id="blank_instance_id",
),
pytest.param(
json.dumps({"state": "sealed_unattributed", "instance_id": "same-instance"}),
"sealed_unattributed",
True,
id="sealed_for_current_instance",
),
pytest.param("not-json", None, True, id="corrupt_marker"),
pytest.param(json.dumps(["completed"]), None, True, id="non_object_marker"),
],
)
def test_released_migration_marker_shapes_stay_idempotent_and_fail_closed(
monkeypatch,
tmp_path,
marker_json: str,
expected_state: str | None,
expect_marker_preserved: bool, sqlite_schema_db_factory,
) -> None:
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
_paired_cloud_config(tmp_path)
legacy_snapshot = {
"sub": "legacy-user",
"vibe_instance_role": "editor",
"vibe_instance_access_source": "email",
"claims_issued_at": 1_700_000_000,
}
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
store = SQLiteBackgroundTaskStore(db)
engine = create_sqlite_engine(db)
try:
_seed_legacy_scheduled_task(store, definition_id="legacy-task", snapshot=legacy_snapshot)
with engine.begin() as connection:
connection.execute(
state_meta.insert().values(
key=resource_access_service.LEGACY_DEFERRED_CONTEXT_MIGRATION_KEY,
value_json=marker_json,
updated_at="2026-08-19T00:00:00Z",
)
)
from storage.importer import _run_sqlite_data_migrations
for _ in range(2):
with engine.begin() as connection:
assert _migration_counts(_run_sqlite_data_migrations(connection)) == _EMPTY_MIGRATION_COUNTS
metadata = _legacy_definition_metadata(connection, "legacy-task")
snapshot = metadata[resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY]
assert "vibe_instance_id" not in snapshot
assert resource_access_service.resource_user_context_from_metadata(metadata) is None
stored = _stored_migration_marker(connection)
if expect_marker_preserved:
# A terminal or unreadable marker is never rewritten, so
# repeated startups cannot churn the released shape.
assert stored == marker_json
else:
assert json.loads(stored)["state"] == expected_state
finally:
store.close()
def test_member_resource_user_context_snapshot_round_trips() -> None:
context = resource_access_service.ResourceUserContext(
subject="member-1",
organization_id="org-1",
organization_member_id="organization-member-1",
organization_role="member",
group_ids=frozenset({"group-engineering"}),
membership_version="membership-v2",
instance_role="member",
instance_access_source="email",
claims_issued_at=1_700_000_000,
is_remote=True,
)
metadata = resource_access_service.metadata_with_resource_user_context({}, context)
restored = resource_access_service.resource_user_context_from_metadata(metadata)
assert restored is not None
assert restored.instance_role == "member"
assert restored.can_manage_instance
assert not restored.can_manage_access_members
assert restored.has_role("editor")
def test_pre_member_resource_user_context_snapshot_keeps_editor_role() -> None:
context = resource_access_service.ResourceUserContext(
subject="editor-1",
organization_id="org-1",
organization_member_id="organization-member-1",
organization_role="member",
instance_role="editor",
instance_access_source="email",
claims_issued_at=1_700_000_000,
is_remote=True,
)
metadata = resource_access_service.metadata_with_resource_user_context({}, context)
restored = resource_access_service.resource_user_context_from_metadata(metadata)
assert restored is not None
assert restored.instance_role == "editor"
assert not restored.can_manage_instance
def test_deferred_snapshot_carries_the_signed_email_and_ignores_supplied_metadata() -> None:
"""PERMISSIONS-025: Project email ACLs need the principal the request had.
The normalized form is the one ``_matching_binding_role`` compares, and the
key is written from the signed context after any caller-supplied value is
dropped, so untrusted metadata can neither mint nor override it.
"""
context = resource_access_service.ResourceUserContext(
subject="editor-1",
email="[email protected] ",
organization_id="org-1",
organization_member_id="organization-member-1",
organization_role="member",
instance_role="editor",
instance_access_source="email",
claims_issued_at=1_700_000_000,
is_remote=True,
)
spoofed = {
resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY: {
"sub": "someone-else",
"email": "[email protected]",
"vibe_instance_role": "owner",
}
}
metadata = resource_access_service.metadata_with_resource_user_context(spoofed, context)
assert metadata[resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY]["email"] == "[email protected]"
restored = resource_access_service.resource_user_context_from_metadata(metadata)
assert restored is not None
assert restored.email == "[email protected]"
assert restored.subject == "editor-1"
assert restored.instance_role == "editor"
def test_historical_snapshot_without_an_email_is_not_given_one() -> None:
"""PERMISSIONS-025: an unstamped principal stays absent rather than inferred."""
legacy = {
resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY: {
"sub": "editor-1",
"vibe_instance_role": "editor",
"vibe_instance_access_source": "email",
"vibe_organization_id": "org-1",
"vibe_organization_role": "member",
}
}
restored = resource_access_service.resource_user_context_from_metadata(legacy)
assert restored is not None
assert restored.email is None
assert restored.has_role("editor")
def test_instance_member_operates_resources_without_rewriting_acl(tmp_path, sqlite_schema_db_factory) -> None:
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
engine = create_sqlite_engine(db)
try:
with engine.begin() as connection:
_seed_policies(connection)
member = _context(
"member-2",
instance_role="member",
group_ids=frozenset({"group-sales"}),
)
assert member.can_manage_instance
assert resource_access_service.can_use_resource(
member, "agent", "private-agent", connection=connection
)
assert resource_access_service.can_use_resource(
member, "agent", "public-agent", connection=connection
)
assert resource_access_service.can_use_resource(
member, "agent", "scoped-agent", connection=connection
)
finally:
engine.dispose()
def test_personal_resources_cannot_use_organization_access_levels(tmp_path, sqlite_schema_db_factory) -> None:
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
engine = create_sqlite_engine(db)
try:
with engine.begin() as connection:
with pytest.raises(resource_access_service.ResourceAccessError, match="invalid_resource_acl_intent"):
resource_access_service.ensure_resource_policy(
connection,
resource_kind="agent",
resource_id="personal-agent",
organization_id=None,
owner_user_id="owner-1",
access_level="public",
)
finally:
engine.dispose()
def test_migration_defers_to_a_disagreeing_durable_binding_row(
monkeypatch,
tmp_path, sqlite_schema_db_factory,
) -> None:
"""A binding row from a peer's reclassification outranks the config read.
Regression: PR #1606 round 1 — the migration running from a bare
``ensure_sqlite_state()`` must not bind ambiguous snapshots to a config
kind that the durable binding row does not (yet) agree with.
"""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
_paired_cloud_config(tmp_path, instance_kind="personal")
legacy_snapshot = {
"sub": "legacy-user",
"vibe_instance_role": "editor",
"vibe_instance_access_source": "email",
"claims_issued_at": 1_700_000_000,
}
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
store = SQLiteBackgroundTaskStore(db)
engine = create_sqlite_engine(db)
try:
_seed_legacy_scheduled_task(store, definition_id="legacy-task", snapshot=legacy_snapshot)
binding_row = json.dumps(
{
"schema_version": 1,
"state": "ready",
"instance_id": "same-instance",
"instance_kind": "organization",
"generation": 3,
"updated_at": "1700000000",
},
sort_keys=True,
separators=(",", ":"),
)
from storage.importer import _run_sqlite_data_migrations
with engine.begin() as connection:
connection.execute(
state_meta.insert().values(
key="remote_access.instance_binding.v1",
value_json=binding_row,
updated_at="1700000000",
)
)
counts = _migration_counts(_run_sqlite_data_migrations(connection))
marker = json.loads(_stored_migration_marker(connection))
metadata = _legacy_definition_metadata(connection, "legacy-task")
# No snapshot was bound and the opportunity stays retriable.
assert counts == _EMPTY_MIGRATION_COUNTS
assert marker["state"] == "pending"
assert marker["instance_id"] == "same-instance"
snapshot = metadata[resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY]
assert "vibe_instance_kind" not in snapshot
finally:
engine.dispose()
def test_recovered_config_is_unavailable_and_does_not_seal_legacy_snapshots(
monkeypatch,
tmp_path, sqlite_schema_db_factory,
) -> None:
"""Regression PR #1606 r3: a recovered/defaulted V2Config.load() (broken
JSON, load_warnings set) is UNAVAILABLE, never authoritative UNPAIRED.
Repairing the config later must still be able to migrate the snapshots.
"""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
config = _paired_cloud_config(tmp_path)
legacy_snapshot = {
"sub": "legacy-user",
"vibe_instance_role": "editor",
"vibe_instance_access_source": "email",
"claims_issued_at": 1_700_000_000,
}
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
store = SQLiteBackgroundTaskStore(db)
engine = create_sqlite_engine(db)
try:
_seed_legacy_scheduled_task(store, definition_id="legacy-task", snapshot=legacy_snapshot)
class Recovered:
load_warnings = ("invalid json recovered to defaults",)
class remote_access:
class vibe_cloud:
instance_id = ""
instance_kind = ""
enabled = False
@staticmethod
def runtime_credentials():
return None
monkeypatch.setattr(V2Config, "load", staticmethod(lambda: Recovered()))
from storage.importer import _run_sqlite_data_migrations
with engine.begin() as connection:
counts = _migration_counts(_run_sqlite_data_migrations(connection))
marker = _stored_migration_marker(connection)
assert _migration_counts(counts) == _EMPTY_MIGRATION_COUNTS
# No terminal seal was written.
if marker is not None:
payload = json.loads(marker)
assert payload.get("state") != "sealed_unattributed"
# Repair: restore a real pairing and migrate.
monkeypatch.undo()
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
_paired_cloud_config(tmp_path)
with engine.begin() as connection:
_seed_ready_binding(connection, instance_id="same-instance", instance_kind="personal")
repaired = _migration_counts(_run_sqlite_data_migrations(connection))
metadata = _legacy_definition_metadata(connection, "legacy-task")
snapshot = metadata[resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY]
assert snapshot["vibe_instance_id"] == "same-instance"
assert snapshot["vibe_instance_kind"] == "personal"
assert repaired.get("legacy_deferred_definitions", 0) >= 1
finally:
engine.dispose()
def test_gate_under_writer_lock_does_not_open_a_second_write_connection(
monkeypatch,
tmp_path, sqlite_schema_db_factory,
) -> None:
"""Regression PR #1606 r3: resource_user_context_from_metadata is called
while a queued-delivery transaction already holds reserve_write_lock.
Bootstrap must not open a second write connection (it would time out
and permanently retire the delivery as unauthorized).
"""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
_paired_cloud_config(tmp_path)
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
engine = create_sqlite_engine(db)
try:
from storage.agent_session_rows import reserve_write_lock
metadata = {
resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY: {
"sub": "legacy-user",
"vibe_instance_role": "editor",
"vibe_instance_access_source": "email",
"vibe_instance_id": "same-instance",
"vibe_instance_kind": "personal",
"claims_issued_at": 1_700_000_000,
}
}
with engine.begin() as conn:
reserve_write_lock(conn)
# Absent binding row + known kind: the gate must fail closed
# WITHOUT opening a second writer, and without raising.
context = resource_access_service.resource_user_context_from_metadata(metadata)
# Fail-closed is acceptable; a timeout / deadlock is not.
assert context is None or context.instance_id == "same-instance"
finally:
engine.dispose()
def test_typed_reader_from_sqlite_migration_does_not_persist_config(
monkeypatch,
tmp_path,
) -> None:
"""Regression PR #1606 r4: the typed reader used under an open SQLite
writer must not persist on-load config migrations (that would invert
C2 lock order against a peer holding the config lock).
"""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
_paired_cloud_config(tmp_path)
calls = {"persist": 0}
real_load = V2Config.load
def load_counting(*args, **kwargs):
persist = kwargs.get("persist_migrations", True)
if persist:
calls["persist"] += 1
return real_load(*args, **kwargs)
monkeypatch.setattr(V2Config, "load", staticmethod(load_counting))
db = tmp_path / "vibe.sqlite"
run_migrations(db)
engine = create_sqlite_engine(db)
try:
from storage.importer import _run_sqlite_data_migrations
with engine.begin() as connection:
_run_sqlite_data_migrations(connection)
assert calls["persist"] == 0
finally:
engine.dispose()
def test_terminal_delivery_snapshots_are_left_byte_identical(
monkeypatch,
tmp_path, sqlite_schema_db_factory,
) -> None:
"""Regression PR #1606 r4: accepted/retired delivery snapshots are the
immutable submitted Message candidate and must not be rewritten.
"""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
_paired_cloud_config(tmp_path)
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
engine = create_sqlite_engine(db)
try:
from storage.importer import _run_sqlite_data_migrations
from storage.models import agent_sessions, message_deliveries, scopes
import hashlib
snapshot = {
"metadata_json": json.dumps(
{
resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY: {
"sub": "legacy-user",
"vibe_instance_role": "editor",
"vibe_instance_access_source": "email",
"claims_issued_at": 1_700_000_000,
}
}
)
}
snapshot_json = json.dumps(snapshot, sort_keys=True, separators=(",", ":"))
snapshot_sha = hashlib.sha256(snapshot_json.encode("utf-8")).hexdigest()
with engine.begin() as connection:
connection.execute(
scopes.insert().values(
id="scope_term",
platform="avibe",
scope_type="project",
native_id="proj_term",
is_private=0,
supports_threads=0,
metadata_json="{}",
first_seen_at="now",
last_seen_at="now",
updated_at="now",
)
)
connection.execute(
agent_sessions.insert().values(
id="sess_term",
scope_id="scope_term",
title="t",
status="idle",
agent_backend="claude",
agent_variant="default",
session_anchor="anchor_term",
native_session_id="native_term",
created_at="now",
updated_at="now",
last_active_at="now",
metadata_json="{}",
)
)
connection.execute(
message_deliveries.insert().values(
id="del_retired",
session_id="sess_term",
priority="p3",
state="retired",
snapshot_json=snapshot_json,
snapshot_sha256=snapshot_sha,
dispatch_sha256=snapshot_sha,
submitted_at="now",
updated_at="now",
)
)
_run_sqlite_data_migrations(connection)
rows = {
row["id"]: row
for row in connection.execute(
select(
message_deliveries.c.id,
message_deliveries.c.snapshot_json,
message_deliveries.c.snapshot_sha256,
)
).mappings()
}
assert rows["del_retired"]["snapshot_json"] == snapshot_json
assert rows["del_retired"]["snapshot_sha256"] == snapshot_sha
finally:
engine.dispose()
def test_absent_binding_fails_closed_for_deferred_personal_context(
monkeypatch,
tmp_path,
) -> None:
"""Regression PR #1606 r5: a known-kind pairing with no durable binding
row must not project a Personal context for deferred execution.
"""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
config = V2Config.default()
config.remote_access.vibe_cloud.enabled = True
config.remote_access.vibe_cloud.instance_id = "personal-instance"
config.remote_access.vibe_cloud.instance_kind = "personal"
config.remote_access.vibe_cloud.instance_secret = "instance-secret"
config.save()
context = resource_access_service.ResourceUserContext(
subject="personal-user",
instance_id="personal-instance",
instance_role="editor",
instance_access_source="owner",
instance_kind="personal",
is_remote=True,
)
metadata = resource_access_service.metadata_with_resource_user_context({}, context)
assert resource_access_service.resource_user_context_from_metadata(metadata) is None
def test_migration_stays_pending_without_a_validated_binding_row(
monkeypatch,
tmp_path, sqlite_schema_db_factory,
) -> None:
"""Regression PR #1606 r5: known-kind config + absent binding row must
not complete the deferred-context migration or relabel snapshots.
"""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
config = V2Config.default()
cloud = config.remote_access.vibe_cloud
cloud.enabled = True
cloud.instance_id = "same-instance"
cloud.instance_kind = "personal"
cloud.instance_secret = "instance-secret"
config.save()
legacy_snapshot = {
"sub": "legacy-user",
"vibe_instance_role": "editor",
"vibe_instance_access_source": "email",
"claims_issued_at": 1_700_000_000,
}
db = tmp_path / "vibe.sqlite"
sqlite_schema_db_factory(db)
store = SQLiteBackgroundTaskStore(db)
engine = create_sqlite_engine(db)
try:
_seed_legacy_scheduled_task(store, definition_id="legacy-task", snapshot=legacy_snapshot)
from storage.importer import _run_sqlite_data_migrations
with engine.begin() as connection:
counts = _migration_counts(_run_sqlite_data_migrations(connection))
marker = json.loads(_stored_migration_marker(connection))
metadata = _legacy_definition_metadata(connection, "legacy-task")
assert counts == _EMPTY_MIGRATION_COUNTS
assert marker["state"] == "pending"
snapshot = metadata[resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY]
assert "vibe_instance_kind" not in snapshot
finally:
engine.dispose()
def test_unsupported_deferred_snapshot_kind_is_rejected(monkeypatch, tmp_path) -> None:
"""Regression PR #1606 r5: a present-but-unrecognized kind is not a
no-kind legacy snapshot for deferred execution either.
"""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
_paired_cloud_config(tmp_path)
metadata = {
resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY: {
"sub": "legacy-user",
"vibe_instance_role": "editor",
"vibe_instance_access_source": "email",
"vibe_instance_id": "same-instance",
"vibe_instance_kind": "enterprise",
"claims_issued_at": 1_700_000_000,
}
}
assert resource_access_service.resource_user_context_from_metadata(metadata) is None
def test_unrelated_section_load_warning_does_not_make_pairing_unavailable(
monkeypatch,
tmp_path,
) -> None:
"""Regression PR #1606 r5: Model Hub recovery warnings must not classify
an intact Vibe Cloud pairing as UNAVAILABLE.
"""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
_paired_cloud_config(tmp_path)
class IntactPairing:
load_warnings = ("Recovered invalid config section 'model_hub.sources.vendor': bad",)
class remote_access:
class vibe_cloud:
enabled = True
instance_id = "same-instance"
instance_kind = "personal"
instance_secret = "instance-secret"
@staticmethod
def runtime_credentials():
return ("https://backend.test", "same-instance", "instance-secret")
monkeypatch.setattr(V2Config, "load", staticmethod(lambda **kwargs: IntactPairing()))
state = resource_access_service._configured_resource_state()
assert state.status == "ready"
assert state.instance_id == "same-instance"
assert state.instance_kind == "personal"
def test_kindless_deferred_snapshot_fails_closed_when_pairing_is_unpaired(
monkeypatch,
tmp_path,
) -> None:
"""P2 a0D_l: kindless snapshot + unpaired/unavailable config → no Editor context.
The valid legacy no-kind PAIRING path (PARTIAL, runtime-ready, kind not
yet backfilled) still returns the original context.
"""
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
config = V2Config.default()
config.remote_access.vibe_cloud.enabled = False
config.remote_access.vibe_cloud.instance_id = ""
config.save()
metadata = {
resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY: {
"sub": "legacy-user",
"vibe_instance_role": "editor",
"vibe_instance_access_source": "email",
"claims_issued_at": 1_700_000_000,
}
}
assert resource_access_service.resource_user_context_from_metadata(metadata) is None
# Valid legacy no-kind pairing: runtime-ready, kind not yet backfilled.
config.remote_access.vibe_cloud.enabled = True
config.remote_access.vibe_cloud.instance_id = "same-instance"
config.remote_access.vibe_cloud.instance_kind = ""
config.remote_access.vibe_cloud.instance_secret = "instance-secret"
config.remote_access.vibe_cloud.backend_url = "https://backend.test"
config.save()
restored = resource_access_service.resource_user_context_from_metadata(metadata)
assert restored is not None
assert restored.instance_role == "editor"
assert restored.instance_kind is None
@pytest.fixture
def member_repair_race(monkeypatch, tmp_path, sqlite_schema_db_factory, family):
"""Real WAL state shared by the migration and an independent runtime writer."""
from types import SimpleNamespace
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
_paired_cloud_config(tmp_path)
db = tmp_path / "race.sqlite"
sqlite_schema_db_factory(db)
engine = create_sqlite_engine(db)
peer = create_sqlite_engine(db)
old = "2026-08-20T00:00:00Z"
metadata = {resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY: {
"sub": "member α", "vibe_instance_role": "member", "vibe_instance_access_source": "email",
}}
marker = {"schema_version": 2, "state": "completed", "instance_id": "same-instance",
"instance_kind": "personal", "completed_at": "2026-08-21T00:00:00Z"}
with engine.begin() as conn:
_seed_ready_binding(conn, instance_id="same-instance", instance_kind="personal")
conn.execute(state_meta.insert().values(
key=resource_access_service.LEGACY_DEFERRED_CONTEXT_MIGRATION_KEY,
value_json=json.dumps(marker), updated_at=old,
))
for kind in ("scheduled", "watch"):
conn.execute(run_definitions.insert().values(
id=kind, definition_type=kind, enabled=1, metadata_json=json.dumps(metadata),
created_at=old, updated_at=old,
))
conn.execute(agent_runs.insert().values(
id="run", run_type="scheduled", status="queued", metadata_json=json.dumps(metadata),
created_at=old, updated_at=old,
))
conn.execute(agent_sessions.insert().values(
id="session", agent_backend="codex", agent_variant="default", session_anchor="session",
native_session_id="native", status="active", metadata_json="{}", created_at=old, updated_at=old,
))
delivery = enqueue_queued(conn, scope_id=None, session_id="session", text="你好", metadata=metadata, now=old)
# Only the selected family is eligible: an earlier table's write must
# not accidentally reserve the lock and hide a later family's race.
if family in {"scheduled", "watch"}:
conn.execute(run_definitions.delete().where(run_definitions.c.id != family))
elif family in {"run", "delivery"}:
conn.execute(run_definitions.delete())
if family not in {"run", "binding", "marker"}:
conn.execute(agent_runs.delete())
if family not in {"delivery", "binding", "marker"}:
conn.execute(message_deliveries.delete())
expected = {"legacy_deferred_definitions": 2, "legacy_deferred_runs": 1, "legacy_deferred_deliveries": 1}
if family not in {"binding", "marker"}:
expected = dict(_EMPTY_MIGRATION_COUNTS)
key = "legacy_deferred_definitions" if family in {"scheduled", "watch"} else f"legacy_deferred_{'runs' if family == 'run' else 'deliveries'}"
expected[key] = 1
def mutation(family):
later = "2026-08-22T00:00:00Z"
changed = json.dumps({**metadata, "concurrent_edit": "survives α"})
if family in {"scheduled", "watch"}:
return run_definitions, run_definitions.c.id == family, {"metadata_json": changed, "updated_at": later}
if family == "run":
return agent_runs, agent_runs.c.id == "run", {"metadata_json": changed, "updated_at": later, "status": "completed"}
if family == "delivery":
snapshot = json.dumps({"metadata_json": changed, "text": "peer α"})
return message_deliveries, message_deliveries.c.id == delivery["id"], {
"snapshot_json": snapshot, "snapshot_sha256": hashlib.sha256(snapshot.encode()).hexdigest(),
"updated_at": later, "state": "retired",
}
if family == "binding":
return state_meta, state_meta.c.key == "remote_access.instance_binding.v1", {
"value_json": json.dumps({"schema_version": 1, "state": "reconciling", "instance_id": "other-instance",
"instance_kind": "personal", "generation": 2}), "updated_at": later,
}
assert family == "marker"
return state_meta, state_meta.c.key == resource_access_service.LEGACY_DEFERRED_CONTEXT_MIGRATION_KEY, {
"value_json": json.dumps({**marker, "state": "sealed_unattributed"}), "updated_at": later,
}
try:
yield SimpleNamespace(engine=engine, peer=peer, mutation=mutation, expected=expected)
finally:
peer.dispose()
engine.dispose()
@pytest.mark.parametrize("family", ["scheduled", "watch", "run", "delivery", "binding", "marker"])
def test_member_repair_serializes_peer_writes_through_marker_seal(member_repair_race, family):
"""PERMISSIONS-014: a writer after decision reads cannot race any repair effect."""
from concurrent.futures import ThreadPoolExecutor
from sqlalchemy import event
from sqlalchemy.exc import OperationalError
state = member_repair_race
table, predicate, values = state.mutation(family)
attempts = []
def peer_write():
try:
with state.peer.begin() as conn:
conn.exec_driver_sql("PRAGMA busy_timeout = 0")
conn.execute(table.update().where(predicate).values(**values))
except OperationalError as exc:
assert "locked" in str(exc)
return "blocked"
return "committed"
with ThreadPoolExecutor(max_workers=1) as pool:
def after_read(_conn, _cursor, statement, parameters, _context, _many):
sql = " ".join(statement.split())
if attempts or not sql.startswith("SELECT") or f"FROM {table.name}" not in sql:
return
if family in {"marker", "binding"}:
key = "remote_access.instance_binding.v1" if family == "binding" else resource_access_service.LEGACY_DEFERRED_CONTEXT_MIGRATION_KEY
if key not in parameters:
return
# The SELECT has executed, but migration has not consumed its rows.
# Await a real second connection's completed write attempt, not time.
attempts.append(pool.submit(peer_write).result(timeout=5))
event.listen(state.engine, "after_cursor_execute", after_read)
try:
with state.engine.begin() as conn:
result = resource_access_service.migrate_legacy_deferred_resource_contexts(conn)
assert attempts == ["blocked"]
assert _migration_counts(result) == state.expected
assert json.loads(_stored_migration_marker(conn))["schema_version"] == 3
# The writer slot lasts through sealing until the caller commits.
assert pool.submit(peer_write).result(timeout=5) == "blocked"
finally:
event.remove(state.engine, "after_cursor_execute", after_read)
assert pool.submit(peer_write).result(timeout=5) == "committed"
with state.engine.connect() as conn:
row = conn.execute(select(table).where(predicate)).mappings().one()
assert {key: row[key] for key in values} == values
@pytest.mark.parametrize("family", ["scheduled", "watch", "run", "delivery", "binding", "marker"])
def test_member_repair_reads_peer_first_commit_after_writer_reservation(member_repair_race, family):
"""A peer holding the writer first changes eligibility before the repair reads."""
from concurrent.futures import ThreadPoolExecutor
from threading import Event
from sqlalchemy import event
state = member_repair_race
table, predicate, values = state.mutation(family)
entering = Event()
peer_committed = Event()
def entering_transaction(_conn, _cursor, statement, _parameters, _context, _many):
entering.set()
if statement.lstrip().startswith("SELECT"):
assert peer_committed.wait(timeout=5)
def repair():
with state.engine.begin() as conn:
return resource_access_service.migrate_legacy_deferred_resource_contexts(conn)
event.listen(state.engine, "before_cursor_execute", entering_transaction)
try:
with ThreadPoolExecutor(max_workers=1) as pool:
with state.peer.begin() as conn:
conn.execute(table.update().where(predicate).values(**values))
future = pool.submit(repair)
assert entering.wait(timeout=5)
# Release the earlier writer only once the migration is entering.
peer_committed.set()
counts = _migration_counts(future.result(timeout=5))
finally:
event.remove(state.engine, "before_cursor_execute", entering_transaction)
assert counts == _EMPTY_MIGRATION_COUNTS
with state.engine.connect() as conn:
row = conn.execute(select(table).where(predicate)).mappings().one()
assert {key: row[key] for key in values} == values
@pytest.mark.parametrize("transaction", ["new", "writer", "savepoint"])
def test_member_migration_reservation_supports_initial_schema_and_existing_transactions(tmp_path, transaction):
"""The released initial schema owns agent_sessions.id used by nested reservation."""
from storage.migrations import INITIAL_REVISION
db = tmp_path / "initial.sqlite"
run_migrations(db, revision=INITIAL_REVISION)
engine = create_sqlite_engine(db)
try:
with engine.connect() as conn:
with conn.begin():
if transaction == "writer":
conn.execute(state_meta.insert().values(key="caller-write", value_json="{}", updated_at="now"))
nested = conn.begin_nested() if transaction == "savepoint" else None
result = resource_access_service.migrate_legacy_deferred_resource_contexts(conn)
assert _migration_counts(result) == _EMPTY_MIGRATION_COUNTS
assert conn.connection.dbapi_connection.in_transaction
if nested:
nested.rollback()
finally:
engine.dispose()
@pytest.mark.parametrize("family", ["scheduled"])
@pytest.mark.parametrize("nested", [False, True])
def test_member_repair_keeps_existing_transaction_owned_by_caller(member_repair_race, family, nested):
state = member_repair_race
with state.engine.connect() as conn:
outer = conn.begin()
conn.execute(state_meta.insert().values(key="caller-write", value_json="{}", updated_at="now"))
savepoint = conn.begin_nested() if nested else None
assert _migration_counts(resource_access_service.migrate_legacy_deferred_resource_contexts(conn)) == state.expected
assert json.loads(_stored_migration_marker(conn))["schema_version"] == 3
if savepoint:
savepoint.rollback()
assert json.loads(_stored_migration_marker(conn))["schema_version"] == 2
assert conn.execute(select(state_meta.c.key).where(state_meta.c.key == "caller-write")).first()
outer.rollback()
with state.engine.connect() as conn:
assert json.loads(_stored_migration_marker(conn))["schema_version"] == 2
assert not conn.execute(select(state_meta.c.key).where(state_meta.c.key == "caller-write")).first()
snapshot = _legacy_definition_metadata(conn, "scheduled")[resource_access_service.RESOURCE_USER_CONTEXT_METADATA_KEY]
assert "vibe_instance_id" not in snapshot
@pytest.fixture
def member_repair_provenance(monkeypatch, tmp_path, sqlite_schema_db_factory):
"""Released rows with a completed marker, before a real runtime producer writes."""
from types import SimpleNamespace
from config import paths
monkeypatch.setenv("AVIBE_HOME", str(tmp_path / "home"))
_paired_cloud_config(tmp_path)
db = paths.get_sqlite_state_path()
db.parent.mkdir(parents=True, exist_ok=True)
sqlite_schema_db_factory(db)
store = SQLiteBackgroundTaskStore(db)
old = "2026-08-20T00:00:00Z"
cutoff = "2026-08-21T00:00:00Z"
later = "2026-08-22T00:00:00Z"
context = {
"sub": "member α", "vibe_instance_role": "member",
"vibe_instance_access_source": "email", "claims_issued_at": 1_700_000_000,
"vibe_membership_version": 7, "vibe_instance_authorization_revision": 9,
"authorization_expires_at": 1_700_003_600,
}
metadata = {"resource_user_context": context, "note": {"text": "preserve 当前", "value": [1, 2]}}
for kind in ("scheduled", "watch"):
values = dict(id=kind, name=kind, message="run", schedule_type="interval",
created_at=old, updated_at=old, metadata=metadata)
writer = store.upsert_scheduled_task if kind == "scheduled" else store.upsert_watch
assert writer(values)
store.enqueue_run(dict(id="run", run_type="hook_send", status="queued", session_id="session",
created_at=old, updated_at=old, metadata=metadata))
with store.engine.begin() as conn:
_seed_ready_binding(conn, instance_id="same-instance", instance_kind="personal")
conn.execute(state_meta.insert().values(
key=resource_access_service.LEGACY_DEFERRED_CONTEXT_MIGRATION_KEY,
value_json=json.dumps({"schema_version": 2, "state": "completed", "instance_id": "same-instance",
"instance_kind": "personal", "completed_at": cutoff}), updated_at=cutoff,
))
conn.execute(agent_sessions.insert().values(
id="session", agent_backend="codex", agent_variant="default", session_anchor="session",
native_session_id="native", status="active", metadata_json="{}", created_at=old, updated_at=old,
))
delivery = enqueue_queued(conn, scope_id=None, session_id="session", text="你好", metadata=metadata, now=old)
try:
yield SimpleNamespace(store=store, db=db, old=old, cutoff=cutoff, later=later,
context=context, metadata=metadata, delivery_id=delivery["id"])
finally:
store.close()
@pytest.mark.parametrize("diagnostic", ["pristine", "present", "cleared"])
def test_member_repair_preserves_real_run_diagnostics_and_authorization(member_repair_provenance, diagnostic):
"""PERMISSIONS-014: skip history is not authorization history or a hold-clock update."""
state = member_repair_provenance
store = state.store
if diagnostic != "pristine":
assert store.record_run_skip_reason("run", reason="transport_unavailable", at=state.later)
if diagnostic == "cleared":
assert store._clear_transport_skip_evidence({"run"}) == 1
before = store.get_run("run")
assert before["updated_at"] == state.old
assert before["metadata"]["resource_user_context"] == state.context
if diagnostic in {"pristine", "cleared"}:
assert before["metadata"] == state.metadata # Clearing leaves no mutation history.
else:
assert before["metadata"]["last_skip_at"] == state.later
assert not resource_access_service.metadata_allows_harness_runtime(before["metadata"])
with store.engine.begin() as conn:
assert resource_access_service.migrate_legacy_deferred_resource_contexts(conn)["legacy_deferred_runs"] == 1
after = store.get_run("run")
assert after["metadata"] == {
**before["metadata"], "resource_user_context": {
**state.context, "vibe_instance_id": "same-instance", "vibe_instance_kind": "personal",
},
}
assert {k: v for k, v in after.items() if k not in {"metadata", "updated_at"}} == {
k: v for k, v in before.items() if k not in {"metadata", "updated_at"}
}
assert resource_access_service.metadata_allows_harness_runtime(after["metadata"])
from core.session_turns import SessionTurnManager
with store.engine.begin() as conn:
delivery = conn.execute(select(message_deliveries)).mappings().one()
assert SessionTurnManager._remote_delivery_execution_denial(conn, dict(delivery)) is None
marker = _stored_migration_marker(conn)
assert _migration_counts(resource_access_service.migrate_legacy_deferred_resource_contexts(conn)) == _EMPTY_MIGRATION_COUNTS
assert _stored_migration_marker(conn) == marker
assert store.get_run("run") == after
@pytest.mark.parametrize("kind", ["scheduled", "watch"])
def test_member_repair_refuses_real_post_cutoff_authorization_update(member_repair_provenance, monkeypatch, tmp_path, kind):
"""PERMISSIONS-014: the user-edit producer replaces authority and advances its clock."""
from core import scheduled_tasks, watches
state = member_repair_provenance
module = scheduled_tasks if kind == "scheduled" else watches
monkeypatch.setattr(module, "_utc_now_iso", lambda: state.later)
context = _context("replacement β", organization_id=None, instance_role="member", access_source="email")
# An old no-kind caller can still save a legacy-shaped snapshot. Its new
# timestamp, not an assumption that every caller already supplies binding,
# must prevent the original marker from claiming that replacement authority.
if kind == "scheduled":
definitions = scheduled_tasks.ScheduledTaskStore(tmp_path / "unused-tasks.json")
definitions._sqlite = state.store
definitions.load()
definitions.update_task(kind, name=kind, session_key="", prompt="edited", schedule_type="interval",
post_to=None, deliver_key=None, cron=None, run_at=None, timezone_name="UTC",
user_context=context)
else:
definitions = watches.ManagedWatchStore(tmp_path / "unused-watches.json")
definitions._sqlite = state.store
definitions.load()
definitions.update_watch(kind, name=kind, session_key="", session_id=None, command=["true"],
shell_command=None, prefix=None, cwd=None, mode="once", timeout_seconds=0,
lifetime_timeout_seconds=0, retry_exit_codes=[75], retry_delay_seconds=30,
post_to=None, deliver_key=None, user_context=context)
with state.store.engine.begin() as conn:
before = dict(conn.execute(select(run_definitions).where(run_definitions.c.id == kind)).mappings().one())
metadata = json.loads(before["metadata_json"])
assert metadata["resource_user_context"]["sub"] == "replacement β"
assert metadata["resource_user_context"]["vibe_instance_id"] is None
assert before["updated_at"] == state.later
assert resource_access_service.migrate_legacy_deferred_resource_contexts(conn)["legacy_deferred_definitions"] == 1
after = dict(conn.execute(select(run_definitions).where(run_definitions.c.id == kind)).mappings().one())
assert after == before
assert not resource_access_service.metadata_allows_harness_runtime(metadata)
@pytest.mark.parametrize("kind", ["run", "delivery"])
def test_member_repair_refuses_real_post_cutoff_lifecycle_update(member_repair_provenance, monkeypatch, kind):
from storage import message_deliveries as deliveries
state = member_repair_provenance
if kind == "run":
assert state.store.claim_pending_run("run", started_at=state.later) is not None
table, row_id = agent_runs, "run"
else:
monkeypatch.setattr(deliveries, "utc_now_iso", lambda: state.later)
with state.store.engine.begin() as conn:
row = deliveries.get_delivery(conn, state.delivery_id)
assert deliveries.cas_delivery(conn, row["id"], expected_version=row["version"],
expected_states=("queued",), values={},
history_event={"kind": "retry_claim"}) is not None
table, row_id = message_deliveries, state.delivery_id
with state.store.engine.begin() as conn:
before = dict(conn.execute(select(table).where(table.c.id == row_id)).mappings().one())
assert before["updated_at"] == state.later
counts = resource_access_service.migrate_legacy_deferred_resource_contexts(conn)
assert counts[f"legacy_deferred_{'runs' if kind == 'run' else 'deliveries'}"] == 0
assert dict(conn.execute(select(table).where(table.c.id == row_id)).mappings().one()) == before
def test_member_repair_preserves_real_stable_agent_reference_rewrites(member_repair_provenance):
"""PERMISSIONS-014: catalog canonicalization changes routing, not the initiating principal."""
from core.vibe_agents import VibeAgentStore, ensure_agent_selection_access
from storage.session_reclaim import DEFINITION_AGENT_BINDING_REVISION_KEY
state = member_repair_provenance
agents = VibeAgentStore(state.db)
try:
original = agents.create(name="repair-agent", backend="codex")
metadata = {**state.metadata, "session_settings_snapshot": {"agent_name": original.name, "model": "keep"}}
with state.store.engine.begin() as conn:
conn.execute(run_definitions.update().values(agent_name=original.name, metadata_json=json.dumps(metadata)))
conn.execute(agent_runs.update().values(agent_name=original.name, agent_id=None))
assert state.store.refresh_run_agent_reference("run") == {"agent_id": original.id, "agent_name": original.name}
renamed = agents.rename(original.name, "repair-agent-renamed")
assert renamed.id == original.id
with state.store.engine.begin() as conn:
before = list(conn.execute(select(run_definitions)).mappings())
run_before = dict(conn.execute(select(agent_runs)).mappings().one())
assert run_before["agent_id"] == original.id and run_before["agent_name"] == renamed.name
assert run_before["updated_at"] == state.old
for row in before:
current = json.loads(row["metadata_json"])
assert current["resource_user_context"] == state.context
assert current["session_settings_snapshot"] == {"agent_name": renamed.name, "model": "keep"}
assert current[DEFINITION_AGENT_BINDING_REVISION_KEY]
assert row["updated_at"] == state.old
assert resource_access_service.migrate_legacy_deferred_resource_contexts(conn)["legacy_deferred_definitions"] == 2
for row in before:
after = dict(conn.execute(select(run_definitions).where(run_definitions.c.id == row["id"])).mappings().one())
expected = json.loads(row["metadata_json"])
expected["resource_user_context"] = {**state.context, "vibe_instance_id": "same-instance", "vibe_instance_kind": "personal"}
assert json.loads(after.pop("metadata_json")) == expected
assert after == {k: v for k, v in row.items() if k != "metadata_json"}
assert resource_access_service.metadata_allows_harness_runtime(expected)
context = resource_access_service.resource_user_context_from_metadata(expected)
selected = ensure_agent_selection_access(conn, agent_name=renamed.name, agent_id=original.id,
user_context=context, missing_is_error=True)
assert selected.id == original.id
run_after = dict(conn.execute(select(agent_runs)).mappings().one())
assert {k: v for k, v in run_after.items() if k not in {"metadata_json", "updated_at"}} == {
k: v for k, v in run_before.items() if k not in {"metadata_json", "updated_at"}
}
assert json.loads(run_after["metadata_json"])["resource_user_context"] == {
**state.context, "vibe_instance_id": "same-instance", "vibe_instance_kind": "personal",
}
finally:
agents.close()
def test_member_repair_preserves_real_soft_deletion(member_repair_provenance):
state = member_repair_provenance
state.store.remove_task("scheduled")
assert state.store.get_scheduled_task("scheduled") is None
with state.store.engine.begin() as conn:
before = dict(conn.execute(select(run_definitions).where(run_definitions.c.id == "scheduled")).mappings().one())
assert before["deleted_at"] and before["updated_at"] == state.old
resource_access_service.migrate_legacy_deferred_resource_contexts(conn)
after = dict(conn.execute(select(run_definitions).where(run_definitions.c.id == "scheduled")).mappings().one())
assert {k: v for k, v in after.items() if k != "metadata_json"} == {
k: v for k, v in before.items() if k != "metadata_json"
}
assert state.store.get_scheduled_task("scheduled") is None
def test_member_repair_preserves_real_delivery_dedupe_normalization(member_repair_provenance):
from core.session_turns import SessionTurnManager
from storage import message_deliveries as deliveries
state = member_repair_provenance
with state.store.engine.begin() as conn:
row = deliveries.insert_delivery(
conn, delivery_id="legacy-native", session_id="session", priority="p3", state="queued",
snapshot=deliveries.message_snapshot(scope_id="scope", session_id="session", platform="slack",
author="user", source="user", text="hello", metadata=state.metadata),
dispatch_text="hello", dedupe_key=deliveries.native_dedupe_key("slack", "native"), now=state.old,
)
normalized = deliveries.get_delivery_by_native_identity(
conn, platform="slack", native_message_id="native", scope_id="scope", session_id="session", normalize_legacy=True,
)
assert normalized["dedupe_key"] != row["dedupe_key"]
assert normalized["snapshot_json"] == row["snapshot_json"]
assert normalized["updated_at"] == state.old
resource_access_service.migrate_legacy_deferred_resource_contexts(conn)
repaired = deliveries.get_delivery(conn, "legacy-native")
assert repaired["dedupe_key"] == normalized["dedupe_key"]
snapshot = json.loads(repaired["snapshot_json"])
expected = json.loads(normalized["snapshot_json"])
metadata = json.loads(expected["metadata_json"])
metadata["resource_user_context"].update(vibe_instance_id="same-instance", vibe_instance_kind="personal")
assert json.loads(snapshot.pop("metadata_json")) == metadata
expected.pop("metadata_json")
assert snapshot == expected
assert repaired["snapshot_sha256"] == hashlib.sha256(repaired["snapshot_json"].encode()).hexdigest()
assert SessionTurnManager._remote_delivery_execution_denial(conn, repaired) is None