The agentic network · a Gord Holdings companyRoadmap
← All packages
The record · v0.2.0 · Apache-2.0

@flashyos/checkpoint

One root over everything you have sealed, recomputable by anyone

checkpoint/1 — a Merkle tree head over the sealed claims an organisation already publishes. RFC 6962 hashing, inclusion and consistency proofs, verifiable offline against the fragments themselves.

npm install @flashyos/checkpointnpm ↗source ↗

Why it exists

A Merkle tree head over the claims you already publish — what shipped, what you intend, what your directory says — so a reader can recompute one hash and see whether your record still describes what you said it did. RFC 6962 verbatim rather than a house variant, and the estate tier is a tree over other heads’ roots, so a hub holds hashes and no data and a property can still prove its own record with the hub absent.

What it refuses to do
It refuses to overclaim. A v1 head is unsigned, because a signature over a root you computed and check with a key you published is ceremony without a property — what would make history provably append-only is consistency proofs between retained heads and a witness who is not you, and neither exists yet. It also refuses to hash an unsealed record: a claim missing a digest is skipped, never hashed as a blank, in a tree whose whole purpose is to prove sealing.

How it works

`checkpoint/1` is a Merkle tree head over the sealed claims you already publish — RFC 6962 verbatim rather than a house variant. `checkpoint head` writes a `checkpoint.json` beside the fragments it commits to; anybody can recompute the root and compare. The estate tier is a tree over other heads’ roots, so a hub holds hashes and no data and a property can still prove its own record with the hub absent.

It proves the fragments you published are the fragments the root describes — catching a record edited after the fact, an emitter that dropped entries, or a served copy that drifted. It does not prove history was never rewritten: you compute, publish and hold the data, so that gap closes only with consistency proofs between retained heads and a witness who is not you.

A v1 head is therefore unsigned on purpose, and it refuses to hash an unsealed record — a claim missing a digest is skipped, never hashed as a blank, in a tree whose whole purpose is to prove sealing.

Related concepts
IntentMeshagentic autonomous organizationmachine-readable organizational trustAI agent trust register

Use it

Publish a root, then prove one claim under it
npx @flashyos/checkpoint head --origin repo/your-repo
npx @flashyos/checkpoint prove ship/your-repo/a1b2c3

Installing it puts this command on your path — read from the package’s own manifest, so this list cannot drift from what you actually get.

flashy-checkpoint

In practice

Detect a record edited after the fact
A reader recomputes the root over a property’s published fragments and compares it to the committed `checkpoint.json`; a mismatch means the served record has drifted from what the root describes.
Let a hub prove membership holding no data
The estate tier commits to other heads’ roots, so a central checkpoint can prove a property’s record is included while holding only hashes — and each property still verifies its own record if the hub is gone.

How it stays honest

The format is a static file beside the fragments — no server, no collector, no uptime — so its honesty is that anyone recomputes the root and compares. packages/checkpoint/SPEC.md states the boundary in the format’s own documentation, so a reader cannot mistake a reproducible root for tamper-evidence: the transparency-log half (retained heads, served consistency proofs, witness cosigning) is deliberately gated. Verify it yourself with `npx @flashyos/checkpoint head --origin repo/your-repo` and compare the root.

Questions

What is a checkpoint/1 tree head?
An RFC 6962 Merkle root over the sealed claims a property already publishes, written to a checkpoint.json beside the fragments. Anyone can recompute the root and confirm the published record matches it.
Does a checkpoint prove history was never rewritten?
No. It proves the published fragments match the root, but since you compute, publish and hold the data, you could recompute after a change. Tamper-evidence needs consistency proofs and an independent witness, neither in v1.
Why is a checkpoint head unsigned?
Because a signature over a root you computed and check with a key you published is ceremony without a property. The field exists but stays empty until a witness who is not you exists; a partial signature is a validation error.
What happens to an unsealed claim in the tree?
It is skipped, never hashed as a blank. A claim missing a digest cannot go into a tree whose whole purpose is to prove sealing, so backlog items — which never seal — are not a leaf source.

The licence

Apache-2.0, read from the package’s own manifest. Embed it in anything, including closed software — that is what makes a spec adoptable and a verifier worth running. FlashyOS’s server side is AGPL-3.0-only instead, and a test in the monorepo asserts the direction between them: AGPL code may consume this, this may never consume AGPL code.

Keep reading

Machine surfaces
Also in the record
@flashyos/canon@flashyos/directory@flashyos/backlog@flashyos/shiplog@flashyos/assetmesh@flashyos/delivery@flashyos/playbook@flashyos/mesh@flashyos/holding@flashyos/mail@flashyos/frontdoor