vaid-a2a 0.1.1__tar.gz

vaid_a2a-0.1.1/.gitignore

@@ -0,0 +1,30 @@
+# Rust
+/target
+**/*.rs.bk
+Cargo.lock.orig
+
+# Backtraces
+rustc-ice-*.txt
+
+# Editor / OS
+.DS_Store
+*.swp
+.idea/
+.vscode/
+
+# Python
+__pycache__/
+*.py[cod]
+.pytest_cache/
+*.egg-info/
+dist/
+build/
+.venv/
+.buildvenv/
+.installtest/
+
+# TypeScript / npm
+node_modules/
+typescript/*/dist/
+typescript/*/test-dist/
+*.tsbuildinfo

vaid_a2a-0.1.1/PKG-INFO

@@ -0,0 +1,216 @@
+Metadata-Version: 2.5
+Name: vaid-a2a
+Version: 0.1.1
+Summary: Reference verifier for the VAID A2A extension (docs/a2a/v1/extension.md): checks a VAID carried in an A2A Message against signature, expiry, chain attenuation, requested-action scope and revocation.
+Project-URL: Homepage, https://github.com/solara-associates/vaid
+Project-URL: Repository, https://github.com/solara-associates/vaid
+Project-URL: Source, https://github.com/solara-associates/vaid/tree/main/python/vaid-a2a
+Project-URL: Issues, https://github.com/solara-associates/vaid/issues
+Author: solara.associates
+Author-email: "solara.associates" <info@solara.associates>
+License: Apache-2.0
+Keywords: a2a,agent-identity,agent2agent,attenuation,delegation,vaid
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Requires-Dist: vaid-mint<0.10,>=0.9.0
+Provides-Extra: test
+Requires-Dist: pytest>=8.0; extra == 'test'
+Description-Content-Type: text/markdown
+
+# vaid-a2a
+
+Reference verifier for the VAID [A2A](https://a2a-protocol.org) extension
+specified in [`docs/a2a/v1/extension.md`](../../docs/a2a/v1/extension.md)
+(**draft**).
+
+A2A lets agents delegate work to agents. [a2aproject/A2A#2028](https://github.com/a2aproject/A2A/issues/2028)
+proposes `actorChain`, a caller-supplied record of who acted for whom, and is
+explicit that a self-reported chain can narrow perfectly while proving no
+actual authority. This extension supplies one concrete, offline-checkable
+proof a hop can point at to fill that gap: a VAID — a signed, attenuated,
+revocable delegation document this repo already mints and verifies in three
+languages.
+
+This package does not implement the extension's wire format; it implements
+the **verification side**: given an A2A `Message` (as a plain `dict`) and a
+trust configuration, it extracts any VAID(s) carried under the extension's
+metadata keys and runs the ordered check the spec defines, returning a typed
+allow/deny result with a reason — never a bare boolean, so a caller can log,
+alert, or retry the right thing.
+
+## Install
+
+```sh
+pip install -e python/vaid-pop -e python/vaid-mint -e python/vaid-a2a
+```
+
+(No published release yet — this is a draft extension on a feature branch.
+See `docs/a2a/drafts/a2a-2028-reply.md` and the branch's `REPORT-306.md`.)
+
+## Use
+
+```python
+from datetime import datetime, timezone
+
+from vaid_mint.revocation import InMemoryRevocationList
+from vaid_a2a import verify_a2a_message, METADATA_VAID_KEY
+
+trust_config = {
+    "trustedIssuers": [
+        {"trustDomain": "vaid.example", "kernelPublicKey": "<base64url, raw 32 bytes>"}
+    ]
+}
+
+message = {
+    "metadata": {
+        METADATA_VAID_KEY: leaf_vaid_document,       # a dict, as produced by vaid_mint
+        # METADATA_CHAIN_KEY: [ancestor_vaid_1, ...],  # optional, for chain checks
+    }
+}
+
+result = verify_a2a_message(
+    message,
+    trust_config=trust_config,
+    # A plain, never-populated InMemoryRevocationList() is UNAVAILABLE by
+    # design (R.4.5/R.4.6), so this example as written DENIES EVERY REQUEST
+    # with VerifyCode.INDETERMINATE, however valid the VAID is. That is
+    # deliberate: a copy-pasted revocation seam with nothing wired to it
+    # must fail closed, never read as "nothing is revoked". See "Configuring
+    # real revocation" below for what plugging in an actual store takes.
+    revocation=InMemoryRevocationList(),
+    requested_action="data.acme.orders",
+    now=datetime.now(timezone.utc),
+)
+
+if result.allowed:
+    ...  # proceed
+else:
+    ...  # result.code (a VerifyCode) and result.reason explain why
+```
+
+**Valid requests are refused as `indeterminate` until a real
+`RevocationCheck` is configured.** This is not a bug to work around; it is
+the fail-closed default R.4.5 requires. The copy-paste path above stays
+closed on purpose, so a deployment cannot go live by accident with
+revocation silently assumed clean.
+
+See `examples/guard.py` for use as a guard in front of a request handler.
+
+### Configuring real revocation
+
+Implement `vaid_mint.revocation.RevocationCheck` against whatever actually
+tracks revoked VAIDs in your deployment (a database table, a feed, a cache
+in front of either) and pass an instance of it instead of
+`InMemoryRevocationList()`:
+
+```python
+from vaid_mint.revocation import RevocationCheck, RevocationStatus
+
+class DatabaseRevocationCheck:
+    """Minimal real RevocationCheck: ask the database once per lineage."""
+
+    def __init__(self, db):
+        self._db = db
+
+    def check_lineage(self, lineage: list[str]) -> RevocationStatus:
+        try:
+            revoked_ids = self._db.revoked_vaid_ids(lineage)
+        except Exception:
+            return RevocationStatus.UNAVAILABLE  # fail closed, not NOT_REVOKED
+        if revoked_ids:
+            return RevocationStatus.REVOKED
+        return RevocationStatus.NOT_REVOKED
+
+result = verify_a2a_message(
+    message,
+    trust_config=trust_config,
+    revocation=DatabaseRevocationCheck(db),
+    requested_action="data.acme.orders",
+    now=datetime.now(timezone.utc),
+)
+```
+
+`check_lineage` receives the full ordered lineage (root first, leaf last)
+that `verify_a2a_message` already assembled; it is never asked to resolve
+ancestry itself (R.4.1). `RevocationStatus` is three-valued on purpose: a
+database error or an unreachable feed must report `UNAVAILABLE`, never
+`NOT_REVOKED`.
+
+### Local demo only, never production
+
+`InMemoryRevocationList.assume_nothing_revoked()` exists for local demos and
+tests that have no revocation source to wire up and want to exercise the
+rest of the check (signature, expiry, chain, scope) without every call
+denying on revocation. It is **never** appropriate outside a local demo: it
+makes every lineage read as not-revoked, unconditionally, regardless of
+whether anything actually was.
+
+```python
+# LOCAL DEMO ONLY, NEVER PRODUCTION.
+from vaid_mint.revocation import InMemoryRevocationList
+
+demo_result = verify_a2a_message(
+    message,
+    trust_config=trust_config,
+    revocation=InMemoryRevocationList.assume_nothing_revoked(),
+    requested_action="data.acme.orders",
+    now=datetime.now(timezone.utc),
+)
+```
+
+## What this checks, and in what order
+
+Exactly the order `docs/a2a/v1/extension.md` §5 specifies — signature, leaf
+expiry, chain integrity, per-hop attenuation, requested-action scope,
+revocation — fail closed at the first failing step. See the module docstring
+in `vaid_a2a/verifier.py` for the full reasoning behind the order; it mirrors
+`vaid_mint.verify` and `vaid_mint.chain`, which this package delegates to
+rather than reimplements.
+
+| step | delegates to |
+|---|---|
+| 1. signature / authenticity | `vaid_mint.verify.verify_vaid_authenticity_graded` |
+| 2. leaf expiry | `vaid_mint.document.is_expired_at` |
+| 3. chain integrity | `vaid_mint.chain.verify_chain_at` |
+| 4. per-hop attenuation | `vaid_mint.chain.verify_chain_at` (same call) |
+| 5. requested action in leaf scope | `vaid_mint.document.is_in_scope` |
+| 6. revocation over the full lineage | the caller's own `vaid_mint.revocation.RevocationCheck` |
+
+## Test vectors
+
+`tests/test_vectors.py` runs every vector in `docs/a2a/v1/vectors/*.json` and
+asserts the expected result. Regenerate the vectors from `vaid-mint` tooling
+with `docs/a2a/v1/vectors/generate_vectors.py`; see that directory's own README.
+
+## Packaged conformance firewall
+
+The vectors above also ship **inside the wheel**, so an installed copy can be
+checked without this repository:
+
+```
+vaid-a2a-conformance           # exit 0 = PASS, 1 = BLOCKER
+python -m vaid_a2a.conformance  # same
+```
+
+It replays all 12 extension vectors through `verify_a2a_message` and asserts the
+`(result, error_code)` pair `docs/a2a/v1/extension.md` section 5 specifies for
+each, at the verification instant each vector names rather than the wall clock.
+It pins **verdicts**, not bytes: this package signs and canonicalizes nothing of
+its own, and the bytes beneath it are proven by `vaid-mint-conformance`. The
+bundled vectors are byte-identical to `docs/a2a/v1/vectors/`, which CI checks
+by comparing the file listings and then every file.
+
+## Non-goals
+
+- Does not depend on `a2a-python` or any A2A SDK — `Message` is accepted as a
+  plain `dict`, so this works against any A2A server or client.
+- Does not mint VAIDs (`vaid_mint.mint.MintService`) or implement revocation
+  transport (`docs/spec/revocation.md` R.1) — both out of scope here, as they
+  are for the extension itself.
+- Does not implement `actorChain` (#2028) or require it to be present; see
+  the spec's §4.1 for how the two compose when both are active.

vaid_a2a-0.1.1/README.md

@@ -0,0 +1,192 @@
+# vaid-a2a
+
+Reference verifier for the VAID [A2A](https://a2a-protocol.org) extension
+specified in [`docs/a2a/v1/extension.md`](../../docs/a2a/v1/extension.md)
+(**draft**).
+
+A2A lets agents delegate work to agents. [a2aproject/A2A#2028](https://github.com/a2aproject/A2A/issues/2028)
+proposes `actorChain`, a caller-supplied record of who acted for whom, and is
+explicit that a self-reported chain can narrow perfectly while proving no
+actual authority. This extension supplies one concrete, offline-checkable
+proof a hop can point at to fill that gap: a VAID — a signed, attenuated,
+revocable delegation document this repo already mints and verifies in three
+languages.
+
+This package does not implement the extension's wire format; it implements
+the **verification side**: given an A2A `Message` (as a plain `dict`) and a
+trust configuration, it extracts any VAID(s) carried under the extension's
+metadata keys and runs the ordered check the spec defines, returning a typed
+allow/deny result with a reason — never a bare boolean, so a caller can log,
+alert, or retry the right thing.
+
+## Install
+
+```sh
+pip install -e python/vaid-pop -e python/vaid-mint -e python/vaid-a2a
+```
+
+(No published release yet — this is a draft extension on a feature branch.
+See `docs/a2a/drafts/a2a-2028-reply.md` and the branch's `REPORT-306.md`.)
+
+## Use
+
+```python
+from datetime import datetime, timezone
+
+from vaid_mint.revocation import InMemoryRevocationList
+from vaid_a2a import verify_a2a_message, METADATA_VAID_KEY
+
+trust_config = {
+    "trustedIssuers": [
+        {"trustDomain": "vaid.example", "kernelPublicKey": "<base64url, raw 32 bytes>"}
+    ]
+}
+
+message = {
+    "metadata": {
+        METADATA_VAID_KEY: leaf_vaid_document,       # a dict, as produced by vaid_mint
+        # METADATA_CHAIN_KEY: [ancestor_vaid_1, ...],  # optional, for chain checks
+    }
+}
+
+result = verify_a2a_message(
+    message,
+    trust_config=trust_config,
+    # A plain, never-populated InMemoryRevocationList() is UNAVAILABLE by
+    # design (R.4.5/R.4.6), so this example as written DENIES EVERY REQUEST
+    # with VerifyCode.INDETERMINATE, however valid the VAID is. That is
+    # deliberate: a copy-pasted revocation seam with nothing wired to it
+    # must fail closed, never read as "nothing is revoked". See "Configuring
+    # real revocation" below for what plugging in an actual store takes.
+    revocation=InMemoryRevocationList(),
+    requested_action="data.acme.orders",
+    now=datetime.now(timezone.utc),
+)
+
+if result.allowed:
+    ...  # proceed
+else:
+    ...  # result.code (a VerifyCode) and result.reason explain why
+```
+
+**Valid requests are refused as `indeterminate` until a real
+`RevocationCheck` is configured.** This is not a bug to work around; it is
+the fail-closed default R.4.5 requires. The copy-paste path above stays
+closed on purpose, so a deployment cannot go live by accident with
+revocation silently assumed clean.
+
+See `examples/guard.py` for use as a guard in front of a request handler.
+
+### Configuring real revocation
+
+Implement `vaid_mint.revocation.RevocationCheck` against whatever actually
+tracks revoked VAIDs in your deployment (a database table, a feed, a cache
+in front of either) and pass an instance of it instead of
+`InMemoryRevocationList()`:
+
+```python
+from vaid_mint.revocation import RevocationCheck, RevocationStatus
+
+class DatabaseRevocationCheck:
+    """Minimal real RevocationCheck: ask the database once per lineage."""
+
+    def __init__(self, db):
+        self._db = db
+
+    def check_lineage(self, lineage: list[str]) -> RevocationStatus:
+        try:
+            revoked_ids = self._db.revoked_vaid_ids(lineage)
+        except Exception:
+            return RevocationStatus.UNAVAILABLE  # fail closed, not NOT_REVOKED
+        if revoked_ids:
+            return RevocationStatus.REVOKED
+        return RevocationStatus.NOT_REVOKED
+
+result = verify_a2a_message(
+    message,
+    trust_config=trust_config,
+    revocation=DatabaseRevocationCheck(db),
+    requested_action="data.acme.orders",
+    now=datetime.now(timezone.utc),
+)
+```
+
+`check_lineage` receives the full ordered lineage (root first, leaf last)
+that `verify_a2a_message` already assembled; it is never asked to resolve
+ancestry itself (R.4.1). `RevocationStatus` is three-valued on purpose: a
+database error or an unreachable feed must report `UNAVAILABLE`, never
+`NOT_REVOKED`.
+
+### Local demo only, never production
+
+`InMemoryRevocationList.assume_nothing_revoked()` exists for local demos and
+tests that have no revocation source to wire up and want to exercise the
+rest of the check (signature, expiry, chain, scope) without every call
+denying on revocation. It is **never** appropriate outside a local demo: it
+makes every lineage read as not-revoked, unconditionally, regardless of
+whether anything actually was.
+
+```python
+# LOCAL DEMO ONLY, NEVER PRODUCTION.
+from vaid_mint.revocation import InMemoryRevocationList
+
+demo_result = verify_a2a_message(
+    message,
+    trust_config=trust_config,
+    revocation=InMemoryRevocationList.assume_nothing_revoked(),
+    requested_action="data.acme.orders",
+    now=datetime.now(timezone.utc),
+)
+```
+
+## What this checks, and in what order
+
+Exactly the order `docs/a2a/v1/extension.md` §5 specifies — signature, leaf
+expiry, chain integrity, per-hop attenuation, requested-action scope,
+revocation — fail closed at the first failing step. See the module docstring
+in `vaid_a2a/verifier.py` for the full reasoning behind the order; it mirrors
+`vaid_mint.verify` and `vaid_mint.chain`, which this package delegates to
+rather than reimplements.
+
+| step | delegates to |
+|---|---|
+| 1. signature / authenticity | `vaid_mint.verify.verify_vaid_authenticity_graded` |
+| 2. leaf expiry | `vaid_mint.document.is_expired_at` |
+| 3. chain integrity | `vaid_mint.chain.verify_chain_at` |
+| 4. per-hop attenuation | `vaid_mint.chain.verify_chain_at` (same call) |
+| 5. requested action in leaf scope | `vaid_mint.document.is_in_scope` |
+| 6. revocation over the full lineage | the caller's own `vaid_mint.revocation.RevocationCheck` |
+
+## Test vectors
+
+`tests/test_vectors.py` runs every vector in `docs/a2a/v1/vectors/*.json` and
+asserts the expected result. Regenerate the vectors from `vaid-mint` tooling
+with `docs/a2a/v1/vectors/generate_vectors.py`; see that directory's own README.
+
+## Packaged conformance firewall
+
+The vectors above also ship **inside the wheel**, so an installed copy can be
+checked without this repository:
+
+```
+vaid-a2a-conformance           # exit 0 = PASS, 1 = BLOCKER
+python -m vaid_a2a.conformance  # same
+```
+
+It replays all 12 extension vectors through `verify_a2a_message` and asserts the
+`(result, error_code)` pair `docs/a2a/v1/extension.md` section 5 specifies for
+each, at the verification instant each vector names rather than the wall clock.
+It pins **verdicts**, not bytes: this package signs and canonicalizes nothing of
+its own, and the bytes beneath it are proven by `vaid-mint-conformance`. The
+bundled vectors are byte-identical to `docs/a2a/v1/vectors/`, which CI checks
+by comparing the file listings and then every file.
+
+## Non-goals
+
+- Does not depend on `a2a-python` or any A2A SDK — `Message` is accepted as a
+  plain `dict`, so this works against any A2A server or client.
+- Does not mint VAIDs (`vaid_mint.mint.MintService`) or implement revocation
+  transport (`docs/spec/revocation.md` R.1) — both out of scope here, as they
+  are for the extension itself.
+- Does not implement `actorChain` (#2028) or require it to be present; see
+  the spec's §4.1 for how the two compose when both are active.

vaid_a2a-0.1.1/examples/guard.py

@@ -0,0 +1,54 @@
+"""A minimal example: use vaid_a2a.verify_a2a_message as a guard in front of
+an A2A request handler. Not wired to any specific A2A server framework —
+`handle_message` below is the shape any framework's message handler takes.
+"""
+
+from __future__ import annotations
+
+from vaid_a2a import METADATA_VAID_KEY, VerifyCode, verify_a2a_message
+from vaid_mint.revocation import RevocationCheck
+
+# Loaded once at startup from the AgentCard's own extension declaration.
+TRUST_CONFIG = {
+    "trustedIssuers": [
+        {"trustDomain": "vaid.example", "kernelPublicKey": "<base64url, raw 32 bytes>"},
+    ]
+}
+
+
+def handle_message(message: dict, revocation: RevocationCheck) -> dict:
+    """A stand-in for a real A2A message handler. ``message`` is the incoming
+    A2A ``Message`` as a dict; ``action`` is whatever this handler is about
+    to do, used as the ``requested_action`` scope check."""
+    action = "data.acme.orders"
+
+    result = verify_a2a_message(
+        message,
+        trust_config=TRUST_CONFIG,
+        revocation=revocation,
+        requested_action=action,
+    )
+
+    if not result.allowed:
+        # result.code is a VerifyCode — map it to whatever error shape this
+        # handler's A2A transport expects (see docs/a2a/v1/extension.md §6).
+        return {
+            "error": {
+                "code": result.code.value,
+                "message": result.reason,
+            }
+        }
+
+    if result.code is VerifyCode.NO_VAID:
+        # The extension was not activated, or carried no VAID, and
+        # requireVaid was false — this handler's own policy decides whether
+        # that is acceptable for this action. Shown here for completeness;
+        # a handler that requires a VAID for every action should instead
+        # pass require_vaid=True above and never reach this branch.
+        pass
+
+    return {"result": f"handled action {action!r}"}
+
+
+if __name__ == "__main__":
+    print(METADATA_VAID_KEY)

vaid_a2a-0.1.1/pyproject.toml

@@ -0,0 +1,68 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "vaid-a2a"
+version = "0.1.1"
+description = "Reference verifier for the VAID A2A extension (docs/a2a/v1/extension.md): checks a VAID carried in an A2A Message against signature, expiry, chain attenuation, requested-action scope and revocation."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "Apache-2.0" }
+authors = [
+    # Two entries by design: PEP 621 routes any entry that has an email
+    # entirely into Author-email, leaving the core Author field empty (PyPI
+    # then renders "Author: None"). The name-only entry populates Author;
+    # the second preserves the existing Author-email verbatim.
+    { name = "solara.associates" },
+    { name = "solara.associates", email = "info@solara.associates" },
+]
+keywords = ["vaid", "a2a", "agent-identity", "delegation", "attenuation", "agent2agent"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "License :: OSI Approved :: Apache Software License",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+# vaid-mint supplies verification, chain-attenuation and revocation primitives
+# (vaid_mint.verify, vaid_mint.chain, vaid_mint.document, vaid_mint.revocation) —
+# this package is a thin extraction-and-ordering layer over them, not a second
+# implementation. No dependency on a2a-python or any A2A SDK: Message is accepted
+# as a plain dict so this works against any A2A server or client, per the brief.
+dependencies = [
+    "vaid-mint>=0.9.0,<0.10",
+]
+
+[project.scripts]
+# The packaged firewall: an external consumer who installed ONLY the wheel can run
+# `vaid-a2a-conformance` to prove the verifier they got reaches the verdict
+# docs/a2a/v1/extension.md specifies for every published extension vector. It pins
+# VERDICTS, not bytes - see the module docstring on why that is the normative
+# surface for a verifier, and why it is a different claim rather than a weaker one.
+vaid-a2a-conformance = "vaid_a2a.conformance:main"
+
+[project.optional-dependencies]
+test = [
+    "pytest>=8.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/solara-associates/vaid"
+Repository = "https://github.com/solara-associates/vaid"
+Source = "https://github.com/solara-associates/vaid/tree/main/python/vaid-a2a"
+Issues = "https://github.com/solara-associates/vaid/issues"
+
+[tool.hatch.build.targets.wheel]
+# The extension vectors ship inside the wheel (vaid_a2a/vectors/, vendored
+# byte-identically from docs/a2a/v1/vectors/ and cmp-checked in CI) so a
+# consumer's firewall runs against the exact bytes this verifier was proven
+# against - the same reason vaid_pop and vaid_mint bundle theirs.
+packages = ["vaid_a2a"]
+
+[tool.hatch.build.targets.sdist]
+include = ["vaid_a2a", "tests", "examples", "README.md"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

vaid_a2a-0.1.1/tests/test_vectors.py

@@ -0,0 +1,94 @@
+"""Runs every vector in docs/a2a/v1/vectors/*.json against verify_a2a_message and
+asserts the expected (result, error_code) pair.
+
+The vectors live outside this package, under docs/a2a/v1/vectors/, because they
+are the extension's vectors — not vaid-a2a's private fixtures — and
+test_extension.py-equivalents in other languages would read the same files.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime
+from pathlib import Path
+
+import pytest
+
+from vaid_a2a import METADATA_CHAIN_KEY, METADATA_VAID_KEY, verify_a2a_message
+from vaid_mint.revocation import InMemoryRevocationList
+
+VECTORS_DIR = Path(__file__).resolve().parents[3] / "docs" / "a2a" / "v1" / "vectors"
+
+
+def _parse_verification_time(raw: str) -> datetime:
+    """Parse a vector's own ``verification_time`` (RFC 3339, ``Z`` suffix) —
+    never the wall clock, per the vectors README."""
+    return datetime.fromisoformat(raw.replace("Z", "+00:00"))
+
+
+def _vector_files() -> list[Path]:
+    files = sorted(VECTORS_DIR.glob("*.json"))
+    assert files, f"no vectors found under {VECTORS_DIR} — generator not run?"
+    return files
+
+
+def _load(path: Path) -> dict:
+    return json.loads(path.read_text())
+
+
+def _revocation_for(revoked_ids: list[str]) -> InMemoryRevocationList:
+    store = InMemoryRevocationList()
+    if not revoked_ids:
+        # An empty revocation list must still VOUCH for "nothing revoked",
+        # not read as UNAVAILABLE (R.4.5/R.4.6) — assume_nothing_revoked()
+        # is the explicit, named way to get that posture rather than relying
+        # on an absent store by accident.
+        return InMemoryRevocationList.assume_nothing_revoked()
+    for vaid_id in revoked_ids:
+        store.revoke(vaid_id)
+    return store
+
+
+@pytest.mark.parametrize("vector_path", _vector_files(), ids=lambda p: p.stem)
+def test_vector(vector_path: Path) -> None:
+    vector = _load(vector_path)
+
+    message = {
+        "metadata": {
+            METADATA_VAID_KEY: vector["inputs"]["leaf"],
+            METADATA_CHAIN_KEY: vector["inputs"]["chain"],
+        }
+    }
+    revocation = _revocation_for(vector["revoked_vaid_ids"])
+
+    result = verify_a2a_message(
+        message,
+        trust_config=vector["trust_config"],
+        revocation=revocation,
+        requested_action=vector.get("requested_action"),
+        now=_parse_verification_time(vector["verification_time"]),
+    )
+
+    expected_pass = vector["expected_result"] == "pass"
+    assert result.allowed is expected_pass, (
+        f"{vector_path.name}: expected allowed={expected_pass}, got "
+        f"{result.allowed} ({result.code.value}: {result.reason})"
+    )
+    if vector.get("expected_error_code") is not None:
+        assert result.code.value == vector["expected_error_code"], (
+            f"{vector_path.name}: expected code "
+            f"{vector['expected_error_code']!r}, got {result.code.value!r} "
+            f"({result.reason})"
+        )
+
+
+def test_all_vectors_covered() -> None:
+    """A guard against the parametrized test silently collecting zero cases —
+    the exact "ALL-PASS, a workflow not started" shape: a suite with no
+    vectors loaded would otherwise report a clean, empty pass.
+
+    The floor tracks the number of vectors that actually exist. Left at a
+    stale lower number it stops being a guard against anything but total
+    absence: with 12 vectors published, a floor of 6 would let half of them
+    disappear and still report a clean pass."""
+    assert len(_vector_files()) >= 12