Continuity Receipt

An open specification, test vectors, and reference verifier for verifiable records of governed AI-agent tasks.

Spec version: continuity-receipt/0.5 — published 2026-09-30. 0.1–0.4 remain supported (open items listed in SPEC.md §11). License: Apache-2.0 (specification text, code, and vectors).

Checkout development: SPEC_0.6_DRAFT.md stacks an unpublished authority candidate (authority.grant) on top of 0.5.

Version matrix — the spec and the two implementations version independently:

The pinned install commands resolve to the published release (0.5.0).

Both implementations support spec 0.5 (local authority, execution sandbox vocabulary, runner profiles, state commitments, duplicate member rejection, and consumer profile assessment) with identical verdicts and codes over the full vector set. Verify the version you have with continuity-verify --help or continuity-receipt-verify --help (Python or Rust).

A Continuity Receipt is a signed, hash-chained record of one governed task: decision → authority → execution → delivery → termination → settlement. It is designed to be verified offline by any third party — insurers, arbiters, procurement, courts, other agents — without trusting the channel that delivered it or accepting someone else's verification. What it proves is bounded: a receipt attests what its issuer signed, not that the described events occurred — issuer honesty is out of scope by design (THREAT_MODEL.md #2–#3, CONFORMANCE_TABLE.md §E).

The spec is intentionally small: JSON (RFC 8785 canonicalization), SHA-256, Ed25519, did:key identities. No new cryptography. Redaction uses salted commitments so fields can be revealed selectively without breaking integrity; erasure makes commitments opaque while the chain still verifies.

Naming. "Continuity Receipt" currently names two different objects in the standards landscape: this specification's agent-session lifecycle record (continuity-receipt/0.5), and an IETF SCITT draft that registers the recovery of stateful assets in a transparency log (draft-nikolaichuk-scitt-continuity-receipts). They are adjacent concepts, not the same object. In external copy, prefer "agent continuity receipt" for this specification; see docs/CROSSWALK_AER1_AADP_SCITT.md.

Why this exists

Agents are accumulating persistent memory and doing delegated work at scale, but accountability is still self-reported. This format makes the difference checkable: claims arrive with signed evidence, missing evidence is distinguished from false evidence, and a termination claim (task.termination) is required for a task to verify as complete — it proves the issuer signed that the task stopped, not that it did.

Verification verdicts (IETF CTQ-aligned): TRUSTED · PROVISIONAL · INSUFFICIENT_EVIDENCE · UNTRUSTED. INSUFFICIENT_EVIDENCE is explicitly not the same as false.

Layout

SPEC.md                    the v0.5 specification (normative; 0.1-0.4 supported)
VERIFICATION_RECEIPTS.md   companion: signed statements about a verification run
CONFORMANCE_TABLE.md       rule-by-rule conformance matrix (audit surface)
VERIFY_IN_5_MIN.md         the integration kit page (copy-paste, no SDK)
ADOPTER_GUIDE.md            verify, emit, capture; provenance labels and 0.5 example
REVIEW_BRIEF.md            frozen v0.4 independent-review scope
REVIEW_BRIEF_05.md         prepared v0.5 candidate review brief (external report pending)
REVIEW_NOTES_05.md         candidate self-review, findings and open release gates
INTEGRATION_READINESS.md    exact-candidate gate for producer and verifier integration
REVIEW_RESPONSE.md         response to the first independent review (findings → fixes)
schema/                    JSON Schema (2020-12): bundles + verification receipts
THREAT_MODEL.md            what receipts prove, and what they do not
ANCHORING.md               anchoring policy: OpenTimestamps default, chain optional
OPEN_DATA_ANSWER_RECEIPT.md  worked example: an AI answer over an open-data portal
CONTRIBUTING.md            DCO, test rules, scope
ROADMAP.md                 what lands in 0.4 and beyond, and the selection rule
docs/                      crosswalks (sahu; ACTA/asqav; AER-1/AADP/SCITT) + design notes + consumer profile
continuity_receipt/        reference implementation (Python, cryptography>=42)
rust/                      second implementation (verifier crate; cargo test)
vectors/                   40 bundle vectors + 21 verification-receipt vectors
vectors/manifest-0.5.json  separate, unpublished candidate corpus
vectors/manifest-0.6.json  authority candidate corpus (additive over 0.5)
tools/make_vectors.py      regenerates the vectors (fresh ids/timestamps; published fixtures stay frozen)
tools/hostile_input_probe.py  malformed-input corpus, structured outcomes + parity
tools/interop_sahu_vectors.py  reproduce draft-sahu agent-action-receipts vectors
tools/interop_acta_probe.py    ACTA/asqav minimal-construction probe (pinned revisions)
tools/interop_aer1_probe.py    live AER-1 receipt verification probe (draft-zambo-aer1-04)
tests/                     conformance suite (vectors, schema, primitives)

Quickstart

# from PyPI (0.5.0) — clone the repo for the vectors
python3 -m venv .venv && . .venv/bin/activate
pip install continuity-receipt==0.5.0
continuity-verify vectors/02_happy_full.json            # TRUSTED
continuity-consumer vectors/02_happy_full.json --profile conservative # ACCEPT
continuity-receipt-verify vectors/02_happy_full.json    # compat alias
continuity-receipt-verify vectors/10b_anchor_missing.json --require-anchor
continuity-receipt-verify-receipt vectors/verification/01_valid.json \
  --bundle vectors/verification/bundle.json
continuity-receipt-disclose --help

# or run from a checkout
pip install 'cryptography>=42'
python3 -m continuity_receipt.verify vectors/02_happy_full.json

# run the conformance suite (vectors + schema + primitives)
python3 -m unittest discover -s tests -v

ERC-8004 Validation (Base)

Any governed task bundle can be validated through the live adapter at api.whitemagic.dev: it runs the reference verifier, binds the bundle to a task hash, and returns a deterministic outcome plus a signed validator attestation.

curl -s -X POST https://api.whitemagic.dev/erc8004/validate \
  -H "Content-Type: application/json" \
  -d '{
    "request_id": "task_2026_0929_alpha",
    "task_hash": "sha256:…",
    "bundle": { … }
  }'

• Outcome: 1: ACCEPT (TRUSTED), 0: REJECT (UNTRUSTED), 2: NEEDS_EVIDENCE (PROVISIONAL / INSUFFICIENT); 422 when task_hash does not bind to the bundle.
• Attestation: typed EIP-712 ValidationResponse envelope (requestId, outcome, receiptHash, timestamp) signed with the validator's Ed25519 did:key:z6MkmKSaKjTr2DPJEHG6aZVGmX6JkWsWiYtuD9c73ReRGdfW; on-chain relay is not enabled (onchain.relayed: false). Default registry 0x8004A15217B1B1E19d7b43851b9eEbFA40306E78 on eip155:8453.
• Gating: keyed or x402 — $0.01 USDC (5-minute task lease) or $0.50 USDC (24-hour day pass) on Base to 0x213b6bB4fB073E86167c58DA6Cb6E9477557DaA8. Live details: https://api.whitemagic.dev/info · docs: https://api.whitemagic.dev/docs

Test vectors

40 bundle vectors with machine-readable expectations in vectors/manifest.json (human index: vectors/INDEX.md): 0.1 conformance (01–10c), 0.2 additions — succession records, millisecond timestamps, counterparty attestations, revocation semantics, Merkle provenance, anchor typing — 0.3 additions: offer → accept binding (16–16d, including the missing-offer, terms-mismatch, and expiry cases) and selective disclosure of redacted offer terms (16e/16f) — and 0.4 additions: the binding carried through the chain (17–17j, including wrong offeree/signer, chronology, issuer, missing-ref, and unreferenced-accept cases), the mixed-version compatibility case (18), and dedicated negatives for policy_mismatch, redacted_required, and commit_mismatch (19–21). Every schema-valid vector is checked against the schema for its spec version in CI.

21 verification-receipt vectors in vectors/verification/ (manifest + INDEX.md): valid TRUSTED/PROVISIONAL/INSUFFICIENT_EVIDENCE records (the full result — errors, reasons, summary), signature/verdict tampering, wrong bundle, bad kind/version/verdict/timestamp/digest/error-codes/errors/reasons/summary, consistency violations, missing signature, issuer swap, revoked issuer (and the positive case: a revocation statement dated after verified_at leaves the receipt valid), unknown member. Schema: schema/verification-receipt-1.schema.json.

Status and provenance

• Origin: developed in the MandalaOS gate-lite work, where it passed acceptance G1–G8 and the wider project suite (49 tests, dogfood evidence). This repository is the format's public home; it versions independently of any product release train.
• Releases: 0.1 (2026-09-18) — spec, reference verifier, 11 vectors. 0.2 (2026-09-18) — authority.succession, bundle-level revocation statements, counterparty attestation rules, millisecond timestamps, merkle-sha256: provenance, anchor typing, JSON Schema, CI, machine-readable vector manifest. 0.3 (2026-09-23) — agreement.offer / agreement.accept with digest binding, terms/id equality, and expiry semantics; vectors 16–16f; schema 0.3. Tooling 0.3.3 (2026-09-23) — verification receipts (companion v1: schema, 20 vectors, reference verifier + CLI; records the full result — errors, reasons, summary — with offline consistency checks and an anchoring recipe), agreement emitters, integration kit. 0.4 (2026-09-24, published) — the offer → accept binding carried through the chain (offeree required and signer-checked; agreement_ref on the bound stages), hostile-input hardening (whole-shape validation, input boundaries, structured outcomes in both implementations), the rule-by-rule conformance table, and the compatibility vector. Tooling 0.4.0 (published) — schema 0.4, 40 bundle + 21 receipt vectors, tools/hostile_input_probe.py in CI. 0.5 (2026-09-30, published) — local authority (mandala_class: local), execution sandbox vocabulary with runner_profile binding, state.commitment (chain-head and file snapshots), duplicate-member rejection in all parsers, and the consumer profile assessment; schema 0.5, candidate vectors 22–23b, crosswalk documentation. Tooling 0.5.0 (published) — PyPI + crates.io.
• Second implementation: rust/ — an independent Rust verifier (crate continuity-receipt) with the same verdict/error semantics; cargo test checks all 40 bundle vectors and CI diffs it against the Python reference (40/40) and the verification-receipt vectors (21/21, crate 0.4.0), with digest parity pinned by tools/differential_verification_receipts.py and hostile-input parity asserted by tools/hostile_input_probe.py.
• Origin implementation: WhiteMagic — an MIT, local-first memory substrate for agents (this spec repo is Apache-2.0; the two are separate works).
• Standards context: the format is intended as a contribution to the emerging neutral layer (W3C AI Agent Memory Interoperability CG; IETF agentproto work). It is not endorsed by those bodies, and no claim of adoption is made.

Development disclosure

This project is developed with AI agents as drafting, implementation, and review collaborators, under the direction and accountability of the human maintainer. Every artifact published here — spec text, code, vectors — is reviewed and signed off by the human maintainer, who is responsible for its claims. We disclose this proactively because verifiability is the project's subject as well as its method.

The stack

Local memory → governed execution → verifiable continuity

• whitemagic — local-first memory and session continuity for AI agents
• continuity-receipt — portable, offline-verifiable evidence for governed tasks (Apache-2.0, this repo)
• mandalaos-gate-lite — bounded agent execution that emits receipts (review snapshot)
• whitemagic-plugins — client integrations and adapters

Each repository stands on its own: WhiteMagic does not require MandalaOS, and Continuity Receipt does not require WhiteMagic. Three entrances — use it → whitemagic; review a protocol → continuity-receipt; attack the security architecture → mandalaos-gate-lite.

Contributing

Open an issue for spec questions, mapping suggestions, or implementation feedback. Interoperability discussion belongs in the open standards venues; this repository tracks concrete text and vectors.

License

Apache License 2.0 — see LICENSE. The specification is published for royalty-free implementation. Test keys in the vectors are deterministic and public; never use them for real receipts.