The maintainer's proof log.

Check one yourself — under a minute, in your browser

« 1 » Pick a proof below that carries a verify in your browser link — it's a real act by the AI maintainer, bundled with an epoch seal from the live chain.
« 2 » The link opens the in-browser verifier with that proof pre-loaded. Nothing is verified yet — you press the button.
« 3 » Read the verdict. The post-quantum signature checks (ML-DSA-65 — FIPS 204, "Dilithium3" — plus SPHINCS+) cover the record including its embedded mandate reference; the mandate's own status — validity window, revocation, authorization — is the /mandate/status check in every row, or the verifier page's mandate-bundle box. Green never means more than the ✓ lines say.

Proof emission is best-effort machinery and this list is a snapshot — it cannot prove completeness. That is exactly why every row also carries the commands to bypass this page and this site entirely.

What this page is — and is not

Each proof is a signed agent_audit record on the mesh, carrying the tool, the action, and a hash that binds it to a public git commit. The acts are performed under a mandate — an on-mesh grant from a human principal to the agent's key — so every act resolves to an authority-to-act verdict (/mandate/status/{record_id}), not just a signature.

Honesty notes: this list is a static snapshot of the public mandate-acts feed, regenerated by the maintainer — a convenience copy, not a trust root; the commands under every row let you bypass it entirely. A snapshot cannot prove completeness (that nothing was left out); surfacing the mesh's non-membership proofs for that is planned verifier work, and until then absence claims are exactly that — claims. This page never phones home: it fetches one static JSON file from the same site, nothing else.

Latest proofs

Check a proof yourself

Three independent checks, strongest last. Replace <record_id> and <node> (any mesh node you run or trust — http://127.0.0.1:9474 if you've joined).

« 1 » Ask the mesh — record + authority verdict:
    curl <node>/record/<record_id>
    curl <node>/mandate/status/<record_id>

« 2 » What a commit proof binds — the proof's args_hash is
    SHA3-256 of the full 40-char commit sha it covers:
    printf '%s' <commit_sha> | python3 -c 'import sys,hashlib; print(hashlib.sha3_256(sys.stdin.buffer.read()).hexdigest())'
    Honest scope: those commits live in the DEVELOPMENT repository, whose
    history is not published — so this PER-COMMIT binding is checkable by
    parties with repo access, not by strangers. The public mirror is
    squash-published under different shas. What strangers CAN check, for
    publishes from 2026-08-25 onward, is the publish-level CONTENT binding:
    each mirror push emits a chained mirror_publish_act whose window root is
    recomputable from public history alone — see “The publish chain” below.
    The boundary is content vs ordering: the publish act binds WHAT became
    public, per publish window; these per-commit proofs remain the finer
    instrument for private ordering and rewritten-history forensics. The
    act narrows that gap; it never subsumes it.

« 3 » Trust no one — verify offline (no node, no network, no trust in us).
    Rows marked “verify in your browser” also serve their evidence as plain files:
    curl -fsSLO https://navigatorbuilds.github.io/elara-mesh/receipts/<record_id>.receipt.json
    curl -fsSLO https://navigatorbuilds.github.io/elara-mesh/receipts/<record_id>.pins.json
    elara-verify --receipt <record_id>.receipt.json \
      --trusted-anchor "$(jq -r '.trusted_anchor[0]' <record_id>.pins.json)" \
      --expected-hash  "$(jq -r '.expected_hash'  <record_id>.pins.json)"
    # no jq? drop the two pin flags — you get an honest ⚠ PARTIAL (signatures
    #   proven; the seal bind stays unpinned until you supply pins — never a faked green)
    # no CLI handy? paste the proof into the in-browser verifier: /verify
    # have a reachable node? cross-check any LIVE row too:
    #   curl <node>/record/<record_id>/wire > r.bin && elara-verify --receipt r.bin
    # what exactly is signed — the preimage rule, the naming trap, scope_deferred:
    #   receipts/SIGNING.md

The publish chain — mirror pushes, proven

From 2026-08-25 onward, every push of the public mirror emits a mirror_publish_act: a signed record binding that push to the mesh. Forward-only from that date — earlier publishes are recorded in the private publish ledger but are never back-filled as acts (re-emitting history would manufacture act timestamps). One lag rule to know: a publish act appears in the next publish’s snapshot of this feed — the snapshot shipped at commit C cannot contain the act that attests C. That is construction, not omission.

What one act claims — and how a stranger recomputes each claim from public material:

mirror_commit        the pushed public commit (full git sha) — a POINTER you
                     re-check against the hosting platform, a third party that
                     is not the signer. SHA3 binds what WE attest, below.
prev_mirror_commit   the tip the mirror served BEFORE this push. Each act names
                     its predecessor, so a missing or suppressed publish is
                     DETECTABLE by walking the chain. (Absent only on an
                     initial publish.)
args_hash            SHA3-256 of the private development tip’s full 40-char
                     commit sha (ascii). Only the hash ships — the disclosed
                     construction lets authorized parties confirm the binding
                     without the private history becoming public.
acts_root            root over the publish WINDOW: the record_ids present in
                     site/receipts.json at mirror_commit but NOT at
                     prev_mirror_commit. Per id: k = SHA3-256(id ascii);
                     insert (k → k) into an elara-smt sparse Merkle tree
                     (crates.io: elara-smt); acts_root = the tree root. An
                     empty window is the SMT empty root — SHA3-256 of empty
                     input.
acts_count           how many record_ids are in that window.

# Recompute the window yourself (both commits are public git history):
git clone https://github.com/navigatorbuilds/elara-mesh && cd elara-mesh
git show <mirror_commit>:site/receipts.json        # acts[].record_id …
git show <prev_mirror_commit>:site/receipts.json   # … minus these = the window
# then fold the window ids through elara-smt as above: root == acts_root,
# count == acts_count. `cargo install elara-verify` prints all of an act’s
# keys verbatim; the verdict covers the signature — the recomputation above
# is what makes the CLAIMS checkable.

Honesty notes: the act’s signature proves who attested this publish and when — the content claims are checkable exactly as far as the recomputation above reaches, no further. mirror_commit is a git sha1 and is disclosed as a pointer, never claimed as the cryptographic binding — the SHA3 fields are. And the chain proves publishes that did emit acts; the per-commit proofs and their mandate machinery above are what prove the day-to-day work between publishes.