proofbundle 3.0.1__tar.gz → 3.1.0__tar.gz

{proofbundle-3.0.1/src/proofbundle.egg-info → proofbundle-3.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: proofbundle
-Version: 3.0.1
+Version: 3.1.0
 Summary: Emit and verify portable cryptographic evidence bundles, offline: Ed25519 + RFC 6962 Merkle + optional SD-JWT.
 Author: Konrad Gruszka
 License: MIT
@@ -55,8 +55,8 @@ Dynamic: license-file
 <div align="center">
 
 <picture>
-  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/b7n0de/proofbundle/main/assets/b7n0de-logo-dark.svg">
-  <img alt="b7n0de, Verified AI Work" src="https://raw.githubusercontent.com/b7n0de/proofbundle/main/assets/b7n0de-logo.svg" height="60">
+  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/b7n0de/proofbundle/main/assets/b7n0de-hase-logo-dark.png">
+  <img alt="b7n0de, Verified AI Work, pink rabbit mascot over the B7N0DE wordmark" src="https://raw.githubusercontent.com/b7n0de/proofbundle/main/assets/b7n0de-hase-logo.png" width="200">
 </picture>
 
 <h1>proofbundle</h1>
@@ -89,6 +89,7 @@ Merkle, one file, no server, no network.
 - [The problem](#the-problem)
 - [What a receipt proves, and what it doesn't](#what-a-receipt-proves-and-what-it-doesnt)
 - [How it fits together](#how-it-fits-together)
+- [Cite this work](#cite-this-work)
 - [Post-quantum posture](#post-quantum-posture-honest-two-layers)
 - [What's in the box](#whats-in-the-box)
 - [Docs](#docs)
@@ -183,6 +184,28 @@ flowchart LR
     style OK fill:#D6248A,stroke:#D6248A,color:#fff
 ```
 
+### Where it sits in the research neighbourhood
+
+proofbundle is a **practical, released, offline verifier — complementary to TEE and zero-knowledge
+approaches**, not a replacement for any of them. It is honest about the line each neighbour crosses
+that a receipt does not. Maturity labels are stated so nothing reads as a settled standard when it is
+a preprint.
+
+| Neighbour | What it contributes that a receipt does not | Maturity | Where proofbundle draws the line |
+|---|---|---|---|
+| **K-Veritas** ([arXiv 2605.08586](https://arxiv.org/abs/2605.08586)) — nonrepudiable experimental results | the academic case for tamper-evident, execution-bound experiment reports | preprint | proofbundle is a released, offline, eval-shaped receipt for exactly this problem, not the only take on it |
+| **Attestable Audits** ([arXiv 2506.23706](https://arxiv.org/abs/2506.23706)) — TEE-verified safety audits | that the computation actually ran, inside a trusted enclave | preprint (research prototype) | a receipt proves authorship + integrity, **not** that the computation was correct — that needs a TEE or independent reproduction |
+| **BenchJack** ([arXiv 2605.12673](https://arxiv.org/abs/2605.12673)) — auditing agent benchmarks | whether the benchmark itself is gameable (reward-hacking) | preprint | a receipt over a gameable benchmark is honestly still just a receipt; it says nothing about whether the eval was well designed |
+| **Evaluation Cards** ([arXiv 2606.09809](https://arxiv.org/abs/2606.09809)) — reporting / interpretation layer | a structured, human-facing account of what a result means | preprint | a receipt can bind a card's integrity, not its quality |
+| in-toto / Sigstore, SCITT / Rekor v2, OpenSSF Model Signing (stable standards / production) | artifact-provenance, public transparency, model-artifact signing | — | see [INTEROP.md](https://github.com/b7n0de/proofbundle/blob/main/INTEROP.md) for the honest tool-by-tool comparison |
+
+## Cite this work
+
+If proofbundle helped your evaluation pipeline, please cite it. Machine-readable metadata is in
+[`CITATION.cff`](https://github.com/b7n0de/proofbundle/blob/main/CITATION.cff); the archival record and
+concept DOI are on Zenodo ([10.5281/zenodo.21230467](https://doi.org/10.5281/zenodo.21230467)), and the
+current design write-up is the Technical Note linked from [b7n0de.com/proofbundle](https://b7n0de.com/proofbundle).
+
 ## Post-quantum posture (honest, two layers)
 
 proofbundle is **not** "quantum-proof" or "quantum-safe" as a whole. It combines two cryptographic layers

{proofbundle-3.0.1 → proofbundle-3.1.0}/README.md

@@ -1,8 +1,8 @@
 <div align="center">
 
 <picture>
-  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/b7n0de/proofbundle/main/assets/b7n0de-logo-dark.svg">
-  <img alt="b7n0de, Verified AI Work" src="https://raw.githubusercontent.com/b7n0de/proofbundle/main/assets/b7n0de-logo.svg" height="60">
+  <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/b7n0de/proofbundle/main/assets/b7n0de-hase-logo-dark.png">
+  <img alt="b7n0de, Verified AI Work, pink rabbit mascot over the B7N0DE wordmark" src="https://raw.githubusercontent.com/b7n0de/proofbundle/main/assets/b7n0de-hase-logo.png" width="200">
 </picture>
 
 <h1>proofbundle</h1>
@@ -35,6 +35,7 @@ Merkle, one file, no server, no network.
 - [The problem](#the-problem)
 - [What a receipt proves, and what it doesn't](#what-a-receipt-proves-and-what-it-doesnt)
 - [How it fits together](#how-it-fits-together)
+- [Cite this work](#cite-this-work)
 - [Post-quantum posture](#post-quantum-posture-honest-two-layers)
 - [What's in the box](#whats-in-the-box)
 - [Docs](#docs)
@@ -129,6 +130,28 @@ flowchart LR
     style OK fill:#D6248A,stroke:#D6248A,color:#fff
 ```
 
+### Where it sits in the research neighbourhood
+
+proofbundle is a **practical, released, offline verifier — complementary to TEE and zero-knowledge
+approaches**, not a replacement for any of them. It is honest about the line each neighbour crosses
+that a receipt does not. Maturity labels are stated so nothing reads as a settled standard when it is
+a preprint.
+
+| Neighbour | What it contributes that a receipt does not | Maturity | Where proofbundle draws the line |
+|---|---|---|---|
+| **K-Veritas** ([arXiv 2605.08586](https://arxiv.org/abs/2605.08586)) — nonrepudiable experimental results | the academic case for tamper-evident, execution-bound experiment reports | preprint | proofbundle is a released, offline, eval-shaped receipt for exactly this problem, not the only take on it |
+| **Attestable Audits** ([arXiv 2506.23706](https://arxiv.org/abs/2506.23706)) — TEE-verified safety audits | that the computation actually ran, inside a trusted enclave | preprint (research prototype) | a receipt proves authorship + integrity, **not** that the computation was correct — that needs a TEE or independent reproduction |
+| **BenchJack** ([arXiv 2605.12673](https://arxiv.org/abs/2605.12673)) — auditing agent benchmarks | whether the benchmark itself is gameable (reward-hacking) | preprint | a receipt over a gameable benchmark is honestly still just a receipt; it says nothing about whether the eval was well designed |
+| **Evaluation Cards** ([arXiv 2606.09809](https://arxiv.org/abs/2606.09809)) — reporting / interpretation layer | a structured, human-facing account of what a result means | preprint | a receipt can bind a card's integrity, not its quality |
+| in-toto / Sigstore, SCITT / Rekor v2, OpenSSF Model Signing (stable standards / production) | artifact-provenance, public transparency, model-artifact signing | — | see [INTEROP.md](https://github.com/b7n0de/proofbundle/blob/main/INTEROP.md) for the honest tool-by-tool comparison |
+
+## Cite this work
+
+If proofbundle helped your evaluation pipeline, please cite it. Machine-readable metadata is in
+[`CITATION.cff`](https://github.com/b7n0de/proofbundle/blob/main/CITATION.cff); the archival record and
+concept DOI are on Zenodo ([10.5281/zenodo.21230467](https://doi.org/10.5281/zenodo.21230467)), and the
+current design write-up is the Technical Note linked from [b7n0de.com/proofbundle](https://b7n0de.com/proofbundle).
+
 ## Post-quantum posture (honest, two layers)
 
 proofbundle is **not** "quantum-proof" or "quantum-safe" as a whole. It combines two cryptographic layers

{proofbundle-3.0.1 → proofbundle-3.1.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "proofbundle"
-version = "3.0.1"
+version = "3.1.0"
 description = "Emit and verify portable cryptographic evidence bundles, offline: Ed25519 + RFC 6962 Merkle + optional SD-JWT."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -100,7 +100,7 @@ proofbundle = "proofbundle.pytest_plugin"
 where = ["src"]
 
 [tool.setuptools.package-data]
-proofbundle = ["py.typed", "eee_eval_schema.json"]
+proofbundle = ["py.typed", "eee_eval_schema.json", "policies/*.json"]
 
 [tool.ruff]
 line-length = 100

{proofbundle-3.0.1 → proofbundle-3.1.0}/src/proofbundle/__init__.py

@@ -13,7 +13,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-__version__ = "3.0.1"
+__version__ = "3.1.0"
 
 # The `proofbundle/v0.1` normative spec revision this build implements — kept in sync with the
 # `Revision:` line at the top of SPEC.md by tests/test_docs_truth.py (WP-B1, closes #28). Bump

{proofbundle-3.0.1 → proofbundle-3.1.0}/src/proofbundle/bundle.py

@@ -22,7 +22,8 @@ malformed exit code, not a crash.
 from __future__ import annotations
 
 import base64
-from typing import Union
+import hmac
+from typing import Optional, Union
 
 from . import merkle
 from ._strict_json import loads_strict
@@ -31,7 +32,8 @@ from .kbjwt import holder_key_from_cnf, split_key_binding, verify_key_binding
 from .signature import verify_ed25519
 from .sdjwt import verify_sd_jwt
 
-__all__ = ["SCHEMA", "verify_bundle", "load_bundle", "recompute_merkle_root_b64"]
+__all__ = ["SCHEMA", "verify_bundle", "load_bundle", "recompute_merkle_root_b64",
+           "root_authenticity_summary"]
 
 
 def _issuer_requires_holder_binding(sd_part: str) -> bool:
@@ -134,7 +136,9 @@ def load_bundle(path: str) -> dict:
         return loads_strict(handle.read())
 
 
-def verify_bundle(bundle: Union[dict, str], *, expected_aud=None, expected_nonce=None) -> VerificationResult:
+def verify_bundle(bundle: Union[dict, str], *, expected_aud=None, expected_nonce=None,
+                  expected_root_b64: Optional[str] = None,
+                  expected_tree_size: Optional[int] = None) -> VerificationResult:
     """Verify an evidence bundle (a dict or a path to a JSON file).
 
     ``expected_aud`` / ``expected_nonce`` (v1.3): when the bundle carries a Key Binding JWT, these enforce
@@ -142,6 +146,17 @@ def verify_bundle(bundle: Union[dict, str], *, expected_aud=None, expected_nonce
     ``nonce`` MUST match ``expected_nonce``. If omitted, the KB-JWT signature + disclosure binding are still
     checked, but the relying party has NOT bound the presentation to itself/this transaction — a stale or
     cross-audience replay would still verify. A relying party doing challenge-response MUST pass both.
+
+    ``expected_root_b64`` / ``expected_tree_size`` (P0-A, Hardening 3.0.1 §6.2): RELYING-PARTY root
+    authentication. The native Merkle root is NOT part of the signature input (SPEC §5), so the SAME
+    signed payload verifies under DIFFERENT roots — a *coherent one-leaf rewrap* re-anchors the payload
+    at index 0 of a 2-leaf tree with a foreign sibling, and inclusion still holds. Merkle inclusion alone
+    therefore proves CONSISTENCY under the stated root, NOT that the root is authentic. When the relying
+    party supplies an authenticated root / tree size (out of band: a pinned value, a signed checkpoint,
+    the trusted_roots of a policy), these are enforced bit-exactly and a mismatch FAILS (adds the
+    ``root-authenticity`` / ``tree-size`` checks). ``expected_root_b64`` is decoded and compared to the
+    stated root's BYTES (canonicalization-agnostic). Absent, root authenticity stays NOT_EVALUATED and
+    the crypto verdict is unchanged (backward-compatible) — see ``root_authenticity_summary``.
     """
     if isinstance(bundle, str):
         bundle = load_bundle(bundle)
@@ -198,9 +213,28 @@ def verify_bundle(bundle: Union[dict, str], *, expected_aud=None, expected_nonce
     result.add(
         "merkle-inclusion",
         incl_ok,
-        f"anchored at index {leaf_index} of {tree_size}" if incl_ok else "inclusion proof failed",
+        f"anchored at index {leaf_index} of {tree_size} (Merkle-consistent under the STATED root)"
+        if incl_ok else "inclusion proof failed",
     )
 
+    # 2b. P0-A (§6.2): relying-party root authentication. The stated root is NOT signed, so inclusion
+    # alone does not authenticate it; only a bit-exact match against a root/size the relying party
+    # obtained out of band does. Adds a check ONLY when the RP supplies an expectation — absent, root
+    # authenticity is NOT_EVALUATED and the verdict is unchanged (backward-compatible).
+    if expected_root_b64 is not None:
+        exp_root = _b64d(expected_root_b64, "expected_root_b64")
+        root_ok = hmac.compare_digest(root, exp_root)
+        result.add("root-authenticity", root_ok,
+                   "stated root matches the expected authenticated root" if root_ok
+                   else "stated root does NOT match the expected root — possible root/rewrap substitution")
+    if expected_tree_size is not None:
+        # strict: a real int only — reject bool (1==True) and float (1==1.0), matching _require_int.
+        size_ok = (isinstance(expected_tree_size, int) and not isinstance(expected_tree_size, bool)
+                   and tree_size == expected_tree_size)
+        result.add("tree-size", size_ok,
+                   f"tree_size {tree_size} matches the expected size" if size_ok
+                   else f"tree_size {tree_size} != expected {expected_tree_size} — possible tree-size substitution")
+
     # 3. optional SD-JWT selective disclosure credential
     sd = bundle.get("sd_jwt_vc")
     kb_binding_checked = False   # F4: did a KB-JWT (the aud/nonce carrier) actually get verified?
@@ -332,6 +366,54 @@ def verify_bundle(bundle: Union[dict, str], *, expected_aud=None, expected_nonce
     return result
 
 
+def root_authenticity_summary(result: VerificationResult, *,
+                              policy_authenticated_root: Optional[bool] = None,
+                              policy_ok: Optional[bool] = None,
+                              anchor_ok: Optional[bool] = None) -> dict:
+    """Structured root-authenticity verdicts (P0-A §6.3), derived from a completed VerificationResult.
+
+    Separates what Merkle inclusion actually proves from what it does NOT, as three-state strings so a
+    consumer never mistakes 'not checked' for 'passed':
+
+      payloadSignature   PASS/FAIL         — the payload is signed by the stated key
+      merkleConsistency  PASS/FAIL         — the payload is Merkle-consistent under the STATED root
+      rootAuthenticity   PASS/FAIL/NOT_EVALUATED — was the stated root authenticated against a
+                         relying-party value (``expected_root``, or a policy's ``trusted_roots``)?
+      publicTransparency NOT_EVALUATED     — a public-log receipt is the separate §10 profile
+      safeForAutomation  bool              — True ONLY if the whole crypto verdict passed, the root was
+                                             affirmatively authenticated, AND no supplied trust policy /
+                                             anchor requirement FAILED (§6.3: root authenticity AND policy)
+
+    ``policy_authenticated_root`` folds the policy layer's root verdict in when no explicit
+    ``root-authenticity`` check ran (e.g. the root matched a policy ``trusted_roots`` entry).
+    ``policy_ok`` / ``anchor_ok`` are the relying-party gate verdicts (True/False/None=not-evaluated); a
+    FAILED gate makes ``safeForAutomation`` false even when the root itself authenticated, so a consumer
+    keying off this flag can never auto-trust a bundle its own policy rejected.
+    """
+    by = {c.name: c.ok for c in result.checks}
+
+    def _tri(name: str) -> str:
+        return "PASS" if by.get(name) else ("FAIL" if name in by else "NOT_EVALUATED")
+
+    if "root-authenticity" in by:
+        root_auth = "PASS" if by["root-authenticity"] else "FAIL"
+    elif policy_authenticated_root is True:
+        root_auth = "PASS"
+    elif policy_authenticated_root is False:
+        root_auth = "FAIL"
+    else:
+        root_auth = "NOT_EVALUATED"
+    safe = (bool(result.ok) and root_auth == "PASS"
+            and policy_ok is not False and anchor_ok is not False)
+    return {
+        "payloadSignature": _tri("ed25519-signature"),
+        "merkleConsistency": _tri("merkle-inclusion"),
+        "rootAuthenticity": root_auth,
+        "publicTransparency": "NOT_EVALUATED",
+        "safeForAutomation": safe,
+    }
+
+
 def recompute_merkle_root_b64(bundle: Union[dict, str]) -> dict:
     """Recompute the Merkle root from the bundle's own payload + inclusion proof (v1.2, issue #2).
 

{proofbundle-3.0.1 → proofbundle-3.1.0}/src/proofbundle/cli.py

@@ -69,7 +69,8 @@ def _safe_line(s: str) -> str:
 _VERIFY_NULLABLE_FIELDS = (
     "schema_ok", "signature_ok", "merkle_ok", "sd_jwt_ok", "sd_jwt_issuer_verified",
     "key_binding_ok", "audience_ok", "nonce_ok", "freshness_ok", "anchor_ok", "witness_ok",
-    "status_ok", "assurance_policy_ok", "policy_ok", "assurance", "assurance_declared_by")
+    "status_ok", "assurance_policy_ok", "policy_ok", "assurance", "assurance_declared_by",
+    "root_authenticity")
 
 
 def _error_verify_fields(error: str) -> dict:
@@ -300,7 +301,8 @@ def _cmd_emit_eval(args: argparse.Namespace) -> int:
 def _cmd_show_eval(args: argparse.Namespace) -> int:
     from .bundle import load_bundle  # noqa: PLC0415
     from .evalclaim import (  # noqa: PLC0415
-        DEFAULT_ASSURANCE, check_freshness, claim_warnings, decode_eval_claim, sd_jwt_hidden_count,
+        DEFAULT_ASSURANCE, check_freshness, claim_warnings, decode_eval_claim, eval_evidence_class,
+        sd_jwt_hidden_count,
     )
     try:
         # Resolve the path to a dict ONCE and pass that object to every reader — a second per-function re-read of
@@ -316,6 +318,9 @@ def _cmd_show_eval(args: argparse.Namespace) -> int:
     print(f"suite      {claim['suite']} ({claim['suite_version']})")
     print(f"metric     {claim['metric']} {claim['comparator']} {claim['threshold']}")
     print(f"passed     {claim['passed']}   (n={claim['n']})")
+    ev = eval_evidence_class(claim)
+    print(f"evidence   {ev['score_evidence']} ({ev['detail']})")
+    print(f"note       {ev['methodology']} (the receipt never judges whether the suite is well designed)")
     print(f"assurance  {claim.get('assurance_level', DEFAULT_ASSURANCE)}")
     print(f"model      commit {claim['model_id_commit']}")
     print(f"dataset    commit {claim['dataset_id_commit']}")
@@ -432,6 +437,7 @@ def _cmd_verify(args: argparse.Namespace) -> int:
     from .policy import (  # noqa: PLC0415
         evaluate_policy, load_policy, policy_anchor_trust, policy_expected_aud,
     )
+    from .policy_profiles import resolve_policy_source  # noqa: PLC0415
 
     flag_aud = getattr(args, "aud", None)
     flag_nonce = getattr(args, "nonce", None)
@@ -460,7 +466,7 @@ def _cmd_verify(args: argparse.Namespace) -> int:
         # expected_aud are set and DIFFER, that is ambiguous → exit 2 (never a silent override).
         effective_aud = flag_aud
         if getattr(args, "policy", None):
-            policy = load_policy(args.policy)
+            policy = load_policy(resolve_policy_source(args.policy))
             pol_aud = policy_expected_aud(policy)
             if pol_aud is not None and flag_aud is not None and pol_aud != flag_aud:
                 from .policy import PolicyError  # noqa: PLC0415
@@ -495,7 +501,9 @@ def _cmd_verify(args: argparse.Namespace) -> int:
                 merged = dict(pol_trust)
                 merged.update(rp_trust_material or {})   # CLI flags take precedence on the same key
                 rp_trust_material = merged
-        result = verify_bundle(bundle, expected_aud=effective_aud, expected_nonce=flag_nonce)
+        result = verify_bundle(bundle, expected_aud=effective_aud, expected_nonce=flag_nonce,
+                               expected_root_b64=getattr(args, "expected_root", None),
+                               expected_tree_size=getattr(args, "expected_tree_size", None))
         roots = recompute_merkle_root_b64(bundle) if args.verbose else None
     except (ProofBundleError, OSError, ValueError, RecursionError) as exc:   # file/JSON/format/policy errors → clean exit 2, never a raw traceback
         # RecursionError: deeply-nested JSON overflows json.load's recursion; catch it here too so it
@@ -537,6 +545,14 @@ def _cmd_verify(args: argparse.Namespace) -> int:
         aud_requested=effective_aud is not None,
         nonce_requested=flag_nonce is not None,
         assurance=assurance, policy_ok=policy_ok)
+    # P0-A §6.3: structured root-authenticity verdicts, folding the policy layer's trusted_roots verdict
+    # in when no --expected-root was given. Always separate, so merkle-inclusion is never read as root
+    # authentication (additive JSON field + a human line).
+    from .bundle import root_authenticity_summary  # noqa: PLC0415
+    root_summary = root_authenticity_summary(
+        result, policy_authenticated_root=(policy_result or {}).get("root_authenticated"),
+        policy_ok=policy_ok, anchor_ok=anchor_required_ok)
+    fields["root_authenticity"] = root_summary
     if policy is not None:
         fields["policy_id"] = policy.get("policy_id")
         # WP-TP1: non-fatal honesty warnings (e.g. "attributes to nobody") — exit code unchanged.
@@ -591,6 +607,13 @@ def _cmd_verify(args: argparse.Namespace) -> int:
         else:
             assurance_line = "n/a (not an eval receipt)"    # a well-verified bundle that is not an eval receipt
         print(f"CRYPTO: {'OK' if crypto_ok else 'FAILED'}")
+        # P0-A §6.3: separate the root-authenticity verdicts — merkle-inclusion proves CONSISTENCY under
+        # the STATED root, never that the root is authentic. safe-for-automation is true only when the
+        # root was affirmatively authenticated (--expected-root or a policy trusted_roots).
+        print(f"ROOT-AUTHENTICITY: {root_summary['rootAuthenticity']} "
+              f"(payload-signature {root_summary['payloadSignature']}, "
+              f"merkle-consistency {root_summary['merkleConsistency']}, "
+              f"safe-for-automation {str(root_summary['safeForAutomation']).lower()})")
         if policy is not None and not crypto_ok:
             print("POLICY: NOT_EVALUATED (crypto failed — policy not checked)")
         else:
@@ -1076,8 +1099,9 @@ def _cmd_decision_init(args: argparse.Namespace) -> int:
 
 def _cmd_policy_explain(args: argparse.Namespace) -> int:
     from .policy import PolicyError, explain_policy, load_policy, policy_warnings  # noqa: PLC0415
+    from .policy_profiles import resolve_policy_source  # noqa: PLC0415
     try:
-        policy = load_policy(args.policy)
+        policy = load_policy(resolve_policy_source(args.policy))
     except PolicyError as exc:   # malformed policy → exit 2; in --json emit an error object (six-lens
         if args.json:            # review: an empty stdout on the error path breaks a JSON consumer)
             print(json.dumps({"ok": False, "policy_id": None, "error": str(exc)}))
@@ -1103,8 +1127,9 @@ def _cmd_policy_explain(args: argparse.Namespace) -> int:
 
 def _cmd_policy_lint(args: argparse.Namespace) -> int:
     from .policy import PolicyError, lint_policy, load_policy  # noqa: PLC0415
+    from .policy_profiles import resolve_policy_source  # noqa: PLC0415
     try:
-        policy = load_policy(args.policy)
+        policy = load_policy(resolve_policy_source(args.policy))
     except PolicyError as exc:   # malformed policy is a lint failure too, with the parse reason
         if args.json:            # emit an error object in --json (mirror _cmd_verify; exit 2 unchanged)
             print(json.dumps({"ok": False, "policy_id": None, "error": str(exc)}))
@@ -1124,6 +1149,22 @@ def _cmd_policy_lint(args: argparse.Namespace) -> int:
     return 0 if res["ok"] else 1
 
 
+def _cmd_policy_list_profiles(args: argparse.Namespace) -> int:
+    from .policy import explain_policy, load_policy  # noqa: PLC0415
+    from .policy_profiles import list_profiles, profile_path  # noqa: PLC0415
+    rows = []
+    for name in list_profiles():
+        policy = load_policy(profile_path(name))
+        rows.append({"name": name, "policy_id": policy.get("policy_id"),
+                    "schema": policy.get("schema"), "pin_count": len(explain_policy(policy))})
+    if args.json:
+        print(json.dumps(rows, indent=2, ensure_ascii=False))
+        return 0
+    for row in rows:
+        print(f"{row['name']:22} {row['schema']:32} {row['pin_count']} pin(s)   {row['policy_id']}")
+    return 0
+
+
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(
         prog="proofbundle",
@@ -1156,8 +1197,19 @@ def build_parser() -> argparse.ArgumentParser:
                              "bind a Key Binding JWT presentation to this verifier")
     verify.add_argument("--nonce", default=None,
                         help="expected KB-JWT nonce (RFC 9901 §7.3 replay binding)")
+    verify.add_argument("--expected-root", dest="expected_root", default=None, metavar="B64",
+                        help="authenticate the merkle root against a base64 value the relying party "
+                             "obtained OUT OF BAND (a pinned root, a signed checkpoint). The stated root "
+                             "is NOT signed, so a coherent one-leaf rewrap verifies under a different "
+                             "root; supplying this closes it — a mismatch FAILS (exit 1). Without it, "
+                             "root authenticity reads NOT_EVALUATED")
+    verify.add_argument("--expected-tree-size", dest="expected_tree_size", default=None, type=int,
+                        metavar="N", help="require the merkle tree_size to equal N (guards tree-size "
+                             "substitution); a mismatch FAILS")
     verify.add_argument("--policy", default=None,
-                        help="path to a trust-policy JSON (proofbundle/trust-policy/v0.1). Applies a "
+                        help="path to a trust-policy JSON (proofbundle/trust-policy/v0.1), OR the name "
+                             "of a packaged profile (WP3, e.g. strict-eval-v1 — see "
+                             "docs/POLICY_PROFILES.md; `policy list-profiles` lists them all). Applies a "
                              "fail-closed, offline trust decision OVER the crypto result: without it "
                              "POLICY reads NOT_EVALUATED; a policy failure is exit 3, distinct from a "
                              "crypto failure (exit 1)")
@@ -1313,19 +1365,26 @@ def build_parser() -> argparse.ArgumentParser:
     policy_cmd = sub.add_parser(
         "policy", help="inspect a trust policy: explain its effective pins, lint for vacuousness")
     psub = policy_cmd.add_subparsers(dest="policy_command", required=True)
+    _profile_help = ("path to a trust-policy JSON, OR the name of a packaged profile (WP3, "
+                     "see docs/POLICY_PROFILES.md) such as strict-eval-v1 — a real file of the "
+                     "same name always wins over a packaged profile")
     p_explain = psub.add_parser(
         "explain", help="list the effective pins a trust policy makes (what POLICY: OK will mean)")
-    p_explain.add_argument("policy", help="path to the trust-policy JSON")
+    p_explain.add_argument("policy", help=_profile_help)
     p_explain.add_argument("--json", action="store_true", help="machine readable output")
     p_explain.set_defaults(func=_cmd_policy_explain)
     p_lint = psub.add_parser(
         "lint", help="fail (exit 1) on a WIRKUNGSLOSE policy that would produce a vacuous "
                      "POLICY: OK; --strict also fails on attributes-to-nobody")
-    p_lint.add_argument("policy", help="path to the trust-policy JSON")
+    p_lint.add_argument("policy", help=_profile_help)
     p_lint.add_argument("--strict", action="store_true",
                         help="promote warnings (attributes to nobody) to lint failures")
     p_lint.add_argument("--json", action="store_true", help="machine readable output")
     p_lint.set_defaults(func=_cmd_policy_lint)
+    p_list = psub.add_parser(
+        "list-profiles", help="list the named trust-policy profiles shipped with this package (WP3)")
+    p_list.add_argument("--json", action="store_true", help="machine readable output")
+    p_list.set_defaults(func=_cmd_policy_list_profiles)
 
     prereg = sub.add_parser(
         "prereg",

{proofbundle-3.0.1 → proofbundle-3.1.0}/src/proofbundle/evalclaim.py

@@ -52,6 +52,9 @@ __all__ = [
     "EVAL_CLAIM_SCHEMA", "COMMIT_ALG", "ASSURANCE_LEVELS", "canonicalize", "build_eval_claim",
     "emit_eval_receipt", "decode_eval_claim", "salted_commit", "issuer_fingerprint",
     "claim_warnings", "verify_commitment", "check_freshness", "sd_jwt_hidden_count",
+    "eval_evidence_class", "SCORE_EVIDENCE_CLASSES", "EXACT_SCORE_VERIFIED",
+    "THRESHOLD_VERDICT_VERIFIED", "SCORE_COMMITMENT_PRESENT", "SCORE_WITHHELD",
+    "METHODOLOGY_NOT_EVALUATED",
 ]
 
 
@@ -337,6 +340,67 @@ def claim_warnings(claim: dict) -> list:
     return out
 
 
+# P0-B (Hardening 3.0.1 §7.1) — the machine-readable SCORE-evidence verdicts. A receipt today signs a
+# THRESHOLD VERDICT (`passed` against the signed `comparator`/`threshold`): the exact score is used at
+# emit time to COMPUTE `passed` and is then DISCARDED (build_eval_claim never stores it), so no output
+# may imply an exact score was verified. The other classes are reachable only through the optional,
+# additive exact-score profile (§7.2, EXPERIMENTAL, NOT part of the frozen 3.x core).
+EXACT_SCORE_VERIFIED = "EXACT_SCORE_VERIFIED"
+THRESHOLD_VERDICT_VERIFIED = "THRESHOLD_VERDICT_VERIFIED"
+SCORE_COMMITMENT_PRESENT = "SCORE_COMMITMENT_PRESENT"
+SCORE_WITHHELD = "SCORE_WITHHELD"
+METHODOLOGY_NOT_EVALUATED = "METHODOLOGY_NOT_EVALUATED"
+SCORE_EVIDENCE_CLASSES = (EXACT_SCORE_VERIFIED, THRESHOLD_VERDICT_VERIFIED,
+                          SCORE_COMMITMENT_PRESENT, SCORE_WITHHELD)
+
+
+def eval_evidence_class(claim: dict) -> dict:
+    """Classify what SCORE evidence a VERIFIED eval claim carries (never call on an unverified claim).
+
+    Returns ``{"score_evidence": <class>, "methodology": METHODOLOGY_NOT_EVALUATED, "detail": <str>}``.
+
+    Today every receipt is ``THRESHOLD_VERDICT_VERIFIED``: the frozen v0.1 schema has no ``score``
+    field, so a receipt proves only that ``passed`` holds for the signed ``comparator``/``threshold``.
+    ``methodology`` is ALWAYS ``METHODOLOGY_NOT_EVALUATED`` — a receipt never judges whether the suite
+    measures what it claims (No-Overclaim §0.5).
+
+    The remaining classes are reachable only through the optional, additive exact-score profile (§7.2,
+    field names provisional pending its ADR, EXPERIMENTAL, not in the 3.x core): a signed decimal-string
+    ``score`` whose recomputed ``passed`` AGREES → ``EXACT_SCORE_VERIFIED`` (a score present but
+    inconsistent with ``passed`` is a decode-time FAIL; if seen here it degrades to the threshold
+    verdict, never a false EXACT); a signed score COMMITMENT → ``SCORE_COMMITMENT_PRESENT`` (a binding,
+    NOT a range proof: it does not prove the hidden score crossed the threshold, §7.3); an explicit
+    withheld marker → ``SCORE_WITHHELD``.
+    """
+    methodology = METHODOLOGY_NOT_EVALUATED
+    comparator = claim.get("comparator")
+    threshold = claim.get("threshold")
+    passed = claim.get("passed")
+    score = claim.get("score")
+    if (isinstance(score, str) and _DECIMAL_RE.match(score) and comparator in _COMPARATORS
+            and isinstance(threshold, str) and _DECIMAL_RE.match(threshold) and isinstance(passed, bool)):
+        from decimal import Decimal, InvalidOperation  # noqa: PLC0415
+        try:
+            recomputed = {">=": Decimal(score) >= Decimal(threshold), ">": Decimal(score) > Decimal(threshold),
+                          "<=": Decimal(score) <= Decimal(threshold), "<": Decimal(score) < Decimal(threshold)}[comparator]
+        except InvalidOperation:
+            recomputed = None
+        if recomputed is passed:
+            return {"score_evidence": EXACT_SCORE_VERIFIED, "methodology": methodology,
+                    "detail": "exact score signed and consistent with the threshold verdict"}
+        return {"score_evidence": THRESHOLD_VERDICT_VERIFIED, "methodology": methodology,
+                "detail": "score present but not consistent with `passed` — only the threshold verdict stands"}
+    if claim.get("score_commit") or claim.get("score_commitment"):
+        return {"score_evidence": SCORE_COMMITMENT_PRESENT, "methodology": methodology,
+                "detail": "a score COMMITMENT is present — a binding, NOT a range proof: it does not "
+                          "prove the hidden score crossed the threshold"}
+    if claim.get("score_withheld") is True:
+        return {"score_evidence": SCORE_WITHHELD, "methodology": methodology,
+                "detail": "the exact score is deliberately withheld; only the threshold verdict is signed"}
+    return {"score_evidence": THRESHOLD_VERDICT_VERIFIED, "methodology": methodology,
+            "detail": "proves `passed` against the signed threshold, not an exact score"}
+
+
 def verify_commitment(identifier: str, salt: bytes, commitment: str) -> bool:
     """Check that a PRESENTED identifier (+ its salt) matches a salted commitment in a claim
     (``model_id_commit`` / ``dataset_id_commit``). Makes a model-swap visible: a claim that silently swapped

proofbundle-3.1.0/src/proofbundle/policies/decision-receipt-v1.json

@@ -0,0 +1,14 @@
+{
+  "schema": "proofbundle/trust-policy/v0.2",
+  "policy_id": "proofbundle-policy/decision-receipt-v1",
+  "allowed_schema_versions": ["proofbundle/v0.1"],
+  "signature": {"allowed_algs": ["ed25519"]},
+  "decision_receipt": {
+    "accepted_predicate_types": ["https://b7n0de.com/proofbundle/predicates/decision-receipt/v0.1"],
+    "require_not_checked": true,
+    "require_decision_change_conditions": true,
+    "require_audience": true,
+    "require_nonce": true,
+    "allow_raw_inputs": false
+  }
+}

proofbundle-3.1.0/src/proofbundle/policies/research-preview-v1.json

@@ -0,0 +1,7 @@
+{
+  "schema": "proofbundle/trust-policy/v0.1",
+  "policy_id": "proofbundle-policy/research-preview-v1",
+  "allowed_schema_versions": ["proofbundle/v0.1"],
+  "signature": {"allowed_algs": ["ed25519"]},
+  "merkle": {"required_hash_alg": "sha256-rfc6962"}
+}

proofbundle-3.1.0/src/proofbundle/policies/strict-eval-authenticated-root-v1.json

@@ -0,0 +1,9 @@
+{
+  "schema": "proofbundle/trust-policy/v0.1",
+  "policy_id": "proofbundle-policy/strict-eval-authenticated-root-v1",
+  "allowed_schema_versions": ["proofbundle/v0.1"],
+  "signature": {"allowed_algs": ["ed25519"]},
+  "merkle": {"required_hash_alg": "sha256-rfc6962", "require_authenticated_root": true},
+  "sd_jwt": {"require_key_binding_when_cnf_present": true},
+  "assurance": {"minimum_level": "reproduced", "reject_self_attested_without_prereg": true}
+}

proofbundle-3.1.0/src/proofbundle/policies/strict-eval-v1.json

@@ -0,0 +1,9 @@
+{
+  "schema": "proofbundle/trust-policy/v0.1",
+  "policy_id": "proofbundle-policy/strict-eval-v1",
+  "allowed_schema_versions": ["proofbundle/v0.1"],
+  "signature": {"allowed_algs": ["ed25519"]},
+  "merkle": {"required_hash_alg": "sha256-rfc6962"},
+  "sd_jwt": {"require_key_binding_when_cnf_present": true},
+  "assurance": {"minimum_level": "reproduced", "reject_self_attested_without_prereg": true}
+}

proofbundle-3.1.0/src/proofbundle/policies/strict-prereg-v1.json

@@ -0,0 +1,9 @@
+{
+  "schema": "proofbundle/trust-policy/v0.2",
+  "policy_id": "proofbundle-policy/strict-prereg-v1",
+  "allowed_schema_versions": ["proofbundle/v0.1"],
+  "signature": {"allowed_algs": ["ed25519"]},
+  "merkle": {"required_hash_alg": "sha256-rfc6962"},
+  "assurance": {"reject_self_attested_without_prereg": true},
+  "anchors": {"require_anchor": "any", "require_anchor_target": "preRegistration", "allow_pending": false}
+}