Skip to content

armgit / avibe

Public Imported from GitHub
0

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

32.8 KB
Raw Blame
from __future__ import annotations

import json

import pytest
from sqlalchemy import select

from storage import resource_access_service, vault_service
from storage.db import create_sqlite_engine
from storage.models import (
    metadata,
    resource_access_groups,
    resource_access_policies,
    state_meta,
    vault_grants,
    vault_requests,
    vault_secrets,
)
from storage.vault_crypto import Sealed
from vibe import api, remote_access


def _context(
    subject: str,
    *,
    group_ids: frozenset[str] | None = frozenset({"group-engineering"}),
    role: str = "member",
    instance_role: str = "editor",
    is_remote: bool = True,
) -> resource_access_service.ResourceUserContext:
    return resource_access_service.ResourceUserContext(
        subject=subject,
        email=f"{subject}@example.com",
        organization_id="org-1",
        organization_member_id=f"member-{subject}",
        organization_role=role,
        group_ids=group_ids,
        instance_role=instance_role,
        instance_access_source="organization_group",
        is_remote=is_remote,
    )


def _external_guest_context() -> resource_access_service.ResourceUserContext:
    return resource_access_service.ResourceUserContext(
        subject="guest-1",
        instance_role="viewer",
        instance_access_source="email",
        is_remote=True,
    )


@pytest.fixture
def vault(tmp_path):
    vault_service.GRANT_RUNTIME_CACHE.clear()
    engine = create_sqlite_engine(tmp_path / "vault_acl.sqlite")
    metadata.create_all(engine)
    try:
        yield engine
    finally:
        engine.dispose()


def _sealed(name: str) -> Sealed:
    return Sealed(ciphertext=f"ciphertext-{name}", nonce=f"nonce-{name}", wrap_meta=f"wrap-{name}")


def _create_secret(conn, name: str, **kwargs) -> None:
    vault_service.create_secret(conn, name=name, sealed=_sealed(name), **kwargs)


def _secret_id(conn, name: str) -> str:
    return str(conn.execute(select(vault_secrets.c.id).where(vault_secrets.c.name == name)).scalar_one())


def _set_policy(
    conn,
    name: str,
    *,
    access_level: str,
    group_ids: list[str] | None = None,
    owner_user_id: str = "owner-1",
) -> str:
    resource_id = _secret_id(conn, name)
    resource_access_service.ensure_resource_policy(
        conn,
        resource_kind="vault_secret",
        resource_id=resource_id,
        organization_id="org-1",
        owner_user_id=owner_user_id,
        access_level=access_level,
        group_ids=group_ids,
        policy_revision=1,
        last_applied_control_plane_revision=1,
    )
    return resource_id


def _grant_from_request(conn, request: dict, *, user_context) -> dict:
    option = request["card"]["grant_options"][0]
    return vault_service.create_grant(
        conn,
        member_names=option["member_snapshot"],
        source_selector=option["source_selector"],
        purpose=option["purpose"],
        request_id=request["id"],
        user_context=user_context,
    )


def test_active_org_members_list_all_vault_metadata_without_envelopes(vault) -> None:
    with vault.begin() as conn:
        _create_secret(conn, "PRIVATE_KEY")
        _create_secret(conn, "PUBLIC_KEY")
        _create_secret(conn, "SCOPED_KEY")
        _set_policy(conn, "PRIVATE_KEY", access_level="private")
        _set_policy(conn, "PUBLIC_KEY", access_level="public")
        _set_policy(conn, "SCOPED_KEY", access_level="scope", group_ids=["group-engineering"])

    with vault.connect() as conn:
        owner_rows = vault_service.list_secrets(conn, user_context=_context("owner-1"))
        member_rows = vault_service.list_secrets(conn, user_context=_context("member-1"))
        no_group_rows = vault_service.list_secrets(conn, user_context=_context("member-2", group_ids=None))

    assert {row["name"] for row in owner_rows} == {"PRIVATE_KEY", "PUBLIC_KEY", "SCOPED_KEY"}
    assert {row["name"] for row in member_rows} == {"PRIVATE_KEY", "PUBLIC_KEY", "SCOPED_KEY"}
    assert {row["name"] for row in no_group_rows} == {"PRIVATE_KEY", "PUBLIC_KEY", "SCOPED_KEY"}
    serialized = json.dumps(member_rows)
    assert "ciphertext-" not in serialized
    assert "nonce-" not in serialized
    assert "wrap-" not in serialized
    assert "ciphertext" not in serialized
    assert "wrap_meta" not in serialized


def test_editor_vault_use_keeps_protected_secret_behind_approval(vault) -> None:
    editor = _context("member-1")
    with vault.begin() as conn:
        _create_secret(conn, "PROTECTED_USE", protection="protected")
        _set_policy(conn, "PROTECTED_USE", access_level="public")

        metadata_payload = vault_service.get_secret_meta(
            conn,
            "PROTECTED_USE",
            user_context=editor,
        )
        access = vault_service.resolve_secret_access(
            conn,
            "PROTECTED_USE",
            session_id="ses-editor",
            user_context=editor,
        )

    assert metadata_payload["name"] == "PROTECTED_USE"
    assert access["status"] == "approval_required"
    assert access["request"]["status"] == "pending"
    assert access.get("envelope") is None
    assert access["request"]["card"]["value"] is None
    serialized_metadata = json.dumps(metadata_payload)
    assert "ciphertext-PROTECTED_USE" not in serialized_metadata
    assert "nonce-PROTECTED_USE" not in serialized_metadata
    assert "wrap-PROTECTED_USE" not in serialized_metadata


def test_active_org_members_create_private_vault_requests_and_grants(vault) -> None:
    owner = _context("owner-1", instance_role="owner")
    member = _context("member-1")
    with vault.begin() as conn:
        _create_secret(conn, "PRIVATE_ACCESS", protection="protected")
        _create_secret(conn, "PRIVATE_SIGN", kind="keypair", signer_kind="local")
        _set_policy(conn, "PRIVATE_ACCESS", access_level="private")
        _set_policy(conn, "PRIVATE_SIGN", access_level="private")
        owner_request = vault_service.create_access_request(conn, "PRIVATE_ACCESS", user_context=owner)
        member_access_request = vault_service.create_access_request(
            conn,
            "PRIVATE_ACCESS",
            user_context=member,
        )
        member_sign_request = vault_service.create_sign_request(
            conn,
            "PRIVATE_SIGN",
            digest="00" * 32,
            scheme="ecdsa-secp256k1-recoverable",
            user_context=member,
        )
        member_grant = _grant_from_request(conn, owner_request, user_context=member)

        requests = list(conn.execute(select(vault_requests)).mappings())
        grants = list(conn.execute(select(vault_grants)).mappings())

    assert {row["id"] for row in requests} == {
        owner_request["id"],
        member_access_request["id"],
        member_sign_request["id"],
    }
    statuses = {row["id"]: row["status"] for row in requests}
    assert statuses == {
        owner_request["id"]: "approved",
        member_access_request["id"]: "pending",
        member_sign_request["id"]: "pending",
    }
    assert [row["id"] for row in grants] == [member_grant["id"]]
    assert member_grant["status"] == "active"


def test_active_org_member_reads_and_denies_all_vault_requests(vault) -> None:
    owner = _context("owner-1", instance_role="owner")
    member = _context("member-1")
    with vault.begin() as conn:
        _create_secret(conn, "PRIVATE_REQUEST", protection="protected")
        _create_secret(conn, "PUBLIC_REQUEST", protection="protected")
        _set_policy(conn, "PRIVATE_REQUEST", access_level="private")
        _set_policy(conn, "PUBLIC_REQUEST", access_level="public")
        private_request = vault_service.create_access_request(conn, "PRIVATE_REQUEST", user_context=owner)
        public_request = vault_service.create_access_request(conn, "PUBLIC_REQUEST", user_context=owner)

        visible = vault_service.list_requests(conn, user_context=member)
        private_payload = vault_service.get_request(
            conn,
            private_request["id"],
            user_context=member,
        )
        private_denied = vault_service.deny_request(
            conn,
            private_request["id"],
            user_context=member,
        )
        public_denied = vault_service.deny_request(
            conn,
            public_request["id"],
            user_context=member,
        )
        statuses = dict(
            conn.execute(select(vault_requests.c.id, vault_requests.c.status)).all()
        )

    assert {request["id"] for request in visible} == {
        private_request["id"],
        public_request["id"],
    }
    assert "secret_unlock_material" in private_payload["card"]
    assert statuses == {
        private_request["id"]: "denied",
        public_request["id"]: "denied",
    }
    assert private_denied["status"] == "denied"
    assert public_denied["status"] == "denied"


def test_delete_request_approval_requires_resource_management(vault) -> None:
    owner = _context("owner-1", instance_role="owner")
    member = _context("member-1")
    with vault.begin() as conn:
        _create_secret(conn, "PRIVATE_DELETE")
        _set_policy(conn, "PRIVATE_DELETE", access_level="private")
        request = vault_service.create_delete_request(conn, "PRIVATE_DELETE", user_context=owner)
        with pytest.raises(vault_service.VaultSecretAccessError):
            vault_service.approve_delete_request(conn, request["id"], user_context=member)
        row = conn.execute(select(vault_requests).where(vault_requests.c.id == request["id"])).mappings().one()

    assert row["status"] == "pending"


def test_active_org_member_can_lookup_pending_provision_requests(vault, monkeypatch) -> None:
    member = _context("member-1")
    with vault.begin() as conn:
        provision = vault_service.create_provision_request(conn, "MISSING_SECRET")
        visible, ambiguous = vault_service.resolve_pending_provision_request_by_name(
            conn,
            "MISSING_SECRET",
            user_context=member,
        )
        visible_by_id = vault_service.get_pending_provision_request(
            conn,
            provision["id"],
            user_context=member,
        )

    assert visible is not None
    assert visible["id"] == provision["id"]
    assert ambiguous is False
    assert visible_by_id is not None
    assert visible_by_id["id"] == provision["id"]

    monkeypatch.setattr(api, "_vault_engine", lambda: vault)
    monkeypatch.setattr(api, "resolve_resource_access_context", lambda: member)
    api_by_name = api.get_vault_provision_request_by_name("MISSING_SECRET")
    api_by_id = api.get_vault_provision_request(provision["id"])
    assert api_by_name["request"]["id"] == provision["id"]
    assert api_by_name["ambiguous"] is False
    assert api_by_id["request"]["id"] == provision["id"]


def test_active_org_vault_request_limit_applies_to_complete_result_set(vault) -> None:
    owner = _context("owner-1", instance_role="owner")
    member = _context("member-1")
    with vault.begin() as conn:
        _create_secret(conn, "VISIBLE_REQUEST", protection="protected")
        _create_secret(conn, "HIDDEN_REQUEST", protection="protected")
        _set_policy(conn, "VISIBLE_REQUEST", access_level="public")
        _set_policy(conn, "HIDDEN_REQUEST", access_level="private")
        visible_request = vault_service.create_access_request(conn, "VISIBLE_REQUEST", user_context=owner)
        private_request = vault_service.create_access_request(conn, "HIDDEN_REQUEST", user_context=owner)
        conn.execute(
            vault_requests.update()
            .where(vault_requests.c.id == visible_request["id"])
            .values(created_at="2026-01-01T00:00:00+00:00")
        )
        conn.execute(
            vault_requests.update()
            .where(vault_requests.c.id == private_request["id"])
            .values(created_at="2026-01-01T00:00:01+00:00")
        )

        visible = vault_service.list_requests(conn, limit=1, user_context=member)

    assert [request["id"] for request in visible] == [private_request["id"]]


def test_active_org_member_lists_and_revokes_all_vault_grants(vault) -> None:
    owner = _context("owner-1", instance_role="owner")
    member = _context("member-1")
    with vault.begin() as conn:
        _create_secret(conn, "OWNER_GRANT", protection="protected")
        _create_secret(conn, "MEMBER_GRANT", protection="protected")
        _set_policy(conn, "OWNER_GRANT", access_level="private")
        _set_policy(conn, "MEMBER_GRANT", access_level="private", owner_user_id="member-1")
        owner_request = vault_service.create_access_request(conn, "OWNER_GRANT", user_context=owner)
        member_request = vault_service.create_access_request(conn, "MEMBER_GRANT", user_context=member)
        owner_grant = _grant_from_request(conn, owner_request, user_context=owner)
        member_grant = _grant_from_request(conn, member_request, user_context=member)

        visible = vault_service.list_grants(conn, user_context=member)
        revoked_owner = vault_service.revoke_grant(
            conn,
            owner_grant["id"],
            user_context=member,
        )
        revoked_member = vault_service.revoke_grant(
            conn,
            member_grant["id"],
            user_context=member,
        )

    assert {grant["id"] for grant in visible} == {
        owner_grant["id"],
        member_grant["id"],
    }
    assert revoked_owner["status"] == "revoked"
    assert revoked_member["status"] == "revoked"


def test_active_org_member_audit_limit_uses_complete_event_stream(vault) -> None:
    owner = _context("owner-1", instance_role="owner")
    member = _context("member-1")
    with vault.begin() as conn:
        _create_secret(conn, "OWNER_AUDIT", protection="protected")
        _create_secret(conn, "MEMBER_AUDIT", protection="protected")
        _set_policy(conn, "OWNER_AUDIT", access_level="private")
        _set_policy(conn, "MEMBER_AUDIT", access_level="private", owner_user_id="member-1")
        owner_request = vault_service.create_access_request(conn, "OWNER_AUDIT", user_context=owner)
        owner_grant = _grant_from_request(conn, owner_request, user_context=owner)
        vault_service.audit(conn, "member-event", secret_name="MEMBER_AUDIT")
        vault_service.audit(
            conn,
            "owner-event",
            request_id=owner_request["id"],
            grant_id=owner_grant["id"],
            delivery={"grant_id": owner_grant["id"]},
        )

        visible = vault_service.list_audit(conn, limit=1, user_context=member)

    assert [row["event"] for row in visible] == ["owner-event"]
    assert visible[0]["request_id"] == owner_request["id"]
    assert visible[0]["grant_id"] == owner_grant["id"]


def test_deleted_secret_audit_is_visible_to_active_org_members_without_exposing_tombstone(vault) -> None:
    owner = _context("member-1", instance_role="owner")
    admin = _context("admin-1", role="admin", instance_role="owner")
    member = _context("member-2")
    guest = _external_guest_context()
    with vault.begin() as conn:
        _create_secret(conn, "DELETED_AUDIT", protection="protected")
        _set_policy(conn, "DELETED_AUDIT", access_level="private", owner_user_id="member-1")
        vault_service.audit(conn, "before-delete", secret_name="DELETED_AUDIT")
        vault_service.delete_secret(conn, "DELETED_AUDIT", user_context=admin)

        owner_rows = vault_service.list_audit(conn, secret_name="DELETED_AUDIT", user_context=owner)
        admin_rows = vault_service.list_audit(conn, secret_name="DELETED_AUDIT", user_context=admin)
        member_rows = vault_service.list_audit(conn, secret_name="DELETED_AUDIT", user_context=member)
        guest_rows = vault_service.list_audit(conn, secret_name="DELETED_AUDIT", user_context=guest)

    expected_events = {"before-delete", "deleted"}
    assert expected_events <= {row["event"] for row in owner_rows}
    assert expected_events <= {row["event"] for row in admin_rows}
    assert expected_events <= {row["event"] for row in member_rows}
    assert guest_rows == []
    assert vault_service._AUDIT_ACCESS_SNAPSHOT_KEY not in json.dumps(owner_rows)
    assert vault_service._AUDIT_ACCESS_SNAPSHOT_KEY not in json.dumps(admin_rows)
    assert vault_service._AUDIT_ACCESS_SNAPSHOT_KEY not in json.dumps(member_rows)


def test_acl_filtered_audit_uses_bounded_keyset_batches_until_limit_is_visible(vault, monkeypatch) -> None:
    member = _context("member-1", is_remote=False)
    monkeypatch.setattr(vault_service, "_REMOTE_AUDIT_MIN_BATCH_SIZE", 2)
    monkeypatch.setattr(vault_service, "_REMOTE_AUDIT_MAX_BATCH_SIZE", 2)
    with vault.begin() as conn:
        _create_secret(conn, "BATCH_VISIBLE")
        _create_secret(conn, "BATCH_HIDDEN")
        _set_policy(conn, "BATCH_VISIBLE", access_level="public")
        _set_policy(conn, "BATCH_HIDDEN", access_level="private")
        vault_service.audit(conn, "batch-visible", secret_name="BATCH_VISIBLE")
        for index in range(5):
            vault_service.audit(
                conn,
                f"batch-hidden-{index}",
                secret_name="BATCH_HIDDEN",
            )

        visible = vault_service.list_audit(conn, limit=1, user_context=member)

    assert [row["event"] for row in visible] == ["batch-visible"]
    assert vault_service._AUDIT_ACCESS_SNAPSHOT_KEY not in json.dumps(visible)


def test_vault_api_allows_active_org_member_full_grant_and_audit_access(vault, monkeypatch) -> None:
    owner = _context("owner-1", instance_role="owner")
    member = _context("member-1")
    with vault.begin() as conn:
        _create_secret(conn, "API_OWNER", protection="protected")
        _create_secret(conn, "API_MEMBER", protection="protected")
        _set_policy(conn, "API_OWNER", access_level="private")
        _set_policy(conn, "API_MEMBER", access_level="private", owner_user_id="member-1")
        owner_request = vault_service.create_access_request(conn, "API_OWNER", user_context=owner)
        member_request = vault_service.create_access_request(conn, "API_MEMBER", user_context=member)
        owner_grant = _grant_from_request(conn, owner_request, user_context=owner)
        member_grant = _grant_from_request(conn, member_request, user_context=member)
        vault_service.audit(conn, "api-member-visible", secret_name="API_MEMBER")

    releases: list[list[dict[str, str]]] = []
    monkeypatch.setattr(api, "_vault_engine", lambda: vault)
    monkeypatch.setattr(api, "resolve_resource_access_context", lambda: member)
    monkeypatch.setattr(
        api,
        "release_vault_agent_scopes",
        lambda scopes, *, reason: releases.append([dict(scope) for scope in scopes]),
    )

    grants = api.get_vault_grants()["grants"]
    audit_rows = api.get_vault_audit()["events"]
    revoked = api.revoke_vault_grant(owner_grant["id"])

    with vault.connect() as conn:
        owner_status = conn.execute(
            select(vault_grants.c.status).where(vault_grants.c.id == owner_grant["id"])
        ).scalar_one()

    assert {grant["id"] for grant in grants} == {
        owner_grant["id"],
        member_grant["id"],
    }
    assert "api-member-visible" in {row["event"] for row in audit_rows}
    assert owner_grant["id"] in json.dumps(audit_rows)
    assert revoked["grant"]["status"] == "revoked"
    assert owner_status == "revoked"
    assert releases == [[{"grant_id": owner_grant["id"]}]]


@pytest.mark.parametrize(
    "selector",
    [
        {"env": ["PRIVATE_SELECTOR"]},
        {"tags": ["deploy"]},
        {"skills": ["release"]},
    ],
)
def test_active_org_member_resolves_private_secret_cli_selectors(vault, selector: dict) -> None:
    with vault.begin() as conn:
        _create_secret(conn, "PRIVATE_SELECTOR", tags=["deploy", "skill:release"])
        _set_policy(conn, "PRIVATE_SELECTOR", access_level="private")
        expanded = vault_service.expand_value_delivery_selector(
            conn,
            user_context=_context("member-1"),
            **selector,
        )
        assert list(conn.execute(select(vault_requests)).mappings()) == []
        assert list(conn.execute(select(vault_grants)).mappings()) == []

    assert expanded["secrets"] == [
        {
            "name": "PRIVATE_SELECTOR",
            "field": "value",
            "record": "PRIVATE_SELECTOR",
            "env": "PRIVATE_SELECTOR",
            "kind": "static",
            "protection": "standard",
        }
    ]


def test_remote_created_secret_registers_private_organization_policy(vault) -> None:
    creator = _context("member-1", instance_role="owner")
    with vault.begin() as conn:
        _create_secret(conn, "REMOTE_CREATED", user_context=creator)
        policy = resource_access_service.get_resource_policy(
            "vault_secret",
            _secret_id(conn, "REMOTE_CREATED"),
            connection=conn,
        )

    assert policy is not None
    assert policy["organization_id"] == "org-1"
    assert policy["owner_user_id"] == "member-1"
    assert policy["access_level"] == "private"


def test_vault_secret_removal_deletes_resource_policy_and_groups(vault) -> None:
    with vault.begin() as conn:
        _create_secret(conn, "REMOVED_SECRET")
        resource_id = _set_policy(
            conn,
            "REMOVED_SECRET",
            access_level="scope",
            group_ids=["group-engineering"],
        )

        vault_service.delete_secret(
            conn,
            "REMOVED_SECRET",
            user_context=_context("owner-1", instance_role="owner"),
        )
        policies = conn.execute(
            select(resource_access_policies).where(
                resource_access_policies.c.resource_kind == "vault_secret",
                resource_access_policies.c.resource_id == resource_id,
            )
        ).all()
        groups = conn.execute(
            select(resource_access_groups).where(
                resource_access_groups.c.resource_kind == "vault_secret",
                resource_access_groups.c.resource_id == resource_id,
            )
        ).all()

    assert policies == []
    assert groups == []


def test_active_org_admin_can_manage_public_vault_secret(vault) -> None:
    with vault.begin() as conn:
        _create_secret(conn, "PUBLIC_MANAGEMENT")
        _set_policy(conn, "PUBLIC_MANAGEMENT", access_level="public")

        # Reads stay open to every active Organization member.
        assert vault_service.get_secret_meta(
            conn,
            "PUBLIC_MANAGEMENT",
            user_context=_context("member-1"),
        )["name"] == "PUBLIC_MANAGEMENT"
        # Instance Editor cannot manage secrets, regardless of Organization role.
        with pytest.raises(vault_service.VaultSecretAccessError):
            vault_service.update_secret_metadata(
                conn,
                "PUBLIC_MANAGEMENT",
                description="member update",
                user_context=_context("member-1"),
            )
        updated = vault_service.update_secret_metadata(
            conn,
            "PUBLIC_MANAGEMENT",
            description="admin update",
            user_context=_context("admin-1", role="admin", instance_role="owner"),
        )
        vault_service.delete_secret(
            conn,
            "PUBLIC_MANAGEMENT",
            user_context=_context("admin-1", role="admin", instance_role="owner"),
        )
        stored = conn.execute(
            select(vault_secrets).where(vault_secrets.c.name == "PUBLIC_MANAGEMENT")
        ).first()

    assert updated["description"] == "admin update"
    assert stored is None


def test_active_org_member_can_create_vault_secret_but_external_guest_cannot(vault) -> None:
    guest = _external_guest_context()

    with vault.begin() as conn:
        _create_secret(
            conn,
            "MEMBER_CREATED",
            user_context=_context("member-1"),
        )
        with pytest.raises(vault_service.VaultSecretAccessError):
            _create_secret(conn, "GUEST_CREATED", user_context=guest)
        assert conn.execute(
            select(vault_secrets).where(vault_secrets.c.name == "MEMBER_CREATED")
        ).first() is not None
        assert conn.execute(select(vault_secrets).where(vault_secrets.c.name == "GUEST_CREATED")).first() is None


@pytest.mark.parametrize(
    ("initial_level", "initial_groups", "updated_level", "updated_groups"),
    [
        ("public", None, "scope", ["group-engineering"]),
        ("scope", ["group-engineering", "group-sales"], "scope", ["group-engineering"]),
        ("private", None, "scope", ["group-sales"]),
    ],
)
def test_narrowed_vault_policy_revokes_active_grants(
    vault,
    monkeypatch,
    initial_level: str,
    initial_groups: list[str] | None,
    updated_level: str,
    updated_groups: list[str],
) -> None:
    owner = _context("owner-1", instance_role="owner")
    with vault.begin() as conn:
        _create_secret(conn, "NARROWED_KEY", protection="protected")
        resource_id = _set_policy(
            conn,
            "NARROWED_KEY",
            access_level=initial_level,
            group_ids=initial_groups,
        )
        request = vault_service.create_access_request(conn, "NARROWED_KEY", user_context=owner)
        grant = _grant_from_request(conn, request, user_context=owner)

    monkeypatch.setattr("storage.db.get_cached_sqlite_engine", lambda: vault)
    monkeypatch.setattr(
        remote_access,
        "publish_resource_index",
        lambda *_args, **_kwargs: {"organization_id": "org-1", "resources": []},
    )
    monkeypatch.setattr(
        remote_access,
        "pull_resource_acl_intents",
        lambda *_args, **_kwargs: {
            "organization_id": "org-1",
            "intents": [
                {
                    "resource_kind": "vault_secret",
                    "resource_id": resource_id,
                    "revision": 2,
                    "access_level": updated_level,
                    "group_ids": updated_groups,
                }
            ],
        },
    )
    monkeypatch.setattr(remote_access, "acknowledge_resource_acl_intent", lambda *_args, **_kwargs: {})
    releases: list[dict] = []
    monkeypatch.setattr(
        remote_access.api,
        "release_vault_agent_scopes",
        lambda scopes, *, reason: releases.append({"scopes": scopes, "reason": reason}),
    )

    result = remote_access._sync_one_organization(None, organization_id="org-1", resources=[])

    assert result["applied"] == 1
    with vault.connect() as conn:
        status = conn.execute(select(vault_grants.c.status).where(vault_grants.c.id == grant["id"])).scalar_one()
    assert status == "revoked"
    assert releases == [{"scopes": [{"grant_id": grant["id"]}], "reason": "resource-access-policy-narrowed"}]


def test_narrowed_vault_release_failure_stays_pending_until_retry_succeeds(vault, monkeypatch) -> None:
    owner = _context("owner-1", instance_role="owner")
    with vault.begin() as conn:
        _create_secret(conn, "RETRY_RELEASE_KEY", protection="protected")
        resource_id = _set_policy(conn, "RETRY_RELEASE_KEY", access_level="public")
        request = vault_service.create_access_request(conn, "RETRY_RELEASE_KEY", user_context=owner)
        grant = _grant_from_request(conn, request, user_context=owner)

    intent = {
        "resource_kind": "vault_secret",
        "resource_id": resource_id,
        "revision": 2,
        "access_level": "private",
        "group_ids": [],
    }
    monkeypatch.setattr("storage.db.get_cached_sqlite_engine", lambda: vault)
    monkeypatch.setattr(
        remote_access,
        "publish_resource_index",
        lambda *_args, **_kwargs: {"organization_id": "org-1", "resources": []},
    )
    monkeypatch.setattr(
        remote_access,
        "pull_resource_acl_intents",
        lambda *_args, **_kwargs: {"organization_id": "org-1", "intents": [intent]},
    )
    acknowledgements: list[dict] = []
    monkeypatch.setattr(
        remote_access,
        "acknowledge_resource_acl_intent",
        lambda *_args, **kwargs: acknowledgements.append(kwargs),
    )
    releases: list[list[dict[str, str]]] = []

    def release(scopes, *, reason):
        releases.append([dict(scope) for scope in scopes])
        if len(releases) == 1:
            raise RuntimeError("resident release failed")

    monkeypatch.setattr(remote_access.api, "release_vault_agent_scopes", release)

    first = remote_access._sync_one_organization(None, organization_id="org-1", resources=[])
    pending_key = remote_access._pending_vault_release_key("org-1", resource_id, 2)
    with vault.connect() as conn:
        pending_after_failure = conn.execute(
            select(state_meta.c.value_json).where(state_meta.c.key == pending_key)
        ).scalar_one_or_none()

    second = remote_access._sync_one_organization(None, organization_id="org-1", resources=[])
    with vault.connect() as conn:
        pending_after_success = conn.execute(
            select(state_meta.c.value_json).where(state_meta.c.key == pending_key)
        ).scalar_one_or_none()

    assert first["ok"] is False
    assert first["applied"] == 1
    assert first["acknowledged"] == 0
    assert first["ack_errors"] == 1
    assert pending_after_failure is not None
    assert second["ok"] is True
    assert second["acknowledged"] == 1
    assert pending_after_success is None
    assert releases == [[{"grant_id": grant["id"]}], [{"grant_id": grant["id"]}]]
    assert acknowledgements == [
        {
            "resource_kind": "vault_secret",
            "resource_id": resource_id,
            "revision": 2,
            "outcome": "applied",
        }
    ]


@pytest.mark.parametrize("role", ["owner", "member", "editor", "viewer"])
def test_secret_management_follows_instance_manager_capability(vault, role):
    context = _context("manager", instance_role=role)
    with vault.begin() as conn:
        _create_secret(conn, "MANAGED_KEY")
        operations = (
            lambda: vault_service.update_secret_tags(conn, "MANAGED_KEY", ["test"], user_context=context),
            lambda: vault_service.update_secret_metadata(conn, "MANAGED_KEY", description="managed", user_context=context),
            lambda: vault_service.update_secret_field(conn, "MANAGED_KEY", "username", _sealed("user"), record="MANAGED_KEY.username", user_context=context),
            lambda: vault_service.update_secret_field(conn, "MANAGED_KEY", "value", _sealed("default"), record="MANAGED_KEY", user_context=context),
            lambda: vault_service.update_secret_metadata(conn, "MANAGED_KEY", default_field="password", user_context=context),
            lambda: vault_service.remove_secret_field(conn, "MANAGED_KEY", "username", user_context=context),
            lambda: vault_service.update_secret_classification(conn, "MANAGED_KEY", protection="protected", user_context=context),
            lambda: vault_service.store_pubkey_pin(conn, "MANAGED_KEY", {"fingerprint": "test-pin"}, user_context=context),
            lambda: vault_service.rotate_secret(conn, "MANAGED_KEY", _sealed("rotated"), user_context=context),
            lambda: vault_service.delete_secret(conn, "MANAGED_KEY", user_context=context),
        )
        for operation in operations:
            if role in {"owner", "member"}:
                operation()
            else:
                with pytest.raises(vault_service.VaultSecretAccessError):
                    operation()
        if role in {"owner", "member"}:
            with pytest.raises(vault_service.SecretNotFoundError):
                vault_service.get_secret_meta(conn, "MANAGED_KEY")
        else:
            assert vault_service.get_secret_meta(conn, "MANAGED_KEY")["tags"] == []


@pytest.mark.parametrize("policy", ["missing", "foreign"])
@pytest.mark.parametrize("role", ["owner", "member", "editor", "viewer"])
def test_direct_secret_operations_preserve_protected_approval_and_lower_role_acl(vault, policy, role):
    context = _context("manager", instance_role=role, is_remote=False)
    with vault.begin() as conn:
        _create_secret(conn, "DIRECT_PRIVATE", protection="protected")
        resource_id = _secret_id(conn, "DIRECT_PRIVATE")
        conn.execute(resource_access_policies.delete().where(resource_access_policies.c.resource_id == resource_id))
        if policy == "foreign":
            resource_access_service.ensure_resource_policy(
                conn, resource_kind="vault_secret", resource_id=resource_id,
                organization_id="foreign-org", owner_user_id="foreign-user",
                access_level="private", group_ids=[], policy_revision=1,
                last_applied_control_plane_revision=1,
            )
        before = [dict(row) for row in conn.execute(select(resource_access_policies)).mappings()]
        if role in {"owner", "member"}:
            vault_service.update_secret_metadata(conn, "DIRECT_PRIVATE", description="managed", user_context=context)
            access = vault_service.resolve_secret_access(conn, "DIRECT_PRIVATE", session_id="ses-private", user_context=context)
            assert access["status"] == "approval_required"
            assert access["request"]["status"] == "pending"
            assert access.get("envelope") is None
            assert access["request"]["card"]["value"] is None
        else:
            with pytest.raises(vault_service.VaultSecretAccessError):
                vault_service.resolve_secret_access(conn, "DIRECT_PRIVATE", session_id="ses-private", user_context=context)
        assert [dict(row) for row in conn.execute(select(resource_access_policies)).mappings()] == before