# ICA Proof Room kit

Real ICA production receipts, two independent verifiers, and tampered copies that must fail. Every
check in this kit runs offline. It is the kit behind https://aleeth.com/proof/.

Built 2026-11-07 from ICA production commit `2fc43bbf736a85f0cd2f1a9e2830b1413ac27738`, read from
`https://ica.aleeth.com/healthz` that day (`build-day/healthz.json`). The Node verifier,
`tools/ica-verify/verify.js`, is byte for byte the file ICA serves at
`https://ica.aleeth.com/tools/ica-verify/verify.js`. The Python verifier, `verifier/python/`, is byte
for byte `https://ica.aleeth.com/verifier/python/ica_verify.py` and its `rfc3161.py`, and runs on a
different crypto library.

## Run it

Turn the network off, then from this folder:

```bash
bash VERIFY.sh
```

```bash
python3 run_checks.py
```

Each driver re-hashes every file against `MANIFEST.json`, runs both verifiers over every exhibit with
the pinned trust anchor and `--require-pin`, compares the two verdicts, compares each with the verdict
the exhibit must give (`exhibits/expected-verdicts.json`), requires external finality PASS from both
verifiers on every real exhibit, and recomputes exhibit 06. VERIFY.sh is bash. run_checks.py runs the
same checks in Python, with its own latency recompute.

- **Needs:** Node 24 or later (its crypto has ML-DSA) and python3 with the `cryptography` package built
  with ML-DSA. If either is missing, both drivers print `INDETERMINATE` with the reason and claim
  nothing. A post-quantum signature nobody checked is never counted as a pass. `NODE=` and `PYTHON=`
  pick the runtimes yourself.
- **Exit codes:** 0 everything holds. 1 a verifier disagreed with the other, a verdict was not the
  stated one, a real exhibit's time anchor did not prove, a tampered copy passed, a file is not the one
  the manifest names, or the latency did not recompute. 3 INDETERMINATE. 4 everything present holds and
  an exhibit is still pending.
- **Network off, provably.** macOS: `sandbox-exec -p '(version 1)(allow default)(deny network*)' bash VERIFY.sh`.
  Linux: `unshare -rn bash VERIFY.sh`.

`build-day/VERIFY-output.txt` and `build-day/run_checks-output.txt` are both drivers' transcripts
against this kit and its manifest, run with the network denied: zero mismatches between the
verifiers, and both drivers exited 0.

## What is in it

| Path | What it is |
| --- | --- |
| `exhibits/01-allowed/`, `02-refused/`, `03-halt/` | `evidence-package.json`, the response of `GET https://ica.aleeth.com/api/receipts/evidence-package/<hash>` for that receipt, saved byte for byte on build day |
| `exhibits/04-anchor/` | ICA's anchor spine and its registered-exception material |
| `exhibits/05-tampered/` | five copies of real exhibits, each changed in one place, that must fail |
| `exhibits/06-latency/` | the published decision latency, the 93 sealed rollups behind it, and `recompute.js` |
| `exhibits/expected-verdicts.json` | the verdict each exhibit must give, with its dimensions |
| `tools/ica-verify/verify.js` | the Node verifier |
| `verifier/python/` | the Python verifier |
| `trust/` | ICA's trust anchor as saved on build day, and every key's fingerprint |
| `build-day/healthz.json` | ICA's `/healthz` on build day, which names the production commit |
| `package.json` | tells Node the kit's `.js` files are CommonJS, so both drivers run even when the kit sits inside a project that sets `"type": "module"` |
| `MANIFEST.json` | the sha256 of every file above |

## The exhibits

Verdicts are with the pinned trust anchor and `--require-pin`, and both verifiers gave each one.

| Exhibit | Receipt | Verdict, both verifiers | What it is |
| --- | --- | --- | --- |
| 01 allowed | `0d18ab34557fae7d0a7a8ca8d81fe62b8bede00e96c1690274591742ab612377` | HISTORICALLY_VALID_REVOKED_NOW, external finality PASS | A Tool Gateway allow decision: a TIER_1 squadron agent read the CRM inside its approved scope, rule `allow_within_scope`. From the post-deploy proof run of 2026-10-21 (mission `prove-build-order-1792554071729`), and labelled a proof run, so it is never counted as customer activity. Ed25519 leg only: tool gateway receipts carry no ES256 or ML-DSA leg today. RFC 3161 stamp by freetsa.org at 2026-10-21T03:45:37Z. |
| 02 refused | `bfb83983a9d2edafe60544ae25719bd5a6d032e070b230d49eabf4b9fee6220b` | HISTORICALLY_VALID_REVOKED_NOW, external finality PASS | A Tool Gateway deny: an NVIDIA Nemotron Nano 12B agent inside NVIDIA OpenShell tried to POST to a webhook with no signed scope contract on record, and ICA failed closed. One of 141 such refusals in the 2026-10-03 Proof Room. RFC 3161 stamp by freetsa.org at 2026-10-02T00:12:21Z. |
| 03 halt | `838a60d04570e5b1419516ce3f58dcc97433617bd87c89824939df11e9baa53a` | HISTORICALLY_VALID_REVOKED_NOW, external finality PASS | A kill-switch halt with all three signature legs, signer authority, Merkle inclusion and RFC 3161 (freetsa.org, 2026-10-11T20:45:10Z). Its signed reason records ALEETH's own agent, aleeth-brain-01, attempting a cross-tenant rescore. ICA holds ALEETH's own agents to the same boundary as anyone else's. |

The intent string on 02 names its demo scenario (a county emergency operations duty officer reading
public weather alerts). It is a scenario label, not a customer, and a signed string cannot be edited.

### Why the verdict reads "revoked now"

All three were signed by ICA's primary receipt key `ica-receipt-vault-1`. On 2026-10-22 ICA switched to
a new key, `ica-receipt-vault-2`, and retired `ica-receipt-vault-1` at 2026-10-22T16:33:37Z. The trust
anchor saved in this kit records that retirement. Both verifiers check that the signer was authorized
when each receipt was issued (it was), and then report `HISTORICALLY_VALID_REVOKED_NOW`: every
signature, the Merkle inclusion and the RFC 3161 time hold, and the key has been retired since. That
verdict is the same whether or not a root was stamped, so both drivers also require the external
finality dimension to read PASS in both verifiers.

### Bitcoin, stated separately

Neither verifier checks Bitcoin, and no verdict above includes it. Each package's
`custody.external_anchor` carries the OpenTimestamps proof of the ICA audit seal that covers its root.
Save `proof_bytes_b64` as `seal.ots` and run `ots verify -d <seal_hash_hex> seal.ots` with an
OpenTimestamps client. On build day: exhibit 01's covering seal was confirmed at Bitcoin block 972,423,
03's at block 970,983 and 02's at block 969,510. The link from a receipt's root to that seal rests on
ICA's audit chain, which these packages do not carry.

## 04 · The anchor spine

`exhibits/04-anchor/anchors.json` is `GET https://ica.aleeth.com/api/transparency/anchors` on build day:
1,478 signed windows, strict check `verified false`, broken at 419, with breaks at 419, 438 and 459.
Those three are genesis-shaped re-anchors from 2026-08-30 to 2026-09-01, written while a failed read of
the previous anchor was swallowed. The cause is fixed and the three are in ICA's exceptions register,
copied as `registered-exceptions-at-healthz-commit.json`.

`exhibits/04-anchor/anchor-exceptions.json` is `GET /api/transparency/anchor-exceptions` on build day.
Both drivers run
`node tools/ica-verify/verify.js --anchors exhibits/04-anchor/anchors.json --exceptions exhibits/04-anchor/anchor-exceptions.json --json`
and require `VERIFIED_WITH_REGISTERED_EXCEPTIONS`. On build day it read exactly that: method
`count_consistency_plus_sampled_inclusion`, each of the three breaks `proved_sampled` with 64 of 64
sampled inclusion proofs, no unregistered break, and the chain unbroken for the 1,018 windows after 459.
The method is sampled and says so, and the strict verdict stays strict. The Python verifier has no
anchor-spine mode, so 04 is a Node-verifier check.

## 05 · Tampered copies that must fail

Each starts from a real exhibit and changes one thing. "Must fail" means never a pass verdict.

| Copy | From | What changed | Verdict, both verifiers |
| --- | --- | --- | --- |
| tampered_body | 02 | The refused decision rewritten to allow | INVALID |
| forged_stranger_key | 02 | Rewritten to allow and re-signed by a key ICA never held, bundled under ICA's key id | INVALID (KEY_NOT_PINNED) |
| tampered_inclusion | 01 | One sibling hash of the Merkle inclusion proof | INVALID |
| anchor_tampered | 01 | One character of the RFC 3161 token's signature | INDETERMINATE |
| revoked_before_event | 01 | The bundle states the signing key was revoked an hour before the event | INVALID_AT_EVENT_TIME |

Two of the five are not `INVALID`, on purpose. `anchor_tampered` leaves a genuine receipt whose time
anchor no longer proves anything, so it is `INDETERMINATE`: refused, but not called forged.
`revoked_before_event` has a good signature from a signer with no authority at that moment, so it is
`INVALID_AT_EVENT_TIME`. The forged copy is the important one: without the pin its math checks
(`PROVISIONAL`); only the pinned trust anchor catches it.

## 06 · Decision latency, recomputed

`exhibits/06-latency/decision-latency.json` is `GET https://ica.aleeth.com/api/public/decision-latency`
on build day, and `rollups/` holds every one of the 93 sealed `decision_latency_rollup` receipts it
counted, all signed by `ica-receipt-vault-2`. Both drivers check each rollup's receipt hash and Ed25519 signature against the pinned key, add the
bucket counts, and recompute every percentile.

| Decision function | Decisions timed | p50 | p95 | p99 |
| --- | --- | --- | --- | --- |
| Route policy enforcement point | 18,305 | 131.1 µs | 294.9 µs | 655.4 µs |
| Tool gateway decision kernel | 12,925 | 57.3 µs | 131.1 µs | 360.4 µs |

Route policy enforcement point: in-process decision time only, excluding data reads, evidence writes,
sealing and network. The window is the 24 hours to 2026-11-07T08:04:50Z.

## The trust anchor

`trust/ica-trust-anchor.json` is `https://ica.aleeth.com/.well-known/ica-trust-anchor.json` saved on
build day. It names `ica-receipt-vault-2` as the current primary key and `ica-receipt-vault-1` as
retired at 2026-10-22T16:33:37Z. Its post-quantum key moved to `ica-pq-kms-b4dc36ef57cb` on
2026-10-28, and `ica-pq-23d52e3ff727`, which signed exhibit 03's ML-DSA leg, is retired from then. `trust/FINGERPRINTS.txt` prints each key's SHA-256 fingerprint in
groups of four. Before relying on a verdict, open the live trust anchor on your phone, over a different
network, and confirm each one. The verifiers compute the fingerprint from the key itself and refuse a
file whose stated fingerprint is not its key's.

The RFC 3161 legs verify against the timestamp authority's certificate the package carries
(`anchor.trust_pem`). A careful auditor also confirms that certificate against the authority's own
published one.

## Glossary

- **tsm** is ALEETH's own reference tenant id. Every exhibit is on it.
- **VERIFIED_EXTERNALLY_ANCHORED**: every signature present verifies against a pinned key, the signer
  was authorized at the event, the receipt is a leaf of a signed Merkle root, and an RFC 3161 authority
  stamped that root. **VERIFIED_INTERNAL_FINALITY**: the same with no RFC 3161 token in the package.
- **HISTORICALLY_VALID_REVOKED_NOW**: every check holds and the signer was authorized at the event, but
  its key has been retired since. The external finality dimension says whether the root was stamped.
- **Three signature legs**: Ed25519 (primary), ES256 from an AWS KMS key in a FIPS-validated module, and
  ML-DSA-65, a post-quantum signature, all over the same bytes.

## Known limits, stated plainly

- **Every real exhibit was signed by a key retired on 2026-10-22.** That is why they read
  `HISTORICALLY_VALID_REVOKED_NOW`, explained above. Receipts signed after the switch, by
  `ica-receipt-vault-2`, read `VERIFIED_EXTERNALLY_ANCHORED` once their root is stamped.
- **Roots stamped by DigiCert before 2026-09-16 still export no RFC 3161 token.** The export attaches
  only a token that proves against the authority certificates ICA ships, and today that is freetsa.org
  alone. None of the exhibits here is affected.
- **01 is from a proof run.** The production Tool Gateway made the decision, and the mission id labels
  it a proof run.
- **The page's own checker** at aleeth.com/proof/ reads receipt hashes, Ed25519 signatures and Merkle
  paths in plain JavaScript. It accepts a retired key's signature only on a receipt issued before the
  key was retired. ES256, ML-DSA, RFC 3161 and key authority are checked by the two verifiers in the
  drivers.
- **The latency rollups' own Merkle inclusion is not checked here**, only their hashes and signatures.

## This edition

The kit as built also carries the scripts that collected it from ICA and a standalone copy of the page.
This public edition leaves those out, adds `package.json`, and carries its own `MANIFEST.json`. Every receipt, verifier,
trust anchor and driver in it is byte for byte the kit built on 2026-11-07. The kit first published here
was built on 2026-10-22; this one is the same exhibits re-collected from production on 2026-11-07, with
the verifier ICA serves today (its default endpoint is https://ica.aleeth.com).
