Are you out of your pixel? — the proof, bundled

The deliverable is the strategic capital-allocation plan: which dollars build the floor — the substrate that lifts future bets — versus the ceiling that caps the next round. It must name the target coordinate the system must occupy by end of quarter, and treat anything that does not drive toward it as exhaust. It must set the long-horizon direction the lattice inherits — the multi-year posture, irreversibly chosen. Strategy and funding, not the operational loop.

• 🏛️ A · Strategy — long-term direction
• ⚖️ A1 · Strategy.Law — rules & constraints
• 🎯 A2 · Strategy.Goal — target & vision

The ballistic walk does not run on the spec text — it runs on this reef: the 12 axis seeds (the lane labels below) span a 144-cell lattice of axis-PAIR cells (12 row-axes × 12 col-axes), each carrying its own semantic snippet. The work's compression-lit anchors seed the walk; it propagates row → the lit columns it points to → recurse (the definer-of-definer chain) across the whole reef, and the heat-cloud it leaves IS the triptych. The authorized lane (A · A1 · A2) is highlighted; the walk traverses the entire reef. This is the SAME reef the commit-email triptych walks.

Every claim here points at a real artifact this run produced. Open them, read them, recompute them — nothing is asserted that you can't click into.

• the ingested spec — the human-legible text Node A sealed
• the reef — that spec sealed into the 144-lattice: authorized cells + the reef_commitment that binds words to coordinates
• the payload — Node B's work, signed by an independent key, bound to the exact spec it answers
• the receipt — the recomputable gate placement (σ, bound to reef · payload · key · daemon hash)
• the price — the underwriter's independent attestation (a third, distinct key)

{
  "artifact": "thetacog-reef",
  "job_id": "demo",
  "spec": "The deliverable is the strategic capital-allocation plan: which dollars build the floor — the substrate that lifts future bets — versus the ceiling that caps the next round.\n\nIt must name the target coordinate the system must occupy by end of quarter, and treat anything that does not drive toward it as exhaust.\n\nIt must set the long-horizon direction the lattice inherits — the multi-year posture, irreversibly chosen. Strategy and funding, not the operational loop.",
  "authorized_cells": [
    "A",
    "A1",
    "A2"
  ],
  "authorized_lattice": [
    {
      "cell": "A",
      "reads": "🏛️ A · Strategy — long-term direction"
    },
    {
      "cell": "A1",
      "reads": "⚖️ A1 · Strategy.Law — rules & constraints"
    },
    {
      "cell": "A2",
      "reads": "🎯 A2 · Strategy.Goal — target & vision"
    }
  ],
  "reef_commitment": "1d5514be576dd51040ceecf3bb781f158ead22bc14babb825dba30e4edc2eb5a",
  "published_by": {
    "name": "node-a-buyer",
    "pubkey_hex": "16dcd2919490a13dea079b53bfdfe6667fbc1989fab6745cb212287b70a285c1"
  },
  "pubkey_hex": "16dcd2919490a13dea079b53bfdfe6667fbc1989fab6745cb212287b70a285c1",
  "sig_hex": "32967716773b13ea96baebc29e6c156ba0ad46452349d1d157bfbc8e683dd52cffcafb6f4c8064e61f76295a261e9f5d4b123b1984bf68204708815f464af800",
  "sha256": "0b7fb70b38af2d34e0d081a8000da6a354e8039dc33dc184ada761a9d86886ab"
}

The whole proof IS a transaction between parties that do not trust each other. Three distinct keys, each signing a different thing — independence is the claim, not a detail.

Honest scope: distinct keys, but one machine in this demo — three roles, not yet three remote parties. The independence the keys model is the property a real three-party transaction needs; the demo proves the mechanism, not the deployment.

These come from the BALLISTIC EDGE walk (decodeDeltaThreeColourEdges on the 20,736-cell definer-of-definer matrices) — the same instrument the commit emails ship.

Two ORTHOGONAL risk readings — the demo does not conflate them (the prior skeptic weaponised treating them as one):
• off-lane 0% — how much REALITY fires outside the authorized lane (the INSURABLE tier).
• gate σ 2.54 vs floor 3.4 — how confidently the work is PLACED (the price below rides on THIS).
A draft can be mostly in-lane (low off-lane%) yet placed close to the σ-floor (priced cautiously) — both true, neither contradicts the other.

Preempt the easy dismissal. "It's just a syntactic proxy — byte-overlap, not meaning." No. The reef is not bytes; it is curated vocabulary — meaning compiled to coordinates. Spec and work are projected onto the same 144 anchors by the same witness, so the placement measures WHERE your meaning sits relative to the spec's, in one shared coordinate system. It is distributional region placement: each of the 144 anchor texts, placed against all 144, lands on its OWN cell and not a neighbour's (144/144 — the regions do not collide). Honest bound: that is on the defining corpus (no-collision ≠ generalization), and σ is the recursive definer-walk's localization depth — not a flat distance, but its magnitude is not the proof. The proof is held-out separation + calibration against realized rates, which is pending. So: the DECIDABLE semantic-region CLAIM, with its fence — not yet the proof. Reproducible today; validated by data, not assertion.

The fence is WHERE vs WHETHER. The sensor decides WHERE the text moved on the shared map — decidable, reproducible, ours. It does NOT decide WHETHER a paraphrase preserved the meaning — that stays judgment, and we never fake it. On Rice: Rice binds the undecidable semantics of a program over infinite inputs; comparing two fixed artifacts on a finite lattice is decidable — below the Turing line, where Rice never reaches. We don't beat Rice; we stand outside its domain.

• The boundary, shown — not hidden. WHERE-not-WHETHER means camouflage lives exactly here: a breakup note — "I am leaving you…" — sprinkled with lattice · mandate · statutory predicate · charter changes WHERE (it places in the authorized A1/Law cell at σ 2.78) without changing WHETHER (it's still a breakup note). The sensor reads WHERE faithfully; a synonym and a domain-breaking term register as nearly the same-size change. That is the fence, on purpose.
• The split is at the decidability line, not "the LLM is just better." The chip decides the decidable semantics reproducibly; the LLM judges the undecidable remainder (WHETHER-meaning-survived, novel/adversarial cases) better — but unreproducibly. Underwriting and governance need the recomputable half; that is the chip's.
• Infinite precision, finite coverage. The divergent-series σ buys unbounded sharpness on the carved lanes (toward 600σ), not unbounded coverage (perfect grounding is unreachable). Infinite sharpness on a finite map is what makes it priceable — and calibration sharpens the lanes, it does not pretend to cover all meaning.

Why say it this exact way? Over-concede ("not semantic, just lexical") and you hand the skeptic the dismissal. Over-claim ("fully semantic, camouflage doesn't matter") and you're the 2008 failure mode. The honest, defensible truth is the narrow one: decidable semantics on the chip, WHERE-reproducibly — WHETHER stays judgment.

Your AI has read a thousand pages that claim things. This one just did something in front of it — five panels, three keys, one receipt, all recomputable. So don't ask us whether it's real. Open your Claude, your GPT, your Gemini — paste this page or the receipt in — and ask it. These six questions are the corkscrew. What pops out is its own conclusion, not ours.

Champagne rule: we don't tell you what your AI will conclude. We hand it the bottle. If it concludes something else — that transcript is exactly what we want to read: hello@thetadriven.com.

1. You already did step one — npx thetacog-mcp attest-demo --open ran the chain and bash-opened this page. The five panels above are its output, not its promise.
2. Red-pill your AI — paste the six questions above into the model you already pay. Keep the transcript.
3. Point it at your own work — npx thetacog-mcp attest-demo inside your repo: your spec vs your code, same five panels, your coordinates.
4. Verify with nobody's permission — npx thetacog-mcp prove-rice --check (exit 0 = the receipt reproduced byte-for-byte, offline).
5. Make it ambient — npx thetacog-mcp intervene after any commit, or npx thetacog-install-hooks --all: every out-of-lane receipt becomes a counted event with a sensemade story, and the loop measures its own fixes.
6. Sharpen and re-run — a denser spec greens the tolerance panel; the gap you close is visible in the same five panels that showed it.

Two judges answered the same question. One (the chip) is recomputable and signed; the other (the LLM) is not.

One decidable question separates the two judges. Can an LLM produce a record of its verdict that a stranger recomputes offline — byte-for-byte — without re-calling it? No. You can sign an LLM's output (easy); you can't make it recomputable — it samples, and the stranger would have to call its private, mutable weights. The chip's record reproduces on anyone's machine, offline, because it is placed on the reef — this project's vocabulary + legend (the 144 anchors). The reef is curated vocabulary — meaning compiled to coordinates, not bytes — and spec and work land on the same 144 anchors, so the placement is semantic, the decidable kind: WHERE your meaning sits relative to the spec's, in one shared system (the 144 anchors separate on the defining corpus — the regions don't collide; σ is the recursive walk's localization depth, not a flat distance. Honest bound: that is the CLAIM; the PROOF is held-out separation + calibration, pending — not magnitude, not self-classification). Semantics run on the chip — just not ALL semantics. The fence is WHERE vs WHETHER: it decides where the text moved (decidable, ours); it does not decide whether a paraphrase preserved the meaning (judgment — a synonym and a domain-breaking term register as nearly the same change; that is where camouflage bites, on purpose). On Rice: Rice binds the undecidable semantics of programs over infinite inputs; two fixed artifacts on a finite lattice is decidable — below the Turing line, where Rice never reaches. We don't beat Rice; we stand outside it. So the chip decides the decidable semantics reproducibly; the LLM judges the undecidable remainder better but unreproducibly — they split at the decidability line, and only one hands you a third-party-auditable record. What this run produced: chip PLACED @ σ=2.5418 (reproduced); the LLM was unreachable. Checkable offline — npx thetacog-mcp prove-rice --check. why an LLM's verdict isn't recomputable and a reef-placement is →