{
  "markdown": "# GRASP — Governed Reasoning And Signable Provenance\n\n[![CI](https://github.com/CodeTonight-SA/grasp/actions/workflows/ci.yml/badge.svg)](https://github.com/CodeTonight-SA/grasp/actions/workflows/ci.yml)\n\n**Try it in your browser:** <https://grasp-web-chi.vercel.app>\n\n**Reference implementation of cryptographic causation for AI systems.**\n\nWhen an AI makes a decision that matters, three questions decide whether anyone\ncan trust the record of it: *what did it decide*, *what did it believe when it\ndecided*, and *can every claim it made be checked against its source*? GRASP\nanswers all three with tamper-evident, replayable, externally-anchorable\nrecords — **what an AI decided** (a signed decision chain), **what it believed\nwhen it decided** (a signed memory chain), and **every outward claim it makes**\n(a deterministic citation-provenance floor) — bound together and falsifiable by\nconstruction, so a *skeptic* (a regulator, opposing counsel, an auditor) can\nindependently refute or confirm them. The verifier is the math plus an external\nparty, never the AI. Don't trust it — witness it.\n\n## Where GRASP sits (the open-core family)\n\nGRASP is the **open proof layer** of a wider stack. The position is open-core:\n*open-source the tools, licence the engine.*\n\n| Piece | What it is | Licence |\n|---|---|---|\n| **GRASP** (this repo) | The proof layer — the reference implementation of cryptographic causation (signed decision chain, signed memory chain, deterministic citation floor). | **AGPL-3.0-only** — open |\n| **HAPPI** | The open protocol the stack speaks — a specification, not a black box. GRASP's `cite.verify` is pinned byte-compatible to the HAPPI `cite.verify` verb (happi/1.3). | Open standard ([happi.md](https://happi.md)) |\n| **GRIP + HAL** | The reasoning + provenance engine (GRIP) and the LLM-agnostic multi-provider substrate (HAL). Not required to produce *or* verify a GRASP record. | Licensed / private |\n\nThe load-bearing consequence for anyone relying on a record: **GRASP records are\nproduced and re-verified by this open package alone** — no GRIP runtime, no HAL,\nno network, no account (see *Verify a receipt* below). The engine is licensed;\nthe tool that lets a skeptic check its work is not. Deeds, not words.\n\n## What is in the box\n\n| Module | What it does |\n|---|---|\n| `grasp.idr` | Signed Intent Decision Records (IDRs): flat-JSON envelopes, HMAC-SHA256 / Ed25519 / ML-DSA-65 / dual-hybrid over a canonical body digest, predecessor hash-chaining, content addressing that excludes volatile metadata, optional output-hash binding, JSONL persistence with POSIX locking. |\n| `grasp.idr_forest` | The forest that organises IDRs into a provenance graph **rooted at exogenous anchors only** (CI runs, human commits, cross-provider verdicts, pre-registered hypotheses), with an RFC-6962 Merkle root, `O(log N)` inclusion proofs, tamper-detecting verification, and deterministic replay. |\n| `grasp.merkle` | The RFC-6962 (Certificate Transparency) Merkle primitive: domain-separated leaf/node hashing, inclusion proofs, verification. |\n| `grasp.context_chain` / `grasp.context_head` | The signed memory/belief chain: append-only `context-delta` records with an atomic HEAD pointer, two-axis verification (per-node signatures + content-addressed blob presence), and a signed cross-reference (`records_idr`) into the decision chain. |\n| `grasp.prove_it` | The deterministic citation floor: every claim carries a verbatim quote; the engine verifies each quote exists in its cited source (exact → whitespace/typographic-flexible → not found), records exact character offsets, and renders a self-contained HTML artifact where every citation is clickable and a fabricated one renders **red**. |\n| `grasp.cite_verify` | The protocol twin of that floor — the same ladder as the `cite.verify` verb of the [HAPPI](https://happi.md) protocol (happi/1.3), pinned byte-compatible by a cross-implementation agreement test. |\n| `grasp.provenance` | The composition: one prove-it run writes an IDR leaf into the decision chain **and** a cross-referencing node into the memory chain — fail-open, so recording problems never block the artifact. |\n| `grasp.legal_receipt` | A signed filing gate built on the floor: a legal deliverable is SAFE TO FILE only when every quote is provably present in its cited source; any fabricated citation makes the CLI exit 1. **Never file a red.** |\n\n## The three legs, and why they compose\n\n1. **Decision record** — `grasp.idr` + `grasp.idr_forest`: signed envelopes\n   (what/why/how/when), predecessor-chained, organised into a forest whose\n   roots must be *exogenous* — something the AI does not control. A record set\n   that only confirms itself is theatre; exogenous rooting is what lets a\n   skeptic independently check the chain.\n2. **Belief record** — `grasp.context_chain`: an append-only signed chain of\n   the evolving mental model, so the record carries what the system believed\n   *at decision time*, not just its output.\n3. **Claim record** — `grasp.prove_it` / `grasp.cite_verify`: deterministic\n   verbatim-quote provenance. A hallucinated quote resolves to `not_found` and\n   renders red — it cannot earn a pass, because the check is arithmetic string\n   matching, not judgement.\n\nThey compositionally close: `grasp.provenance.record_proveit_provenance` writes\none prove-it run into **both** chains, and the memory node cites the decision\nleaf by content address *inside its signed body* — flip a byte of the citation\nand chain verification returns `BROKEN`. The conformance tests anchor this.\n\n**Scope honesty:** the citation floor proves a quote is **verbatim in the\nsupplied source** — not that the source is authentic, and not that the quote\n*supports* the claim. Support-checking is a caller-side layer (the L2 seam on\n`Citation.support`), and it must be fail-open: the deterministic floor is the\nguarantee; anything above it is recall.\n\n## Signing, honestly stated\n\nRecords are hash-chained and Merkle-rooted; sealed **HMAC-SHA256 by default**\nover a locally held key (`GRASP_SIGNING_KEY` env var, or a key file created on\nfirst use under `~/.grasp/keys/` with 0600 permissions — the key never enters a\nrecord; only signatures and a short key fingerprint do). Asymmetric signing is\nnow first-class: **Ed25519**, post-quantum **ML-DSA-65** (FIPS 204), and the\ndual `ed25519+ml-dsa-65` hybrid, selected via `GRASP_SIGNING_SCHEME` — the\ndefault is `ed25519` when the optional `cryptography` package is installed\n(`pip install grasp-provenance[pqc]`), else HMAC-SHA256. `grasp keygen`\ngenerates keypairs and prints the public key + fingerprint for publication; the\nverifier resolves verification keys from `GRASP_*_PUB`, `GRASP_VERIFY_KEYS`, or\n`<home>/keys/<scheme>.pub`, and marks schemes it cannot check as `DEGRADED` —\nmonotone toward safe, never upgraded to `VERIFIED`. The private seed never\nenters a record.\n\n## What GRASP proves — and what it doesn't\n\nThe full trust-boundary document lives at\n[`docs/THREAT-MODEL.md`](docs/THREAT-MODEL.md): the six adversaries the design\nconsiders, which attacks the arithmetic defeats (outsider tampering,\ntruncation-after-anchor, damaged ledgers, scheme downgrade), which it only\n*bounds* (the key holder under symmetric default; time against the Bitcoin\nclock rather than an eIDAS-qualified authority), and the ordered hardening\nroadmap that closes the gaps. We publish it deliberately — a verifier you\ncannot threat-model is marketing.\n\n## Anchored in the real world\n\nThe approach this package implements runs in production pilots whose Merkle\nroots are anchored into the **public Bitcoin blockchain**, independently\ncheckable on any explorer:\n\n- Pilot decision chain — committed via an OpenTimestamps proof to block\n  **956992**: <https://mempool.space/block/956992>\n- Post-quantum finance pilot (Ed25519 + ML-DSA-65) — dual-signed and anchored\n  via the same OpenTimestamps path; its anchor block details are shared in\n  evaluation materials on request rather than listed here.\n\nCheck it yourself — that is the point. To be precise about what this means:\nthose anchors witness *pilot deployments* of the approach; this package does\nnot anchor anything to Bitcoin on install. Anchoring is a deployment step you\nopt into: `grasp anchor` stamps the current Merkle root via OpenTimestamps\nand writes a continuity receipt of the exact leaf set it commits to — so a\nlater `grasp verify` can prove no anchored record was truncated or rewritten.\nIt refuses to anchor a chain that does not verify.\n\n### Checking your own anchor\n\nStamping a root and *confirming it reached a block* are different questions,\nand the second is the one that matters. Answering it the orthodox way needs a\nBitcoin node — and a node is not free. Even a pruned one performs a full\ninitial block download (758 GB as of 2026-08-01; `prune=` caps what is\n*retained*, not what is downloaded). More to the point, your node convinces\nonly you: whoever you are proving something to checks the anchor against\n*their* node either way.\n\nSo `grasp verify --anchor` works in tiers, and always says which one answered\nand what it rests on:\n\n| `verified_by` | What happened | What you are trusting |\n|---|---|---|\n| `bitcoin-node` | A reachable node confirmed it | Nothing — it validated the chain itself |\n| `multi-source-header` | Two or more independent block-header sources returned the **identical** header | That those operators would have to collude |\n| *(none)* | **Not confirmed** — a verdict is never manufactured | — |\n\n```console\n$ grasp verify --anchor\n...\nanchor_check:\n  confirmed:    true\n  block:        957120\n  block_hash:   0000000000000000000059a3e7682ab2d862cb6d0988afe8d4e890c93a07c21b\n  verified_by:  multi-source-header\n  trust:        2 independent block-header sources (blockstream.info,\n                mempool.space) returned the identical header, and they would\n                have to collude to forge it. This is NOT a local full node.\n```\n\nThe lighter tier is sound rather than a shortcut, because the cryptography\nstill happens on your machine: `ots --no-bitcoin verify` binds your digest to\nthe proof and **computes** the merkle root up from it through the proof's own\noperations. Only the \"does block N really carry that root?\" lookup is\noutsourced — a forged proof fails locally, before any lookup happens. Sources\nthat disagree are refused outright rather than out-voted, and a root the real\nblock does not carry is reported as a disproof that takes `ok` away.\n\nSet `GRASP_BITCOIN_NODE` to an RPC URL to use the node tier instead; no\ncode change is needed. A pruned node serves it fine, because the client only\nasks for `getblockcount`, `getblockhash` and `getblockheader`, and\n`getblockheader` reads the block index rather than block data — which pruning\nnever discards.\n\nThe anchor check is **opt-in** for a reason: plain `grasp verify` is offline\nand stays that way. `--anchor` is the only part that touches the network.\n\n## Install and run the conformance tests\n\n```bash\ngit clone https://github.com/CodeTonight-SA/grasp\ncd grasp\npython3 -m venv .venv && .venv/bin/pip install -e . pytest\n.venv/bin/python -m pytest tests -q\n```\n\nThe tests are hermetic (a throwaway `GRASP_HOME`, a fixed test signing key) and\nrun green in isolation — a fresh virtualenv with nothing else on the path. They\nare deliberately mutation-sensitive: mutate the verifier to always-pass and the\nfabricated-quote tests fail; skip signature verification and the tamper tests\nfail.\n\nRequires Python ≥ 3.10 on a POSIX system (file locking uses `fcntl`).\n\n## Use it from any MCP host\n\nGRASP ships an MCP server (`grasp-mcp`, standard library only), and this\nrepository is simultaneously a **Claude Code plugin + one-plugin marketplace**\n(`.claude-plugin/`), a **Gemini CLI extension** (`gemini-extension.json`), and\nan **Antigravity plugin**. One prerequisite for every local host:\n\n```bash\npipx install \"git+https://github.com/CodeTonight-SA/grasp\"   # puts grasp-mcp on PATH\n```\n\n| Host | Install | Guide |\n|---|---|---|\n| Claude Code | `claude plugin marketplace add CodeTonight-SA/grasp` then `claude plugin install grasp@CodeTonight-SA/grasp` | [docs/install/claude-code.md](docs/install/claude-code.md) |\n| Gemini CLI | `gemini extensions install https://github.com/CodeTonight-SA/grasp` | [docs/install/gemini-cli.md](docs/install/gemini-cli.md) |\n| Antigravity (`agy`) | `agy plugin install https://github.com/CodeTonight-SA/grasp` | [docs/install/antigravity.md](docs/install/antigravity.md) |\n| Claude Desktop | one `mcpServers` entry in `claude_desktop_config.json` | [docs/install/claude-desktop.md](docs/install/claude-desktop.md) |\n| OpenAI Codex CLI | `[mcp_servers.grasp]` in `~/.codex/config.toml` | [docs/install/codex.md](docs/install/codex.md) |\n| xAI Grok Build | `grok mcp add grasp grasp-mcp` | [docs/install/grok-build.md](docs/install/grok-build.md) |\n| Claude for Work / Cowork | remote-only — self-hosted bridge required | [docs/install/claude-for-work.md](docs/install/claude-for-work.md) |\n| ChatGPT (Developer mode) | remote-only — self-hosted bridge required | [docs/install/chatgpt.md](docs/install/chatgpt.md) |\n\nAny other MCP host registers the same server with one settings entry:\n\n```json\n{ \"mcpServers\": { \"grasp\": { \"command\": \"grasp-mcp\" } } }\n```\n\nThe behaviour contract travels with the install (`GEMINI.md` for Gemini CLI;\nthe `grasp-provenance` skill for the Claude Code plugin): call\n`grasp_record_decision` before consequential actions, `grasp_record_belief`\nat checkpoints, and `grasp_prove_claim` before asserting any sourced\nquotation (a fabricated quote returns `not_found` — it cannot pass). Ask the\nmodel to run `grasp_verify` at any time: every signature, the chain linkage,\nand the Merkle root re-check offline, and the verdict comes back exactly as\nthe arithmetic found it (`verified` / `degraded` / `broken`).\n\n**How to use it — just ask.** You are already running GRASP the moment the\nserver is registered; there is nothing to invoke by hand. Ask the model in plain\nwords and it reaches for the right verb — and every result comes back as one\nportable, glanceable card (box-drawing, no colour, offline-verifiable), the same\nshape in any harness:\n\n- **Record a decision** — before a consequential step: *\"record this decision\"*\n  → `grasp_record_decision` writes a signed IDR (what / why / how).\n- **Record a belief** — at a checkpoint: *\"checkpoint what we believe\"* →\n  `grasp_record_belief` snapshots the mental model into the signed memory chain.\n- **Prove a claim** — after any sourced assertion: *\"prove that quote\"* →\n  `grasp_prove_claim` verifies the quote is verbatim in its source; a fabricated\n  one returns `not_found` and cannot pass.\n- **Verify integrity** — any time: *\"verify the chain\"* → `grasp_verify`\n  re-checks every signature, the linkage, and the Merkle root offline.\n\nPrefer your own terminal? The same records verify with the Python package or the\n`tools/grasp-verify-receipt` script — no server, no network (see *Verify a\nreceipt* below). Deeds, not words — *facta, non verba*.\n\nRecords land in `~/.grasp/` (`idr.jsonl`, `context.jsonl`) — or wherever\n`GRASP_HOME` points — and re-verify with this package alone, no server and no\nnetwork.\n\n## Quickstart\n\nVerify a claim's citation, then record the run into both signed chains:\n\n```python\nfrom grasp.prove_it import render\nfrom grasp.provenance import record_proveit_provenance\n\nspec = {\n    \"title\": \"Limitation analysis\",\n    \"response\": \"The claim is time-barred [[cite:c1]].\",\n    \"sources\": [{\"id\": \"act\", \"label\": \"Limitation Act\",\n                 \"text\": \"An action shall not be brought after six years.\"}],\n    \"citations\": [{\"id\": \"c1\", \"claim\": \"Time-barred after six years.\",\n                   \"source_id\": \"act\", \"quote\": \"not be brought after six years\"}],\n}\n\nhtml, prov = render(spec)          # deterministic verification + HTML artifact\nprint(prov[\"grounding_rate\"])      # 1.0 — the quote is really there\n\nrec = record_proveit_provenance(spec, prov)   # IDR leaf + memory-chain node\nprint(rec[\"idr_addr\"])             # sha256:… — the signed decision record\n```\n\nGate a legal deliverable on its citations (exit 1 on any fabricated quote):\n\n```bash\ngrasp-legal-receipt spec.json --deliverable memo.md --out receipt.json\n```\n\nProve one decision is committed by a single Merkle root without revealing the\nothers:\n\n```python\nfrom grasp.idr_forest import forest_inclusion_proof, verify_forest_inclusion\n\nout = forest_inclusion_proof(forest, node_id)\nassert verify_forest_inclusion(out[\"content_addr\"], out[\"proof\"], out[\"forest_root\"])\n```\n\n## Activate a deployment\n\n`grasp activate` walks three acts and closes on the chain's birth certificate:\n\n1. **Tier** — `public` (records may be published), `private` (zero-egress by\n   construction: egress-capable backends are refused outright and the storage\n   self-check runs under an in-process socket blocker), or `combination`\n   (records stay private; only content hashes go to public witnesses).\n2. **Storage** — a live-probed picker over the six built-in backends (local,\n   bitcoin-ots, s3, sepolia, ipfs, website). Every probe is a real check with\n   a one-line remedy when a runtime dependency is missing — never a greyed\n   \"coming soon\".\n3. **Terms + access** — activation refuses until the install's license/terms\n   files are accepted; acceptance is a signed record bound to each file's\n   sha256, so changed terms honestly demand re-acceptance. Private and\n   combination modes collect a signed visibility allowlist and report whether\n   a PII-redaction seam is wired (`GRASP_REDACTION_CMD`).\n\n```text\n╭─ GRASP ● activated — chain born ───────────────────────────╮\n│ id         precog-1784069403-…                             │\n│ mode       private                                         │\n│ acl        true                                            │\n│ backends   local                                           │\n│ count      1                                               │\n╰─ facta, non verba ─────────────────────────────────────────╯\n```\n\nThe activation itself is the deployment's first signed decision record — the\nzero-telemetry claim ships with its own falsifier (`egress_guard()`), not an\nadjective.\n\n## Per-response prove-it footer\n\nA response whose claims are bound to sources (`[[cite:ID]]`) can close on a\ncompact provenance card — the moat proving the model's own claims, every\nturn. Three modes (`salient` default, `always`, `off`); the fineprint rows\nare plain URLs, so modern terminals link them with zero escape codes, and\n`grasp open <id>` is the fallback:\n\n```text\n╭─ GRASP ✓ prove-it — this response ─────────────────────────╮\n│ model      ◆ claude-fable-5                                │\n│ verified   true                                            │\n│ claims     2 — ✓2 ≈0 ✗0                                    │\n│ grounding  ██████████ 1.00                                 │\n╰─ facta, non verba ─────────────────────────────────────────╯\n┆ inspect  ~/.grasp/prove-it/41e3e9c8bc90.html\n┆ or run   grasp open 41e3e9c8bc90\n```\n\nThe inspect row is a plain path, never a `file://` URI — terminals that\nauto-link plain paths and https URLs do not link `file://`, so the URI\nform is the one guaranteed-dead click surface.\n\nA fabricated quote cannot pass: it renders ✗ and flips the card's glyph.\n\n## WITNESS — one gesture\n\n`grasp witness` fuses the three things an answer worth keeping deserves:\nthe rendered prove-it artifact you can open, the deterministic check over\nevery `[[cite:ID]]`-bound claim, and the sealed record anyone can verify\nwithout trusting us. It composes the footer, the IDR leaf, and the\nmemory-chain node this package already ships — no new cryptography, no new\nspec.\n\n```bash\ngrasp witness --input spec.json --model claude-fable-5            # see + prove + seal\ngrasp witness --input spec.json --model claude-fable-5 --no-seal  # stop at the floor\ngrasp witness --input spec.json --model claude-fable-5 --anchor   # then stamp the root (network; opt-in)\n```\n\nReal output (a two-citation spec, both quotes present verbatim):\n\n```text\n╭─ GRASP ✓ WITNESS ──────────────────────────────────────────╮\n│ model      ◆ claude-fable-5                                │\n│ verified   true                                            │\n│ claims     2 bound — ✓2 ≈0 ✗0                              │\n│ grounding  ██████████ 1.00                                 │\n│ decision   idr a17619c11470 · memory precog-1786655048-8e… │\n│ anchor     sealed · not yet covered by an anchored root    │\n╰─ facta, non verba ─────────────────────────────────────────╯\n┆ inspect  ~/.grasp/prove-it/85118dd7eef4.html\n┆ or run   grasp open 85118dd7eef4\n```\n\nRead the card the way a skeptic would, because every row is a handle:\n\n- **claims** counts BOUND claims only, and says so — the tally measures\n  citation discipline, not correctness, and assertions the author never\n  bound to a source are simply not measured. A fabricated quote renders\n  ✗, flips the glyph, and the command **exits non-zero**.\n- **decision** names the sealed IDR leaf and the memory-chain node — the\n  tamper-evident record of what was decided and what was believed.\n  Sealing is additive and fail-open: if recording fails, the row says\n  `unrecorded (degraded)` instead of showing a clean face.\n- **anchor** references an anchored Merkle root ONLY when the newest\n  continuity receipt actually covers this leaf, by arithmetic on the\n  receipt's own committed leaf set — and shows the root digest a verifier\n  can re-check, never a bare date. Until the next `grasp anchor` run, a\n  fresh seal honestly reads `not yet covered`. Sealed and anchored are\n  different strengths, and the card never blurs them.\n\nWhy this exists, in one sentence: an embedded watermark is a maker's mark\non the coin — it signals that an AI touched the artifact; WITNESS is the\nflight recorder and its maintenance log — the sealed, replayable record of\nwhat was decided, believed and claimed underneath the artifact. The two\nanswer different questions and compose (the EU AI Act's Article 50 marking\nserves transparency of content; record-keeping and explanation duties of\nthe Article 12/86 kind concern accountability of process). A witness says\n**sealed**, **tamper-evident**, **complement-to-watermarks**. It does not\nsay signed, non-repudiable, compliant, or true — a ✓ means the quote\nexists verbatim in the named source and the record has not been altered\nsince sealing, and nothing more.\n\n## Provider honesty — the floor that refuses to lie\n\nWhen a provider's salient claims fail the deterministic floor, GRASP blocks\nthe send, fails over down your provider ladder (nothing unproven is ever\nemitted), and records a signed event in the PRIVATE honesty ledger.\n`grasp honesty` renders the scoreboard; `grasp attest` re-proves the\ndeployment's own configuration guarantees and exits non-zero if any fails:\n\n```text\n╭─ GRASP ● provider honesty — floor-hold scoreboard ─────────╮\n│ ●          ██████████ 1.00  gemini-3.1-pro  ✓1 ✗0          │\n│ ✗          ░░░░░░░░░░ 0.00  grok-4  ✓0 ✗1                  │\n╰─ facta, non verba ─────────────────────────────────────────╯\n```\n\nThe public \"flagged providers\" view exists but ships OFF by construction —\nit activates only behind an enterprise switch AND a legal acknowledgement\nfile, and a test pins that default.\n\n## Shipped here vs. deployment concerns\n\nShipped in this package: the three legs, their composition, RFC-6962 Merkle\ncommitment + inclusion proofs, deterministic replay, the signed legal filing\ngate, and the conformance tests. Deployment concerns intentionally **not**\nbundled: external timestamping/Bitcoin anchoring (a deployment step, as above),\nasymmetric/post-quantum key custody (an integration path), and any L2\nLLM-based support checking (caller-side, fail-open by design).\n\n## Verify a receipt (without trusting us)\n\nEvery GRASP receipt can be re-checked with one command and nothing but Python's\nstandard library — no GRIP runtime, no network, no account:\n\n```\npython3 tools/grasp-verify-receipt SPEC.json RECEIPT.json --root .\n```\n\nIt re-hashes the deliverable and every pinned source, re-reads each citation\nquote at its recorded offsets (verbatim for `verified`; whitespace-only\ntolerance for `fuzzy`; `not_found` always fails), and recomputes the tally. Any\ntampered byte, shifted offset, or missing quote exits 1, loudly. The script is\n~200 readable lines — audit it in one sitting, or write your own from the spec:\nthe JavaScript and Python verifiers byte-agree on shared vectors, so you never\nhave to trust a single implementation. Bitcoin anchors verify through the\nupstream OpenTimestamps client (`pip install opentimestamps-client && ots\nverify <proof>.ots`) — not our code at all.\n\n## TMIF (declaration layer)\n\nGRASP's claims are also published as a signed\n[TMIF Claimant document](docs/tmif.md) —\n[`draft-laurie-tmif-01`](https://datatracker.ietf.org/doc/draft-laurie-tmif/),\n*A Standard for Claiming Transparency and Falsifiability*. To be precise\nabout the relationship: GRASP is **not** an implementation of TMIF. GRASP\nis the engine that produces tamper-evident records; TMIF is a declaration\nformat above it, and GRASP makes a natural reference Claimant because its\nartifacts (signed chain, in-browser verifier, Bitcoin anchor) are exactly\nwhat TMIF directs evaluators to verify. Where TMIF Claimants self-assert\ntransparency levels, GRASP under-claims by policy — see\n[`docs/tmif.md`](docs/tmif.md) for the signed document, the verifying key,\nand a copy-paste verification snippet.\n\n## Licence\n\n**AGPL-3.0-only** (see `LICENSE`). A provenance floor earns trust only if the\nverifier itself is inspectable — anyone relying on a GRASP record must be able\nto read, run, and modify the exact code that produced and verifies it, including\nwhen it is offered as a network service. Copyleft keeps that loop closed.\n\n**Commercial licences.** If the AGPL's network-use obligation does not fit your\ndeployment, a commercial licence is available — contact licensing@codetonight.co.za.\n\nCopyright (C) 2024-2026 Lourens Cornelius Scheepers / CodeTonight (Pty) Ltd.\n\nCopyright (C) 2026 [CodeTonight SA](https://github.com/CodeTonight-SA).\n",
  "bytes": 26163,
  "sha": "7623b0ae1e7b5554136bd2c76df67003b98e53d582b043436dacc80621bffbaa",
  "repo_slug": "codetonight-sa/grasp",
  "fonte": "repo",
  "truncated": false,
  "api": "https://agentalog.com/api/listings/plg_codetonight_sa_grasp_f755b919/readme"
}