Share Evidence with a Partner

Hand a partner a signed, bounded slice of your receipts that they import, verify offline, and keep attributed to you.

On this page

Give a partner the receipts behind one piece of shared work, and nothing else. A signed sharing policy names the partner, the slice of your receipt log they may see, and when the policy expires; your export refuses every receipt outside it.

The partner imports the package into its own store, where the receipts stay attributed to you. Sharing is separate from admission: admission decides which peer may take part, and the sharing policy decides which evidence leaves your store.

Start

Evidence flowChoose a stage.

The verifier works from the exported bytes

Export reads receipts and checkpoints from the store into one directory. The verifier checks it with no access to the producer’s kernel. Export and verify evidence.

checkpoint signerbackground · chio-store-sqlite

Every checkpoint_batch_size receipts (100 by default; 0 turns it off), commits the batch’s canonical bytes to an RFC 6962 Merkle root and signs a KernelCheckpoint whose body carries previous_checkpoint_sha256 and a chain_root.

With a checkpoint: whether a receipt was in its batch, from an inclusion proof against merkle_root, and whether checkpoints chain.

evidence packagechio evidence export

A directory holding receipts.ndjson, checkpoints.ndjson, inclusion-proofs.ndjson, capability-lineage.ndjson, the checkpoint transparency records, and retention.json, with manifest.json listing a hash for every file.

From the package alone: whether any file changed since export. The manifest is not authenticated against an outside source.

verifierchio evidence verify

Checks the file hashes, the signatures the package carries, and its inclusion proofs, with no access to the producer’s kernel. The receipt-verification project repeats the receipt checks in Python, JavaScript, and Go.

It computes integrity and inclusion from bytes. Whether an external effect happened is outside what a receipt can show.

In Rust · checkpoint.rs:139

/// A signed kernel checkpoint statement.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct KernelCheckpoint {
    /// The signed body.
    pub body: KernelCheckpointBody,
    /// Ed25519 signature over canonical JSON of `body`.
    pub signature: Signature,
}

The stages in one deployment: one kernel key signs receipts and checkpoints, both stay in the receipt store, and the export reads them from there. The outside commitment is optional. The verifier computes integrity and inclusion from bytes, and the recipient pins its trusted signers independently of the package.Verifiable evidence

1. Sign the sharing policy

Sign a policy under the schema chio.federation-policy.v1 with chio evidence federation-policy create. It names the issuer, the partner, the read boundary, the time window, an expiry, whether checkpoint proofs are required, and a purpose.

Before you begin

A receipt store holding the run you intend to share, and its capture window. The bounded evidence workflow writes both, with the window in evidence-run/window.json; run the steps below from that example directory.
A signing seed kept outside source control. The seed in the example is a local identity; your partner pins its public key before relying on a share.
The Chio CLI, jq, and OpenSSL on PATH.

Sign a policy for one capability and one quartertranscript

$ chio evidence federation-policy create \
    --output ./org-a-to-org-b.json \
    --signing-seed-file ./federation-signing.seed \
    --issuer org-a \
    --partner org-b \
    --capability cap-billing-q2 \
    --admin-all \
    --since 1767225600 \
    --until 1775001599 \
    --expires-at 4102444800 \
    --require-proofs \
    --purpose "quarterly billing evidence for org-b review"

federation policy created
output:              ./org-a-to-org-b.json
issuer:              org-a
partner:             org-b
signer_public_key:   4cb5abf6ad79fbf5abbccafcc269d85cd2651ed4b885b5869f241aedf0a5ba29
require_proofs:      true

exit 0

You should see the policy file, the issuer and partner, the signer's public key, and require_proofs: true. The read boundary belongs to the policy, so --tenant or --admin-all is required when you sign it, never when you use it. --since, --until, and --expires-at are Unix seconds, and an --expires-at already in the past is refused at signing time.

2. Export under the policy and import on the partner

Attach the policy to an export with --federation-policy, then import the package into a separate partner store. The captured run signs a fresh policy for the recorded window first.

Terminalbash

EVIDENCE_SINCE=$(jq -r .since evidence-run/window.json)
EVIDENCE_UNTIL=$(jq -r .until evidence-run/window.json)
umask 077
openssl rand -hex 32 > sharing.seed
chio evidence federation-policy create \
  --output sharing-policy.json --signing-seed-file sharing.seed \
  --issuer operator-review --partner operator-audit --admin-all \
  --since "$EVIDENCE_SINCE" --until "$EVIDENCE_UNTIL" \
  --expires-at "$((EVIDENCE_UNTIL + 3600))" --require-proofs \
  --purpose 'review the bounded local example run'
chio evidence export --receipt-db evidence-run/receipts.sqlite3 \
  --federation-policy sharing-policy.json --output partner-package
chio evidence import --receipt-db partner-receipts.sqlite3 --input partner-package

Output · exit 0

federation policy created
output:              sharing-policy.json
issuer:              operator-review
partner:             operator-audit
signer_public_key:   a79d14964c71eabaa06955b1a3709dc58ebc0e7e8d6f5b9e59194fea184a924e
require_proofs:      true
federated evidence share imported
share_id:            share-6f9d2c1a916c3e3c6a575f14826be511af95c792e89e8d7e81d8350f5c1d4ed6
issuer:              operator-review
partner:             operator-audit
signer_public_key:   a79d14964c71eabaa06955b1a3709dc58ebc0e7e8d6f5b9e59194fea184a924e
tool_receipts:       3
capability_lineage:  1

You should see a six-line import summary: share_id, issuer, partner, signer_public_key, tool_receipts, and capability_lineage. The counts are the partner's record of what it took in; they grant nothing. The export refuses any receipt outside the policy's window and read boundary.

An export with no read boundary at all is refused before any file is written, and the command exits 1:

Refuse an export without a read boundary

Terminalbash

chio evidence export --receipt-db evidence-run/receipts.sqlite3 --output missing-boundary

Output · exit 1


error[CHIO-KERNEL-RECEIPT-READ-CONTEXT-MISSING]: evidence export needs a read boundary
  help: pass --tenant <id> to export one tenant's receipts, or --admin-all to export every tenant as the operator
  code: urn:chio:error:kernel:receipt-read-context-missing
  docs: https://chio.computer/docs/reference/errors#error-kernel-receipt-read-context-missing

Exit 1 is the expected refusal. A shell running with set -e stops at this command, so run it on its own.

3. Find the shared references from local activity

On the partner, list what was shared with chio trust evidence-share list. It filters by capability, agent subject, tool server, tool name, window, issuer, and partner.

Terminalbash

chio trust evidence-share list --issuer operator-review --partner operator-audit

Output

evidence_shares: 1
- share-6f9d…4ed6 issuer=operator-review partner=operator-audit tool_receipts=3 capability_lineage=1 require_proofs=true

You should see the share's references beside the partner's own history. Imported receipts stay attributed to their issuer: the report never presents a foreign receipt as a native local one.

4. Verify the package, then a changed copy

Run chio evidence verify on the package. Because the policy required proofs, every exported receipt carries a checkpoint inclusion proof, and verification reports uncheckpointed_receipts: 0. Change one byte and verification fails at the manifest hash:

Detect a changed package file

Terminalbash

cp -R evidence-package altered-package
printf '\n' >> altered-package/receipts.ndjson
chio evidence verify --input altered-package

Output · exit 1


error[CHIO-ATTEST-PROVENANCE-MISSING]: evidence package file hash mismatch for receipts.ndjson
  help: receipts.ndjson changed after the package was exported; verify the package as exported, or export it again
  code: urn:chio:error:attest:provenance-missing
  docs: https://chio.computer/docs/reference/errors#error-attest-provenance-missing

Exit 1 is the expected refusal. A shell running with set -e stops at this command, so run it on its own.

You should see a file hash mismatch for receipts.ndjson and exit 1. Import runs the same verification, so the partner refuses a changed package too. A tenant-scoped manifest also carries a structured disclosure notice naming the cross-tenant aggregate fields the checkpoint set reveals; an admin-all manifest omits it, because the operator asked for cross-tenant visibility.

A share carries receipts and their proofs. Trust activation and economic effect on the partner are separate acts, each taken by the partner under its own policy.

Where the import summary comes from

The summary fields are written by crates/platform/chio-control-plane/src/evidence_export.rs. The package format, the offline verifier, and what an import does to the receiving node are on Evidence Export.

Next: check what a buyer can verify from shared artifacts

Receipt lineage and buyer packetsBind a cross-organization call to its lineage and see what a hash-only verifier resolves.Evidence exportExport, verify, and import packages across a fleet.Open admissionDecide which peers may participate at all.

Establish federation · 5 of 7

PreviousDelegation NextFederation Walkthrough

The verifier works from the exported bytes

1. Sign the sharing policy

2. Export under the policy and import on the partner

Sign a bounded sharing policy and import the package

Refuse an export without a read boundary

3. Find the shared references from local activity

4. Verify the package, then a changed copy

Detect a changed package file

Next: check what a buyer can verify from shared artifacts