trace-verify 0.1.0__tar.gz

trace_verify-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,85 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        with:
+          python-version: "3.12"
+
+      - name: Install dependencies
+        run: pip install jsonschema==4.26.0 hatchling
+
+      - name: Install trace-verify package (editable)
+        run: pip install -e .
+
+      - name: Smoke-test trace-verify CLI
+        run: |
+          set -euo pipefail
+          trace-verify --version
+          trace-verify \
+            --claim samples/example-trust-record.json \
+            --proof samples/inclusion-proof.json \
+            --entry registry/2026/06/12.ndjson
+          trace-verify \
+            --claim samples/example-trust-record.json \
+            --proof samples/inclusion-proof.json \
+            --entry registry/2026/06/12.ndjson \
+            --json | python -c "import json,sys; r=json.load(sys.stdin); assert r['verified'], r"
+
+      - name: Determine base SHA for append-only check
+        id: base
+        run: |
+          if [ "${{ github.event_name }}" = "pull_request" ]; then
+            echo "sha=${{ github.event.pull_request.base.sha }}" >> "$GITHUB_OUTPUT"
+          elif [ "${{ github.event.before }}" = "0000000000000000000000000000000000000000" ]; then
+            echo "sha=" >> "$GITHUB_OUTPUT"
+          else
+            echo "sha=${{ github.event.before }}" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Check registry is append-only
+        if: steps.base.outputs.sha != ''
+        run: python tools/check_append_only.py "${{ steps.base.outputs.sha }}"
+
+      - name: Validate registry entries against schema
+        run: python tools/validate_registry.py
+
+      - name: Run tool tests
+        run: python -m unittest discover -s tests -v
+
+      - name: Round-trip the sample anchor
+        run: |
+          set -euo pipefail
+          # Re-anchor the committed sample claim and check the recomputed
+          # Merkle root matches the committed registry entry.
+          recomputed=$(python tools/anchor.py samples/example-trust-record.json \
+              --producer ci --proof-dir "$(mktemp -d)" \
+              | python -c "import json,sys; print(json.load(sys.stdin)['merkle_root'])")
+          committed=$(python -c "import json; print(json.loads(open('registry/2026/06/12.ndjson').readline())['merkle_root'])")
+          echo "recomputed: $recomputed"
+          echo "committed:  $committed"
+          test "$recomputed" = "$committed"
+          # Verify the committed inclusion proof against the committed entry.
+          python tools/verify_inclusion.py \
+            --claim samples/example-trust-record.json \
+            --proof samples/inclusion-proof.json \
+            --entry registry/2026/06/12.ndjson
+
+      - name: Check for required files
+        run: |
+          for f in LICENSE README.md CONTRIBUTING.md CODE_OF_CONDUCT.md SECURITY.md; do
+            [ -f "$f" ] || { echo "Missing required file: $f"; exit 1; }
+          done
+          echo "All required community health files present"

trace_verify-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,47 @@
+name: Publish trace-verify to PyPI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+    inputs:
+      dry_run:
+        description: "Build and attest without publishing to PyPI"
+        required: false
+        type: boolean
+        default: true
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@a26af69be951a213d495a4c3e4e4022e16d87065 # v5.6.0
+        with:
+          python-version: "3.12"
+
+      - name: Install build tools
+        run: pip install build
+
+      - name: Build wheel and sdist
+        run: python -m build
+
+      - name: Validate artifacts
+        run: |
+          pip install twine
+          twine check dist/*
+          ls -lh dist/
+
+      - name: Publish to PyPI
+        if: github.event_name == 'release' || (github.event_name == 'workflow_dispatch' && github.event.inputs.dry_run == 'false')
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          skip-existing: true

trace_verify-0.1.0/.gitignore

@@ -0,0 +1 @@
+__pycache__/

trace_verify-0.1.0/CODE_OF_CONDUCT.md

@@ -0,0 +1,17 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our community a harassment-free experience for everyone, regardless of age, body size, visible or invisible disability, ethnicity, sex characteristics, gender identity and expression, level of experience, education, socio-economic status, nationality, personal appearance, race, caste, color, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Positive behavior includes: using welcoming and inclusive language, being respectful of differing viewpoints, gracefully accepting constructive criticism, and focusing on what is best for the community.
+
+Unacceptable behavior includes: the use of sexualized language or imagery, trolling, insulting or derogatory comments, personal or political attacks, public or private harassment, and publishing others' private information without permission.
+
+## Enforcement
+
+Instances of abusive or unacceptable behavior may be reported to the project team via [GitHub Security Advisories](https://github.com/agentrust-io/trace-registry/security/advisories/new).
+
+Adapted from the [Contributor Covenant](https://www.contributor-covenant.org), version 2.1.

trace_verify-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,18 @@
+# Contributing
+
+Thank you for your interest in contributing to the TRACE Registry.
+
+## How to Contribute
+
+1. Fork the repository
+2. Create a feature branch
+3. Commit your changes using [Conventional Commits](https://www.conventionalcommits.org)
+4. Open a pull request against `main`
+
+## Reporting Security Issues
+
+Use [GitHub Security Advisories](https://github.com/agentrust-io/trace-registry/security/advisories/new) rather than opening a public issue.
+
+## Code of Conduct
+
+See [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md).

trace_verify-0.1.0/LICENSE

@@ -0,0 +1,6 @@
+Creative Commons Attribution 4.0 International (CC BY 4.0)
+
+Copyright 2026 AgentTrust Contributors
+
+This work is licensed under the Creative Commons Attribution 4.0 International License.
+To view a copy of this license, visit https://creativecommons.org/licenses/by/4.0/

trace_verify-0.1.0/PKG-INFO

@@ -0,0 +1,127 @@
+Metadata-Version: 2.4
+Name: trace-verify
+Version: 0.1.0
+Summary: Verify TRACE claim inclusion proofs against the public registry
+Project-URL: Homepage, https://github.com/agentrust-io/trace-registry
+Project-URL: Documentation, https://github.com/agentrust-io/trace-registry/blob/main/docs/anchor-format.md
+Project-URL: Bug Tracker, https://github.com/agentrust-io/trace-registry/issues
+Project-URL: Changelog, https://github.com/agentrust-io/trace-registry/blob/main/CHANGELOG.md
+License: CC-BY-4.0
+License-File: LICENSE
+Keywords: ai-governance,audit,inclusion-proof,merkle,trace
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Security :: Cryptography
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+[![License: CC BY 4.0](https://img.shields.io/badge/License-CC_BY_4.0-lightgrey.svg)](LICENSE)
+[![TRACE Spec](https://img.shields.io/badge/TRACE-Spec_v0.1-0ea5e9)](https://github.com/agentrust-io/trace-spec)
+[![Discord](https://dcbadge.limes.pink/api/server/9JWNpH7E?style=flat)](https://discord.gg/9JWNpH7E)
+
+# TRACE Registry
+
+The public accountability layer for TRACE claim anchors. Each entry records the
+Merkle root of a batch of signed TRACE Trust Records, committed to this
+repository as an append-only record. Git's commit history is the
+tamper-evidence layer: any rewrite of a published entry diverges the commit
+hashes that auditors and mirrors have already observed.
+
+## Current Registry State
+
+The registry currently contains one development entry (registry/2026/06/12.ndjson).
+This is a software-only example anchor with advisory enforcement and a zeroed
+measurement, committed as a launch-day example. It does not represent a production
+Trust Record. The first production entries will be added after Confidential Computing
+Summit launch on June 23, 2026.
+
+The anchor construction (canonical claim bytes, leaf hashing, RFC 6962 Merkle
+tree, inclusion proofs) is specified in
+[docs/anchor-format.md](docs/anchor-format.md). A third party can implement a
+verifier from that document alone; the reference tools in [tools/](tools/) are
+one implementation.
+
+> **Status.** The format, reference tooling, schema validation, and a first
+> real entry ([registry/2026/06/12.ndjson](registry/2026/06/12.ndjson)) are
+> live. Anchoring is currently manual and low volume; a continuous anchoring
+> cadence and a packaged `trace-verify` CLI on PyPI are planned but not yet
+> operational.
+
+## Why this exists
+
+Anyone holding a TRACE trust record and its inclusion proof can verify that the
+record was anchored in this registry without trusting the operator who issued
+it, using only this public git history and the verifier below. No single
+operator controls the audit trail.
+
+## Registry Format
+
+Each daily file in `registry/YYYY/MM/` is newline-delimited JSON, one anchor
+entry per line, validated by CI against
+[schema/registry-entry.schema.json](schema/registry-entry.schema.json):
+
+```json
+{"ts": "2026-06-12T18:09:41Z", "merkle_root": "sha256:9279...bada", "leaf_count": 1, "producer": "cmcp-gateway/0.1.0", "batch_id": "2026-06-12-001"}
+```
+
+Entries are append-only. See [docs/anchor-format.md](docs/anchor-format.md)
+for field semantics.
+
+## Verifying a claim
+
+You need three things: your signed claim (Trust Record), the inclusion proof
+your producer gave you, and the registry entry for the batch. Then:
+
+```bash
+git clone https://github.com/agentrust-io/trace-registry.git
+cd trace-registry
+python tools/verify_inclusion.py \
+  --claim samples/example-trust-record.json \
+  --proof samples/inclusion-proof.json \
+  --entry registry/2026/06/12.ndjson
+# OK: claim is included in batch '2026-06-12-001' (root sha256:9279..., ts 2026-06-12T18:09:41Z)
+```
+
+Exit code 0 means the claim is proven included; 1 means it is not. The
+verifier is a single standard-library Python file, so you can audit it (or
+reimplement it from the spec) rather than trust it. The `samples/` files above
+are a real anchored example you can use to exercise the tooling.
+
+Inclusion verification proves the signed claim bytes were anchored at the
+entry's timestamp. Validating the claim's signature against the producer key
+is a separate TRACE step.
+
+## Anchoring claims
+
+Producers batch signed claims and anchor them with:
+
+```bash
+python tools/anchor.py claim1.json claim2.json \
+  --producer my-gateway/1.0 --proof-dir proofs/ \
+  >> registry/2026/06/12.ndjson
+```
+
+This emits the registry entry line and writes one inclusion proof per claim to
+hand back to claim holders.
+
+## Canonical Registry
+
+This repository exists for independence: TRACE claim anchors can be checked
+without trusting any single operator's infrastructure, and the git history is
+auditable by anyone.
+
+## Community
+
+Questions, feedback, integration help: [Discord](https://discord.gg/9JWNpH7E).
+
+## License
+
+Creative Commons Attribution 4.0 International (CC BY 4.0). See [LICENSE](LICENSE).

trace_verify-0.1.0/README.md

@@ -0,0 +1,102 @@
+[![License: CC BY 4.0](https://img.shields.io/badge/License-CC_BY_4.0-lightgrey.svg)](LICENSE)
+[![TRACE Spec](https://img.shields.io/badge/TRACE-Spec_v0.1-0ea5e9)](https://github.com/agentrust-io/trace-spec)
+[![Discord](https://dcbadge.limes.pink/api/server/9JWNpH7E?style=flat)](https://discord.gg/9JWNpH7E)
+
+# TRACE Registry
+
+The public accountability layer for TRACE claim anchors. Each entry records the
+Merkle root of a batch of signed TRACE Trust Records, committed to this
+repository as an append-only record. Git's commit history is the
+tamper-evidence layer: any rewrite of a published entry diverges the commit
+hashes that auditors and mirrors have already observed.
+
+## Current Registry State
+
+The registry currently contains one development entry (registry/2026/06/12.ndjson).
+This is a software-only example anchor with advisory enforcement and a zeroed
+measurement, committed as a launch-day example. It does not represent a production
+Trust Record. The first production entries will be added after Confidential Computing
+Summit launch on June 23, 2026.
+
+The anchor construction (canonical claim bytes, leaf hashing, RFC 6962 Merkle
+tree, inclusion proofs) is specified in
+[docs/anchor-format.md](docs/anchor-format.md). A third party can implement a
+verifier from that document alone; the reference tools in [tools/](tools/) are
+one implementation.
+
+> **Status.** The format, reference tooling, schema validation, and a first
+> real entry ([registry/2026/06/12.ndjson](registry/2026/06/12.ndjson)) are
+> live. Anchoring is currently manual and low volume; a continuous anchoring
+> cadence and a packaged `trace-verify` CLI on PyPI are planned but not yet
+> operational.
+
+## Why this exists
+
+Anyone holding a TRACE trust record and its inclusion proof can verify that the
+record was anchored in this registry without trusting the operator who issued
+it, using only this public git history and the verifier below. No single
+operator controls the audit trail.
+
+## Registry Format
+
+Each daily file in `registry/YYYY/MM/` is newline-delimited JSON, one anchor
+entry per line, validated by CI against
+[schema/registry-entry.schema.json](schema/registry-entry.schema.json):
+
+```json
+{"ts": "2026-06-12T18:09:41Z", "merkle_root": "sha256:9279...bada", "leaf_count": 1, "producer": "cmcp-gateway/0.1.0", "batch_id": "2026-06-12-001"}
+```
+
+Entries are append-only. See [docs/anchor-format.md](docs/anchor-format.md)
+for field semantics.
+
+## Verifying a claim
+
+You need three things: your signed claim (Trust Record), the inclusion proof
+your producer gave you, and the registry entry for the batch. Then:
+
+```bash
+git clone https://github.com/agentrust-io/trace-registry.git
+cd trace-registry
+python tools/verify_inclusion.py \
+  --claim samples/example-trust-record.json \
+  --proof samples/inclusion-proof.json \
+  --entry registry/2026/06/12.ndjson
+# OK: claim is included in batch '2026-06-12-001' (root sha256:9279..., ts 2026-06-12T18:09:41Z)
+```
+
+Exit code 0 means the claim is proven included; 1 means it is not. The
+verifier is a single standard-library Python file, so you can audit it (or
+reimplement it from the spec) rather than trust it. The `samples/` files above
+are a real anchored example you can use to exercise the tooling.
+
+Inclusion verification proves the signed claim bytes were anchored at the
+entry's timestamp. Validating the claim's signature against the producer key
+is a separate TRACE step.
+
+## Anchoring claims
+
+Producers batch signed claims and anchor them with:
+
+```bash
+python tools/anchor.py claim1.json claim2.json \
+  --producer my-gateway/1.0 --proof-dir proofs/ \
+  >> registry/2026/06/12.ndjson
+```
+
+This emits the registry entry line and writes one inclusion proof per claim to
+hand back to claim holders.
+
+## Canonical Registry
+
+This repository exists for independence: TRACE claim anchors can be checked
+without trusting any single operator's infrastructure, and the git history is
+auditable by anyone.
+
+## Community
+
+Questions, feedback, integration help: [Discord](https://discord.gg/9JWNpH7E).
+
+## License
+
+Creative Commons Attribution 4.0 International (CC BY 4.0). See [LICENSE](LICENSE).

trace_verify-0.1.0/SECURITY.md

@@ -0,0 +1,7 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Please do not report security vulnerabilities through public GitHub issues.
+
+Use [GitHub Security Advisories](https://github.com/agentrust-io/trace-registry/security/advisories/new) to report vulnerabilities privately. We respond within 72 hours.

trace_verify-0.1.0/docs/anchor-format.md

@@ -0,0 +1,147 @@
+# TRACE Registry Anchor Format v1
+
+This document is the normative specification for how TRACE Trust Records (signed
+claims) are anchored into this registry and how a third party verifies, without
+trusting the registry operator, that a given claim was included in an anchor.
+
+The construction follows [RFC 6962](https://www.rfc-editor.org/rfc/rfc6962)
+(Certificate Transparency) Merkle trees. A conforming verifier can be written
+from this document alone; the reference tools in [`tools/`](../tools/) are one
+implementation, not the definition.
+
+## 1. Canonical claim bytes
+
+The unit of anchoring is the COMPLETE signed claim object, signature included.
+Anchoring binds the signed artifact, not a pre-signature payload: if either the
+claim body or its signature changes, the anchor no longer matches.
+
+`canonical_claim_bytes` is the canonical JSON serialization of the claim object:
+
+- Object keys sorted lexicographically (by Unicode code point), recursively.
+- Separators `","` and `":"` with no whitespace.
+- Non-ASCII characters escaped (`ensure_ascii`); output encoded as ASCII bytes.
+- No trailing newline.
+
+In Python this is exactly:
+
+```python
+json.dumps(claim, sort_keys=True, separators=(",", ":"), ensure_ascii=True).encode("ascii")
+```
+
+Claims MUST be JSON objects. TRACE Trust Records contain only strings,
+integers, booleans, nulls, arrays, and objects; claims containing non-integer
+numbers are outside this profile because cross-language float serialization is
+not canonical.
+
+## 2. Leaf hash
+
+```
+leaf = SHA-256(0x00 || canonical_claim_bytes)
+```
+
+The `0x00` domain-separation prefix is the RFC 6962 leaf prefix. It prevents an
+interior node from being presented as a leaf (second-preimage attack).
+
+## 3. Merkle tree
+
+The tree over the ordered list of leaves is the RFC 6962 Merkle Tree Hash:
+
+- A tree of one leaf has root equal to that leaf hash.
+- Interior nodes: `node = SHA-256(0x01 || left || right)` where `left` and
+  `right` are the 32-byte child hashes and `0x01` is the interior prefix.
+- Construction proceeds level by level over the ordered leaves: adjacent pairs
+  are hashed together; when a level has an odd number of nodes, the final node
+  is promoted unchanged to the next level (it is NOT duplicated). This yields
+  the same tree as the RFC 6962 recursive split at the largest power of two.
+- The empty batch (zero leaves) is invalid and MUST be rejected. This registry
+  never anchors an empty tree.
+
+The root is published hex-encoded, lowercase, prefixed with the algorithm:
+
+```
+sha256:<64 lowercase hex characters>
+```
+
+## 4. Registry entry format
+
+Anchors are recorded in newline-delimited JSON files at
+`registry/YYYY/MM/DD.ndjson` (UTC date of anchoring). Each line is one JSON
+object with exactly these fields:
+
+| field         | type    | meaning                                                       |
+|---------------|---------|---------------------------------------------------------------|
+| `ts`          | string  | Anchoring time, ISO-8601 UTC with `Z` suffix                  |
+| `merkle_root` | string  | `sha256:<hex>` root of the batch tree (section 3)             |
+| `leaf_count`  | integer | Number of leaves in the batch, >= 1                           |
+| `producer`    | string  | Identifier of the party that produced and submitted the batch |
+| `batch_id`    | string  | Producer-scoped unique identifier for the batch               |
+
+Example:
+
+```json
+{"ts": "2026-06-12T18:30:00Z", "merkle_root": "sha256:9c4f...", "leaf_count": 1, "producer": "cmcp-gateway/0.1.0", "batch_id": "2026-06-12-001"}
+```
+
+Entries are append-only: lines are only ever added to the end of a day file,
+and existing files are never rewritten. Git history is the tamper-evidence
+layer; any rewrite of a published entry diverges the commit hashes that
+auditors and mirrors have already observed. The machine-readable schema is
+[`schema/registry-entry.schema.json`](../schema/registry-entry.schema.json)
+and is enforced by CI on every line of every `registry/**/*.ndjson` file.
+
+## 5. Inclusion proof
+
+A producer gives each claim holder an inclusion proof:
+
+```json
+{"leaf_index": 0, "audit_path": ["sha256:<hex>", "sha256:<hex>"]}
+```
+
+- `leaf_index`: 0-based position of the claim's leaf in the batch.
+- `audit_path`: the RFC 6962 audit path, ordered leaf-to-root: at each tree
+  level the sibling hash needed to recompute the parent. A level where the
+  node was promoted (no sibling) contributes no path element. A single-leaf
+  batch has an empty `audit_path`.
+
+### Verification algorithm
+
+Inputs: the claim object, the proof (`leaf_index`, `audit_path`), and the
+registry entry (`merkle_root`, `leaf_count`). All `sha256:<hex>` strings are
+decoded to 32 raw bytes. The algorithm is the RFC 9162 inclusion-proof check:
+
+```
+1. If leaf_index >= leaf_count, reject.
+2. r  = SHA-256(0x00 || canonical_claim_bytes)        # section 2
+   fn = leaf_index
+   sn = leaf_count - 1
+3. For each p in audit_path, in order:
+     a. If sn == 0, reject (path too long).
+     b. If fn is odd, or fn == sn:
+          r = SHA-256(0x01 || p || r)
+          If fn is even:                  # fn == sn, right-edge promotion
+              until fn is odd or fn == 0: fn = fn >> 1; sn = sn >> 1
+        else:
+          r = SHA-256(0x01 || r || p)
+     c. fn = fn >> 1; sn = sn >> 1
+4. Accept iff sn == 0 and r equals the entry's merkle_root.
+```
+
+Any failure (wrong root, leftover `sn`, malformed hash, out-of-range index)
+means the claim is NOT proven included in that entry.
+
+### What verification proves
+
+A successful verification proves the exact signed claim bytes were part of the
+batch whose root is committed in the public, append-only git history at the
+entry's timestamp. It does not validate the claim's signature or semantics;
+signature verification against the producer key is a separate TRACE step.
+
+## 6. Reference tooling
+
+- [`tools/anchor.py`](../tools/anchor.py): builds the tree over one or more
+  claim files, emits the registry entry line and one inclusion proof per claim.
+- [`tools/verify_inclusion.py`](../tools/verify_inclusion.py): standalone
+  verifier (claim + proof + entry, exit 0/1). Deliberately self-contained so it
+  can be copied and audited in isolation.
+
+Both are Python 3 standard library only (`hashlib`, `json`).

trace_verify-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "trace-verify"
+version = "0.1.0"
+description = "Verify TRACE claim inclusion proofs against the public registry"
+readme = "README.md"
+license = { text = "CC-BY-4.0" }
+requires-python = ">=3.9"
+dependencies = []
+keywords = ["trace", "merkle", "inclusion-proof", "audit", "ai-governance"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Security :: Cryptography",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+[project.scripts]
+trace-verify = "trace_verify.__main__:main"
+
+[project.urls]
+Homepage = "https://github.com/agentrust-io/trace-registry"
+Documentation = "https://github.com/agentrust-io/trace-registry/blob/main/docs/anchor-format.md"
+"Bug Tracker" = "https://github.com/agentrust-io/trace-registry/issues"
+Changelog = "https://github.com/agentrust-io/trace-registry/blob/main/CHANGELOG.md"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/trace_verify"]

trace_verify-0.1.0/registry/2026/06/12.ndjson

@@ -0,0 +1 @@
+{"ts": "2026-06-12T18:09:41Z", "merkle_root": "sha256:9279111218532d83279a0ce4c8d114168e2558b8f85054878c97ee5f428abada", "leaf_count": 1, "producer": "cmcp-gateway/0.1.0", "batch_id": "2026-06-12-001"}