vouch-protocol 2.0.0__tar.gz → 2.0.1__tar.gz

{vouch_protocol-2.0.0/vouch_protocol.egg-info → vouch_protocol-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vouch-protocol
-Version: 2.0.0
+Version: 2.0.1
 Summary: The Identity & Reputation Standard for AI Agents
 Author-email: Vouch Protocol Contributors <hello@vouch-protocol.com>
 License: Apache License 2.0
@@ -229,6 +229,10 @@ Provides-Extra: langchain
 Requires-Dist: langchain>=0.1.0; extra == "langchain"
 Provides-Extra: crewai
 Requires-Dist: crewai>=0.1.0; extra == "crewai"
+Provides-Extra: langgraph
+Requires-Dist: langgraph>=0.1.0; extra == "langgraph"
+Provides-Extra: goose
+Requires-Dist: pyyaml>=6.0; extra == "goose"
 Provides-Extra: autogen
 Requires-Dist: pyautogen>=0.2.0; extra == "autogen"
 Provides-Extra: mcp
@@ -273,7 +277,7 @@ Requires-Dist: base58>=2.1.0; extra == "dev"
 Requires-Dist: qrcode>=7.4.0; extra == "dev"
 Requires-Dist: c2pa-python>=0.5.0; extra == "dev"
 Provides-Extra: all
-Requires-Dist: vouch-protocol[autogen,crewai,dev,enterprise,langchain,mcp,server,streamlit,tracing,vertex]; extra == "all"
+Requires-Dist: vouch-protocol[autogen,crewai,dev,enterprise,goose,langchain,langgraph,mcp,server,streamlit,tracing,vertex]; extra == "all"
 Dynamic: license-file
 
 # Vouch Protocol™
@@ -282,9 +286,9 @@ Dynamic: license-file
  <img src="docs/assets/vouch-wordmark.png" alt="Vouch Protocol" width="400">
 </p>
 
-<sub><em>Vouch Protocol™ — common-law trademark.</em></sub>
+<sub><em>Vouch Protocol™ is a common-law trademark.</em></sub>
 
-<p align="center">The Open Standard for Identity & Provenance of AI Agents</strong>
+<p align="center"><strong>The Open Standard for Identity & Provenance of AI Agents</strong>
 </p>
 
 <p align="center">
@@ -377,8 +381,10 @@ Vouch is not one tool, it is a set of them. Here is the whole map.
 ### Framework integrations (new in v1.6.2)
 Standalone packages that drop Vouch into the agent framework you already use. Each one issues a verifiable credential for a tool call, with optional delegation back to a human principal.
 - **`vouch-langchain`** a LangChain tool that signs each tool call before it leaves the agent.
+- **`vouch-langgraph`** signs LangGraph tool calls and graph nodes, so a signed trail runs across the whole graph.
 - **`vouch-crewai`** a CrewAI tool, with supervisor-to-worker delegation that can only narrow authority, never widen it.
 - **`vouch-a2a`** binds an A2A (Agent2Agent) Agent Card to a Vouch identity, so two agents can verify each other before they collaborate.
+- **`vouch-goose`** registers the Vouch MCP server as an extension for Block's Goose agent, so a Goose session can sign and verify out of the box.
 - **`vouch-mlflow`** signs an MLflow model artifact at registration time, bound to a content digest so any change to the weights breaks the signature.
 - **`vouch-safetensors`** embeds a credential in a `.safetensors` header, complementary to OpenSSF Model Signing, so a model carries who produced it.
 
@@ -388,7 +394,7 @@ The standalone **`vouch-mcp`** package above ships alongside these in v1.6.2.
 Python, TypeScript, and Go are the full reference implementations. A Rust core with idiomatic Swift, JVM (Java and Kotlin), .NET, and C wrappers shares one codebase, so every language produces byte-identical output, verified against shared test vectors. A WebAssembly build is included for the browser and the edge. See the table further down for status per language.
 
 ### Robots and embodied agents
-A robot is an agent with a body, so identity and accountability matter even more once it can cause physical harm. The `vouch.robotics` module ships six capabilities on the same `eddsa-jcs-2022` credentials as the rest of Vouch: hardware-rooted identity (bound to a TPM or secure element, so it cannot be cloned to other hardware), model and config provenance (re-signable on every OTA update), physical capability scope (force, speed, a tighter cap near humans, allowed zones, and shift windows, checked before each actuation, with narrow-only delegation), a robot-to-robot trust handshake, an encrypted tamper-evident black box with a verifiable kill switch, and a scannable offline passport. All six are implemented in Python, TypeScript, Go, and the Rust core, which flows to the Swift, Kotlin/JVM, .NET, C/C++, and WebAssembly wrappers, so a robotics credential signed in one language verifies in every other. Eleven further capabilities round out the set: a living-trust heartbeat (a signed per-interval motion summary whose trust decays unless it is renewed in-envelope), two-level credential revocation (per-credential status lists and whole-DID kill), an accountable safety record (a tamper-evident incident ledger summarized into a portable signed record), signed perception provenance (each captured sensor frame's hash bound to the robot's key and hash-linked, so a robot can prove what its sensors saw and a substituted frame is detectable), an offline delegation lease (a short-lived, scope-bounded grant a disconnected robot verifies and acts on with no network call, nesting across vendors), a physical quorum (a cryptographic two-person rule requiring M of N attested approvers for a high-consequence action), lifecycle credentials (ownership transfer that chains into a verifiable chain of custody, key rotation that forms a key history, and a signed decommission that retires the robot), a regulatory conformance profile (a machine-checkable mapping from a robot's credentials to the clauses of ISO 10218 and 15066, the EU Machinery Regulation, the EU AI Act, and UL 3300, with a deterministic checker and a signed conformance attestation), post-quantum signing by default (robot credentials sign with the hybrid classical-plus-ML-DSA-44 cryptosuite, with backward-compatible verification, so a robot stays unforgeable across its decade-long life), and cross-embodiment identity continuity (an agent identity that moves between robot bodies, with an embodiment credential re-binding to each body's hardware root and a continuity chain that proves the same accountable agent persisted, plus a fork check), and a physical custody handoff chain (a signed record of who accepted custody of a task or object at each hop across human and robot actors, so an incident traces to the exact hop and an attested condition localizes damage to the holder responsible), implemented across the same languages and pinned by the shared interop vector. See [docs/robotics.md](docs/robotics.md) and the defensive disclosures PAD-064 through PAD-070 and PAD-076 through PAD-084.
+A robot is an agent with a body, so identity and accountability matter even more once it can cause physical harm. The `vouch.robotics` module ships six capabilities on the same `eddsa-jcs-2022` credentials as the rest of Vouch: hardware-rooted identity (bound to a TPM or secure element, so it cannot be cloned to other hardware), model and config provenance (re-signable on every OTA update), physical capability scope (force, speed, a tighter cap near humans, allowed zones, and shift windows, checked before each actuation, with narrow-only delegation), a robot-to-robot trust handshake, an encrypted tamper-evident black box with a verifiable kill switch, and a scannable offline passport. All six are implemented in Python, TypeScript, Go, and the Rust core, which flows to the Swift, Kotlin/JVM, .NET, C/C++, and WebAssembly wrappers, so a robotics credential signed in one language verifies in every other. Fourteen further capabilities round out the set: a living-trust heartbeat (a signed per-interval motion summary whose trust decays unless it is renewed in-envelope), two-level credential revocation (per-credential status lists and whole-DID kill), an accountable safety record (a tamper-evident incident ledger summarized into a portable signed record), signed perception provenance (each captured sensor frame's hash bound to the robot's key and hash-linked, so a robot can prove what its sensors saw and a substituted frame is detectable), an offline delegation lease (a short-lived, scope-bounded grant a disconnected robot verifies and acts on with no network call, nesting across vendors), a physical quorum (a cryptographic two-person rule requiring M of N attested approvers for a high-consequence action), lifecycle credentials (ownership transfer that chains into a verifiable chain of custody, key rotation that forms a key history, and a signed decommission that retires the robot), a regulatory conformance profile (a machine-checkable mapping from a robot's credentials to the clauses of ISO 10218 and 15066, the EU Machinery Regulation, the EU AI Act, and UL 3300, with a deterministic checker and a signed conformance attestation), post-quantum signing by default (robot credentials sign with the hybrid classical-plus-ML-DSA-44 cryptosuite, with backward-compatible verification, so a robot stays unforgeable across its decade-long life), and cross-embodiment identity continuity (an agent identity that moves between robot bodies, with an embodiment credential re-binding to each body's hardware root and a continuity chain that proves the same accountable agent persisted, plus a fork check), a physical custody handoff chain (a signed record of who accepted custody of a task or object at each hop across human and robot actors, so an incident traces to the exact hop and an attested condition localizes damage to the holder responsible), bounded infrastructure access (an operator-signed grant naming a resource, its permitted operations, an optional zone, and a time window, which a robot pairs with a signed request the resource authorizes offline, so a robot can open a door or dock at a charger with a tamper-evident, attributable, shrink-only record), fused-sensor provenance (a signed attestation binding a robot's fused world model to the exact set of input frame hashes and the fusion method that produced it, so a manipulated fusion result or a dropped input is detectable and every fused input traces to a frame the robot recorded), and wear and degradation attestation (a robot signs its own wear level bound to its identity and hash-linked over time, and a deterministic rule narrows its physical capability scope as it degrades, so a worn robot operates inside a tighter, verifiable envelope than the static limit it shipped with), implemented across the same languages and pinned by the shared interop vector. See [docs/robotics.md](docs/robotics.md) and the defensive disclosures PAD-064 through PAD-070, PAD-076 through PAD-084, and PAD-087 through PAD-092.
 
 ### Inside your AI tools
 - **Claude Skill**, **OpenAI Custom GPT**, and **Gemini Gem** packages that teach your AI assistant how to add Vouch to your code, running on your own AI subscription.

{vouch_protocol-2.0.0 → vouch_protocol-2.0.1}/README.md

@@ -4,9 +4,9 @@
  <img src="docs/assets/vouch-wordmark.png" alt="Vouch Protocol" width="400">
 </p>
 
-<sub><em>Vouch Protocol™ — common-law trademark.</em></sub>
+<sub><em>Vouch Protocol™ is a common-law trademark.</em></sub>
 
-<p align="center">The Open Standard for Identity & Provenance of AI Agents</strong>
+<p align="center"><strong>The Open Standard for Identity & Provenance of AI Agents</strong>
 </p>
 
 <p align="center">
@@ -99,8 +99,10 @@ Vouch is not one tool, it is a set of them. Here is the whole map.
 ### Framework integrations (new in v1.6.2)
 Standalone packages that drop Vouch into the agent framework you already use. Each one issues a verifiable credential for a tool call, with optional delegation back to a human principal.
 - **`vouch-langchain`** a LangChain tool that signs each tool call before it leaves the agent.
+- **`vouch-langgraph`** signs LangGraph tool calls and graph nodes, so a signed trail runs across the whole graph.
 - **`vouch-crewai`** a CrewAI tool, with supervisor-to-worker delegation that can only narrow authority, never widen it.
 - **`vouch-a2a`** binds an A2A (Agent2Agent) Agent Card to a Vouch identity, so two agents can verify each other before they collaborate.
+- **`vouch-goose`** registers the Vouch MCP server as an extension for Block's Goose agent, so a Goose session can sign and verify out of the box.
 - **`vouch-mlflow`** signs an MLflow model artifact at registration time, bound to a content digest so any change to the weights breaks the signature.
 - **`vouch-safetensors`** embeds a credential in a `.safetensors` header, complementary to OpenSSF Model Signing, so a model carries who produced it.
 
@@ -110,7 +112,7 @@ The standalone **`vouch-mcp`** package above ships alongside these in v1.6.2.
 Python, TypeScript, and Go are the full reference implementations. A Rust core with idiomatic Swift, JVM (Java and Kotlin), .NET, and C wrappers shares one codebase, so every language produces byte-identical output, verified against shared test vectors. A WebAssembly build is included for the browser and the edge. See the table further down for status per language.
 
 ### Robots and embodied agents
-A robot is an agent with a body, so identity and accountability matter even more once it can cause physical harm. The `vouch.robotics` module ships six capabilities on the same `eddsa-jcs-2022` credentials as the rest of Vouch: hardware-rooted identity (bound to a TPM or secure element, so it cannot be cloned to other hardware), model and config provenance (re-signable on every OTA update), physical capability scope (force, speed, a tighter cap near humans, allowed zones, and shift windows, checked before each actuation, with narrow-only delegation), a robot-to-robot trust handshake, an encrypted tamper-evident black box with a verifiable kill switch, and a scannable offline passport. All six are implemented in Python, TypeScript, Go, and the Rust core, which flows to the Swift, Kotlin/JVM, .NET, C/C++, and WebAssembly wrappers, so a robotics credential signed in one language verifies in every other. Eleven further capabilities round out the set: a living-trust heartbeat (a signed per-interval motion summary whose trust decays unless it is renewed in-envelope), two-level credential revocation (per-credential status lists and whole-DID kill), an accountable safety record (a tamper-evident incident ledger summarized into a portable signed record), signed perception provenance (each captured sensor frame's hash bound to the robot's key and hash-linked, so a robot can prove what its sensors saw and a substituted frame is detectable), an offline delegation lease (a short-lived, scope-bounded grant a disconnected robot verifies and acts on with no network call, nesting across vendors), a physical quorum (a cryptographic two-person rule requiring M of N attested approvers for a high-consequence action), lifecycle credentials (ownership transfer that chains into a verifiable chain of custody, key rotation that forms a key history, and a signed decommission that retires the robot), a regulatory conformance profile (a machine-checkable mapping from a robot's credentials to the clauses of ISO 10218 and 15066, the EU Machinery Regulation, the EU AI Act, and UL 3300, with a deterministic checker and a signed conformance attestation), post-quantum signing by default (robot credentials sign with the hybrid classical-plus-ML-DSA-44 cryptosuite, with backward-compatible verification, so a robot stays unforgeable across its decade-long life), and cross-embodiment identity continuity (an agent identity that moves between robot bodies, with an embodiment credential re-binding to each body's hardware root and a continuity chain that proves the same accountable agent persisted, plus a fork check), and a physical custody handoff chain (a signed record of who accepted custody of a task or object at each hop across human and robot actors, so an incident traces to the exact hop and an attested condition localizes damage to the holder responsible), implemented across the same languages and pinned by the shared interop vector. See [docs/robotics.md](docs/robotics.md) and the defensive disclosures PAD-064 through PAD-070 and PAD-076 through PAD-084.
+A robot is an agent with a body, so identity and accountability matter even more once it can cause physical harm. The `vouch.robotics` module ships six capabilities on the same `eddsa-jcs-2022` credentials as the rest of Vouch: hardware-rooted identity (bound to a TPM or secure element, so it cannot be cloned to other hardware), model and config provenance (re-signable on every OTA update), physical capability scope (force, speed, a tighter cap near humans, allowed zones, and shift windows, checked before each actuation, with narrow-only delegation), a robot-to-robot trust handshake, an encrypted tamper-evident black box with a verifiable kill switch, and a scannable offline passport. All six are implemented in Python, TypeScript, Go, and the Rust core, which flows to the Swift, Kotlin/JVM, .NET, C/C++, and WebAssembly wrappers, so a robotics credential signed in one language verifies in every other. Fourteen further capabilities round out the set: a living-trust heartbeat (a signed per-interval motion summary whose trust decays unless it is renewed in-envelope), two-level credential revocation (per-credential status lists and whole-DID kill), an accountable safety record (a tamper-evident incident ledger summarized into a portable signed record), signed perception provenance (each captured sensor frame's hash bound to the robot's key and hash-linked, so a robot can prove what its sensors saw and a substituted frame is detectable), an offline delegation lease (a short-lived, scope-bounded grant a disconnected robot verifies and acts on with no network call, nesting across vendors), a physical quorum (a cryptographic two-person rule requiring M of N attested approvers for a high-consequence action), lifecycle credentials (ownership transfer that chains into a verifiable chain of custody, key rotation that forms a key history, and a signed decommission that retires the robot), a regulatory conformance profile (a machine-checkable mapping from a robot's credentials to the clauses of ISO 10218 and 15066, the EU Machinery Regulation, the EU AI Act, and UL 3300, with a deterministic checker and a signed conformance attestation), post-quantum signing by default (robot credentials sign with the hybrid classical-plus-ML-DSA-44 cryptosuite, with backward-compatible verification, so a robot stays unforgeable across its decade-long life), and cross-embodiment identity continuity (an agent identity that moves between robot bodies, with an embodiment credential re-binding to each body's hardware root and a continuity chain that proves the same accountable agent persisted, plus a fork check), a physical custody handoff chain (a signed record of who accepted custody of a task or object at each hop across human and robot actors, so an incident traces to the exact hop and an attested condition localizes damage to the holder responsible), bounded infrastructure access (an operator-signed grant naming a resource, its permitted operations, an optional zone, and a time window, which a robot pairs with a signed request the resource authorizes offline, so a robot can open a door or dock at a charger with a tamper-evident, attributable, shrink-only record), fused-sensor provenance (a signed attestation binding a robot's fused world model to the exact set of input frame hashes and the fusion method that produced it, so a manipulated fusion result or a dropped input is detectable and every fused input traces to a frame the robot recorded), and wear and degradation attestation (a robot signs its own wear level bound to its identity and hash-linked over time, and a deterministic rule narrows its physical capability scope as it degrades, so a worn robot operates inside a tighter, verifiable envelope than the static limit it shipped with), implemented across the same languages and pinned by the shared interop vector. See [docs/robotics.md](docs/robotics.md) and the defensive disclosures PAD-064 through PAD-070, PAD-076 through PAD-084, and PAD-087 through PAD-092.
 
 ### Inside your AI tools
 - **Claude Skill**, **OpenAI Custom GPT**, and **Gemini Gem** packages that teach your AI assistant how to add Vouch to your code, running on your own AI subscription.

{vouch_protocol-2.0.0 → vouch_protocol-2.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vouch-protocol"
-version = "2.0.0"
+version = "2.0.1"
 description = "The Identity & Reputation Standard for AI Agents"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -43,6 +43,8 @@ dependencies = [
 # Framework integrations
 langchain = ["langchain>=0.1.0"]
 crewai = ["crewai>=0.1.0"]
+langgraph = ["langgraph>=0.1.0"]
+goose = ["pyyaml>=6.0"]
 autogen = ["pyautogen>=0.2.0"]
 mcp = ["mcp>=0.1.0"]
 vertex = ["google-cloud-aiplatform>=1.0.0"]
@@ -107,7 +109,7 @@ dev = [
 
 # All optional dependencies
 all = [
-    "vouch-protocol[langchain,crewai,autogen,mcp,vertex,streamlit,server,enterprise,tracing,dev]"
+    "vouch-protocol[langchain,crewai,langgraph,goose,autogen,mcp,vertex,streamlit,server,enterprise,tracing,dev]"
 ]
 
 [project.urls]

vouch_protocol-2.0.1/tests/test_caveats.py

@@ -0,0 +1,169 @@
+"""Tests for executable caveats in delegation chains."""
+
+import pytest
+
+from vouch import Signer, generate_identity
+from vouch.caveats import (
+    REASON_BROKEN_CHAIN,
+    REASON_BUDGET_EXCEEDED,
+    REASON_INVALID_LINK_PROOF,
+    REASON_UNKNOWN_TYPE,
+    REASON_UNROOTED,
+    CaveatError,
+    allowlist,
+    build_capability,
+    caveat,
+    chain_caveats,
+    evaluate_caveat,
+    flag_true,
+    incident_gate,
+    rate_limit,
+    running_total_ceiling,
+    time_window,
+    value_ceiling,
+    verify_capability,
+)
+
+
+def _id(domain):
+    kp = generate_identity(domain=domain)
+    return kp, Signer(private_key=kp.private_key_jwk, did=kp.did)
+
+
+class TestEvaluateCaveat:
+    def test_value_ceiling(self):
+        c = value_ceiling("c", field="amount", limit=200)
+        assert evaluate_caveat(c, {"amount": 200}) == (True, None)
+        assert evaluate_caveat(c, {"amount": 201})[0] is False
+
+    def test_running_total_ceiling(self):
+        c = running_total_ceiling("c", limit=1000)
+        assert evaluate_caveat(c, {"amount": 100, "runningTotal": 800}) == (True, None)
+        assert evaluate_caveat(c, {"amount": 300, "runningTotal": 800})[0] is False
+
+    def test_time_window(self):
+        c = time_window("c", start=9, end=17)
+        assert evaluate_caveat(c, {"hour": 9})[0] is True
+        assert evaluate_caveat(c, {"hour": 17})[0] is False
+        assert evaluate_caveat(c, {"hour": 8})[0] is False
+
+    def test_allowlist(self):
+        c = allowlist("c", field="region", values=["eu", "us"])
+        assert evaluate_caveat(c, {"region": "eu"})[0] is True
+        assert evaluate_caveat(c, {"region": "apac"})[0] is False
+
+    def test_flag_and_incident(self):
+        assert evaluate_caveat(flag_true("c", field="shipped"), {"shipped": True})[0] is True
+        assert evaluate_caveat(flag_true("c", field="shipped"), {"shipped": False})[0] is False
+        assert evaluate_caveat(incident_gate("c"), {"incidentActive": True})[0] is True
+        assert evaluate_caveat(incident_gate("c"), {})[0] is False
+
+    def test_rate_limit(self):
+        c = rate_limit("c", max_count=3)
+        assert evaluate_caveat(c, {"recentCount": 2})[0] is True
+        assert evaluate_caveat(c, {"recentCount": 3})[0] is False
+
+    def test_unknown_type_denies(self):
+        allow, reason = evaluate_caveat({"id": "x", "type": "does_not_exist", "params": {}}, {})
+        assert allow is False and reason == REASON_UNKNOWN_TYPE
+
+    def test_deterministic(self):
+        c = value_ceiling("c", limit=10)
+        ctx = {"amount": 5}
+        assert evaluate_caveat(c, ctx) == evaluate_caveat(c, ctx)
+
+    def test_caveat_builder_validates(self):
+        with pytest.raises(CaveatError):
+            caveat("", "value_ceiling")
+
+
+class TestChainAndAccumulation:
+    def _chain(self):
+        skp, store = _id("store.example.com")
+        mkp, mgr = _id("manager.example.com")
+        akp, agent = _id("agent.example.com")
+        link1 = build_capability(
+            store,
+            to=mgr.get_did(),
+            attenuation={"action": "refund"},
+            caveats=[flag_true("shipped-only", field="shipped")],
+        )
+        link2 = build_capability(
+            mgr,
+            to=agent.get_did(),
+            attenuation={"action": "refund", "resource": "usd:<=200"},
+            caveats=[value_ceiling("under-200", field="amount", limit=200)],
+            parent=link1,
+        )
+        keys = {
+            store.get_did(): skp.public_key_jwk,
+            mgr.get_did(): mkp.public_key_jwk,
+            agent.get_did(): akp.public_key_jwk,
+        }
+        return [link1, link2], keys, store.get_did()
+
+    def test_accumulates_both_caveats(self):
+        chain, _, _ = self._chain()
+        assert [c["id"] for c in chain_caveats(chain)] == ["shipped-only", "under-200"]
+
+    def test_all_caveats_satisfied_allows(self):
+        chain, keys, root = self._chain()
+        assert (
+            verify_capability(chain, keys.get, {"shipped": True, "amount": 120}, root_issuer=root)
+            is None
+        )
+
+    def test_ancestor_caveat_binds_descendant(self):
+        chain, keys, root = self._chain()
+        # 'shipped-only' came from the STORE (root); it still blocks the agent.
+        r = verify_capability(chain, keys.get, {"shipped": False, "amount": 120}, root_issuer=root)
+        assert r == "caveat_denied:shipped-only"
+
+    def test_own_caveat_blocks(self):
+        chain, keys, root = self._chain()
+        r = verify_capability(chain, keys.get, {"shipped": True, "amount": 5000}, root_issuer=root)
+        assert r == "caveat_denied:under-200"
+
+    def test_non_removal_via_root_check(self):
+        chain, keys, root = self._chain()
+        # Present only the leaf link, hoping 'shipped-only' vanishes.
+        r = verify_capability(
+            [chain[1]], keys.get, {"shipped": False, "amount": 120}, root_issuer=root
+        )
+        assert r == REASON_UNROOTED
+
+    def test_broken_parent_linkage(self):
+        # Two validly-signed links whose parent pointer does not match the
+        # predecessor actually presented: linkage is broken though both proofs pass.
+        skp, store = _id("store.example.com")
+        mkp, mgr = _id("manager.example.com")
+        akp, agent = _id("agent.example.com")
+        real_parent = build_capability(store, to=mgr.get_did(), attenuation={"action": "refund"})
+        other_parent = build_capability(store, to=mgr.get_did(), attenuation={"action": "read"})
+        leaf = build_capability(
+            mgr, to=agent.get_did(), attenuation={"action": "refund"}, parent=real_parent
+        )
+        keys = {store.get_did(): skp.public_key_jwk, mgr.get_did(): mkp.public_key_jwk}
+        # Present other_parent (valid) in place of real_parent: leaf.parent.digest mismatches.
+        r = verify_capability([other_parent, leaf], keys.get, {}, root_issuer=store.get_did())
+        assert r == REASON_BROKEN_CHAIN
+
+    def test_wrong_key_fails_link_proof(self):
+        chain, keys, root = self._chain()
+        bad = dict(keys)
+        # point the store's DID at a different key
+        okp, _ = _id("other.example.com")
+        bad[chain[0]["issuer"]] = okp.public_key_jwk
+        r = verify_capability(chain, bad.get, {"shipped": True, "amount": 120}, root_issuer=root)
+        assert r == REASON_INVALID_LINK_PROOF
+
+    def test_budget_exceeded(self):
+        chain, keys, root = self._chain()
+        r = verify_capability(
+            chain, keys.get, {"shipped": True, "amount": 120}, root_issuer=root, max_caveats=1
+        )
+        assert r == REASON_BUDGET_EXCEEDED
+
+    def test_empty_chain_rejected(self):
+        with pytest.raises(CaveatError):
+            verify_capability([], {}.get, {})

vouch_protocol-2.0.1/tests/test_deliberation.py

@@ -0,0 +1,179 @@
+"""Tests for Proof of Deliberation (two-phase deliberated execution)."""
+
+from datetime import datetime, timedelta, timezone
+
+import pytest
+
+from vouch import Signer, generate_identity
+from vouch.deliberation import (
+    CLASS_IRREVERSIBLE_FINANCIAL,
+    CLASS_REVERSIBLE,
+    EXECUTE_TYPE,
+    INTENT_TYPE,
+    REASON_INTENT_MISMATCH,
+    REASON_INVALID_PROOF,
+    REASON_UNAUTHORIZED_EXECUTOR,
+    REASON_VETOED,
+    REASON_WINDOW_NOT_ELAPSED,
+    VETO_TYPE,
+    DeliberationError,
+    action_digest,
+    check_execution,
+    commit_intent,
+    execute,
+    requires_window,
+    veto_intent,
+    verify_execution,
+    verify_intent,
+)
+
+WIRE = {"action": "transfer_funds", "target": "acct:vendor-1", "resource": "usd:5000"}
+
+
+def _identity(domain="agent.example.com"):
+    kp = generate_identity(domain=domain)
+    return kp, Signer(private_key=kp.private_key_jwk, did=kp.did)
+
+
+def _committed(agent, controller_did, opened, min_seconds=900):
+    return commit_intent(
+        agent,
+        intent=WIRE,
+        reversibility_class=CLASS_IRREVERSIBLE_FINANCIAL,
+        min_seconds=min_seconds,
+        veto_authorities=[controller_did],
+        opens_at=opened,
+    )
+
+
+class TestClasses:
+    def test_reversible_needs_no_window(self):
+        assert requires_window(CLASS_REVERSIBLE) is False
+        assert requires_window(CLASS_IRREVERSIBLE_FINANCIAL) is True
+
+    def test_irreversible_requires_positive_window(self):
+        _, agent = _identity()
+        with pytest.raises(DeliberationError):
+            commit_intent(
+                agent, intent=WIRE, reversibility_class=CLASS_IRREVERSIBLE_FINANCIAL, min_seconds=0
+            )
+
+    def test_unknown_class_rejected(self):
+        _, agent = _identity()
+        with pytest.raises(DeliberationError):
+            commit_intent(agent, intent=WIRE, reversibility_class="whatever", min_seconds=10)
+
+    def test_intent_needs_action_target(self):
+        _, agent = _identity()
+        with pytest.raises(DeliberationError):
+            commit_intent(agent, intent={"action": "x"}, reversibility_class=CLASS_REVERSIBLE)
+
+
+class TestIntentAndVeto:
+    def test_commit_and_verify_intent(self):
+        akp, agent = _identity()
+        _, ctrl = _identity("controller.example.com")
+        intent = _committed(agent, ctrl.get_did(), datetime.now(timezone.utc))
+        assert INTENT_TYPE in intent["type"]
+        ok, subject = verify_intent(intent, akp.public_key_jwk)
+        assert ok and subject["actionDigest"]["digest"] == action_digest(WIRE)
+
+    def test_veto_binds_to_intent(self):
+        _, agent = _identity()
+        _, ctrl = _identity("controller.example.com")
+        intent = _committed(agent, ctrl.get_did(), datetime.now(timezone.utc))
+        veto = veto_intent(ctrl, intent_credential=intent, reason="no")
+        assert VETO_TYPE in veto["type"]
+        assert veto["credentialSubject"]["intentDigest"]["digest"] == action_digest(WIRE)
+
+
+class TestExecution:
+    def test_clean_window_accepted(self):
+        akp, agent = _identity()
+        _, ctrl = _identity("controller.example.com")
+        opened = datetime.now(timezone.utc)
+        intent = _committed(agent, ctrl.get_did(), opened)
+        ex = execute(agent, intent_credential=intent, closed_at=opened + timedelta(seconds=901))
+        assert EXECUTE_TYPE in ex["type"]
+        assert check_execution(ex, intent, akp.public_key_jwk) is None
+        ok, subject = verify_execution(ex, intent, akp.public_key_jwk)
+        assert ok and subject["intent"] == WIRE
+
+    def test_execute_too_early_rejected(self):
+        akp, agent = _identity()
+        _, ctrl = _identity("controller.example.com")
+        opened = datetime.now(timezone.utc)
+        intent = _committed(agent, ctrl.get_did(), opened)
+        ex = execute(agent, intent_credential=intent, closed_at=opened + timedelta(seconds=60))
+        assert check_execution(ex, intent, akp.public_key_jwk) == REASON_WINDOW_NOT_ELAPSED
+
+    def test_veto_blocks_even_after_window(self):
+        akp, agent = _identity()
+        ckp, ctrl = _identity("controller.example.com")
+        opened = datetime.now(timezone.utc)
+        intent = _committed(agent, ctrl.get_did(), opened)
+        veto = veto_intent(ctrl, intent_credential=intent, reason="over threshold")
+        ex = execute(agent, intent_credential=intent, closed_at=opened + timedelta(seconds=1200))
+        reason = check_execution(
+            ex,
+            intent,
+            akp.public_key_jwk,
+            vetoes=[veto],
+            veto_public_keys={ctrl.get_did(): ckp.public_key_jwk},
+        )
+        assert reason == REASON_VETOED
+
+    def test_veto_from_unlisted_authority_ignored(self):
+        akp, agent = _identity()
+        _, ctrl = _identity("controller.example.com")
+        rkp, rogue = _identity("rogue.example.com")
+        opened = datetime.now(timezone.utc)
+        intent = _committed(agent, ctrl.get_did(), opened)  # only ctrl may veto
+        rogue_veto = veto_intent(rogue, intent_credential=intent, reason="I object")
+        ex = execute(agent, intent_credential=intent, closed_at=opened + timedelta(seconds=1000))
+        reason = check_execution(
+            ex,
+            intent,
+            akp.public_key_jwk,
+            vetoes=[rogue_veto],
+            veto_public_keys={rogue.get_did(): rkp.public_key_jwk},
+        )
+        assert reason is None  # rogue is not in vetoAuthorities
+
+    def test_unauthorized_executor_rejected(self):
+        akp, agent = _identity()
+        _, ctrl = _identity("controller.example.com")
+        bkp, bob = _identity("bob.example.com")
+        opened = datetime.now(timezone.utc)
+        intent = _committed(agent, ctrl.get_did(), opened)
+        # Bob (not the intent issuer) signs an execute for the same intent.
+        ex = execute(bob, intent_credential=intent, closed_at=opened + timedelta(seconds=1000))
+        assert check_execution(ex, intent, bkp.public_key_jwk) == REASON_UNAUTHORIZED_EXECUTOR
+
+    def test_tampered_action_rejected(self):
+        akp, agent = _identity()
+        _, ctrl = _identity("controller.example.com")
+        opened = datetime.now(timezone.utc)
+        intent = _committed(agent, ctrl.get_did(), opened)
+        ex = execute(agent, intent_credential=intent, closed_at=opened + timedelta(seconds=1000))
+        # Re-sign an execute whose embedded intent was changed to a bigger amount.
+        ex["credentialSubject"]["intent"] = {
+            "action": "transfer_funds",
+            "target": "acct:vendor-1",
+            "resource": "usd:999999",
+        }
+        from vouch import data_integrity  # noqa: PLC0415
+
+        ex["proof"] = data_integrity.build_proof(
+            ex, agent._raw_priv, agent.verification_method_id()
+        )
+        assert check_execution(ex, intent, akp.public_key_jwk) == REASON_INTENT_MISMATCH
+
+    def test_wrong_executor_key_fails_proof(self):
+        akp, agent = _identity()
+        okp, _ = _identity("other.example.com")
+        _, ctrl = _identity("controller.example.com")
+        opened = datetime.now(timezone.utc)
+        intent = _committed(agent, ctrl.get_did(), opened)
+        ex = execute(agent, intent_credential=intent, closed_at=opened + timedelta(seconds=1000))
+        assert check_execution(ex, intent, okp.public_key_jwk) == REASON_INVALID_PROOF

vouch_protocol-2.0.1/tests/test_provenance.py

@@ -0,0 +1,169 @@
+"""Tests for inference provenance (bind an output to its model and context)."""
+
+import pytest
+
+from vouch import Signer, generate_identity
+from vouch.provenance import (
+    PROVENANCE_TYPE,
+    REASON_CONTEXT_ROOT_MISMATCH,
+    REASON_MISSING_BINDING,
+    REASON_OUTPUT_MISMATCH,
+    REASON_WEIGHTS_MISMATCH,
+    ProvenanceError,
+    check_replay,
+    context_root,
+    output_digest,
+    sign_inference_provenance,
+    verify_context,
+    verify_inference_provenance,
+    weights_hash,
+)
+
+CONTEXT = [
+    {"source": "policy://refunds/v4", "text": "Refunds allowed within 30 days."},
+    {"source": "order://A-1007", "text": "Delivered 2026-06-20. Amount 120 USD."},
+]
+OUTPUT = {"action": "approve_refund", "order": "A-1007", "amount": "usd:120"}
+
+
+def _identity(domain="agent.example.com"):
+    kp = generate_identity(domain=domain)
+    return kp, Signer(private_key=kp.private_key_jwk, did=kp.did)
+
+
+class TestHelpers:
+    def test_output_digest_deterministic(self):
+        assert output_digest(OUTPUT) == output_digest(dict(OUTPUT))
+
+    def test_context_root_order_sensitive(self):
+        assert context_root(CONTEXT) != context_root(list(reversed(CONTEXT)))
+
+    def test_context_root_empty_rejected(self):
+        with pytest.raises(ProvenanceError):
+            context_root([])
+
+    def test_weights_hash_multibase(self):
+        assert weights_hash(b"abc").startswith("u")
+
+    def test_to_bytes_type_error(self):
+        with pytest.raises(ProvenanceError):
+            output_digest(123)
+
+
+class TestSignAndVerify:
+    def test_full_flow(self):
+        kp, agent = _identity()
+        wh = weights_hash(b"model-weights")
+        cred = sign_inference_provenance(
+            agent,
+            output=OUTPUT,
+            model_weights_hash=wh,
+            context_chunks=CONTEXT,
+            sampler={"seed": 42, "temperature": 0.0},
+        )
+        assert PROVENANCE_TYPE in cred["type"]
+        ok, subject = verify_inference_provenance(cred, kp.public_key_jwk)
+        assert ok
+        assert subject["provenance"]["modelWeightsHash"] == wh
+        assert subject["provenance"]["contextRoot"]["root"] == context_root(CONTEXT)
+        assert subject["outputDigest"]["digest"] == output_digest(OUTPUT)
+
+    def test_requires_a_binding(self):
+        _, agent = _identity()
+        with pytest.raises(ProvenanceError):
+            sign_inference_provenance(agent, output=OUTPUT)  # no weights, no context
+
+    def test_weights_only_is_valid(self):
+        kp, agent = _identity()
+        cred = sign_inference_provenance(
+            agent, output=OUTPUT, model_weights_hash=weights_hash(b"m")
+        )
+        ok, _ = verify_inference_provenance(cred, kp.public_key_jwk)
+        assert ok
+
+    def test_context_only_is_valid(self):
+        kp, agent = _identity()
+        cred = sign_inference_provenance(agent, output=OUTPUT, context_chunks=CONTEXT)
+        ok, _ = verify_inference_provenance(cred, kp.public_key_jwk)
+        assert ok
+
+    def test_include_output_false_hides_plaintext(self):
+        kp, agent = _identity()
+        cred = sign_inference_provenance(
+            agent, output=OUTPUT, context_chunks=CONTEXT, include_output=False
+        )
+        ok, subject = verify_inference_provenance(cred, kp.public_key_jwk)
+        assert ok and "output" not in subject and subject["outputDigest"]["digest"]
+
+    def test_wrong_key_fails(self):
+        _, agent = _identity()
+        other_kp, _ = _identity("other.example.com")
+        cred = sign_inference_provenance(agent, output=OUTPUT, context_chunks=CONTEXT)
+        ok, _ = verify_inference_provenance(cred, other_kp.public_key_jwk)
+        assert ok is False
+
+    def test_tamper_breaks_proof(self):
+        kp, agent = _identity()
+        cred = sign_inference_provenance(agent, output=OUTPUT, context_chunks=CONTEXT)
+        cred["credentialSubject"]["output"]["amount"] = "usd:999999"
+        ok, _ = verify_inference_provenance(cred, kp.public_key_jwk)
+        assert ok is False
+
+
+class TestContextVerification:
+    def _subject(self):
+        kp, agent = _identity()
+        cred = sign_inference_provenance(agent, output=OUTPUT, context_chunks=CONTEXT)
+        _, subject = verify_inference_provenance(cred, kp.public_key_jwk)
+        return subject
+
+    def test_same_context_reproduces(self):
+        ok, reason = verify_context(CONTEXT, self._subject())
+        assert ok and reason is None
+
+    def test_substituted_context_rejected(self):
+        forged = [{"source": "policy://refunds/v4", "text": "Refunds any time."}, CONTEXT[1]]
+        ok, reason = verify_context(forged, self._subject())
+        assert ok is False and reason == REASON_CONTEXT_ROOT_MISMATCH
+
+    def test_reordered_context_rejected(self):
+        ok, reason = verify_context(list(reversed(CONTEXT)), self._subject())
+        assert ok is False and reason == REASON_CONTEXT_ROOT_MISMATCH
+
+    def test_missing_binding_when_no_context_root(self):
+        kp, agent = _identity()
+        cred = sign_inference_provenance(
+            agent, output=OUTPUT, model_weights_hash=weights_hash(b"m")
+        )
+        _, subject = verify_inference_provenance(cred, kp.public_key_jwk)
+        ok, reason = verify_context(CONTEXT, subject)
+        assert ok is False and reason == REASON_MISSING_BINDING
+
+
+class TestReplay:
+    def _subject(self, wh):
+        kp, agent = _identity()
+        cred = sign_inference_provenance(
+            agent, output=OUTPUT, model_weights_hash=wh, context_chunks=CONTEXT
+        )
+        _, subject = verify_inference_provenance(cred, kp.public_key_jwk)
+        return subject
+
+    def test_matching_replay_passes(self):
+        wh = weights_hash(b"model")
+        assert check_replay(self._subject(wh), output=OUTPUT, model_weights_hash=wh) is None
+
+    def test_output_mismatch(self):
+        wh = weights_hash(b"model")
+        bad = {"action": "approve_refund", "order": "A-1007", "amount": "usd:999999"}
+        assert check_replay(self._subject(wh), output=bad) == REASON_OUTPUT_MISMATCH
+
+    def test_weights_mismatch(self):
+        wh = weights_hash(b"model")
+        assert (
+            check_replay(self._subject(wh), model_weights_hash=weights_hash(b"other"))
+            == REASON_WEIGHTS_MISMATCH
+        )
+
+    def test_no_checks_supplied_passes(self):
+        assert check_replay(self._subject(weights_hash(b"model"))) is None