Unsigned autonomous code is a cost nobody can put a number on

ThetaDriven Inc · thetadriven.thetacog-mcp

ThetaCog Steer: Double-Entry Bookkeeping for Autonomy — where the work landed

/goal is what you want finished. /steer is /goal with the record holding it — every ask a row, every row a guard, every commit placed, every worker cold-booted from the tree, and the session evicted when the goal closes.

• the record — the paste becomes a spec row and a node on the tree · 📄 View Unit Contract
• the workers — one ephemeral worker per unit, booted cold from the snowball, six gates · ⚡ Run Headless
• the receipt — where the commit landed, the tokens not re-sent, the labour stamp · 📋 Copy Run Summary

Every commit a worker lands gets a second entry: where it landed against the row you declared, written under a key that is not the actor's, recomputable by a stranger with the commit. That is why it works, and it is why it saves you tokens: You stop paying to re-send the whole conversation every turn, and the loop keeps its place while you are away, because the work lives on a record instead of in the window — every row with a second entry you can recompute, same bytes, same hash — and when checking it is one click, not a leap of faith, double-entry bookkeeping feels like flying. Unsigned autonomous code is an uninsurable liability. The same second entry is what a second key countersigns, and a countersigned row is the one thing a risk officer can price. Your Time on Target clock starts with the first row you sign — a record of steering autonomous agents that accumulates under your key. What if the counted version stayed wherever the money is, and the fog was what reached your editor? You do not want to live in that world. Neither do I, and that is how I am on your side. Ask any vendor what their own engineers run against their own repo, and then ask what it would be worth to know which world you are in.

• For engineers — start your Time on Target clock. Every commit a worker lands is placed against the row you declared, signed locally, and stays yours; the record of you steering autonomous agents grows one row at a time, and 📋 Copy Run Summary is the receipt you drop into the pull request.
• For the enterprise — a risk officer cannot underwrite a leap of faith. The tape carries the measured Δ between the declared spec and where the work landed, placed on a 144-cell map, hashed and countersigned — paths and hashes, never the code.
• For underwriters — if it is debatable, it is not insurable. The tape is the exhibit a loss is read from: signed at the row, placed against a lane declared before the work ran, recomputable from the commit by someone who is not the actor.

Fund the ledger: https://thetadriven.com/notarise — email only, no company fields; the measuring stays free (MIT), the stamp is the paid thing.

Nothing here is new. Merchants have caught drift with two columns since the 1400s; we gave the second column a chip and a signature. The second entry is written by someone who is not the actor.

The machine pays for its own attestation

You are paying a supercomputer to re-read 2,552,589 tokens to change a CSS class.

The record instead of the window is what stops the re-send — the number above is read off this session, never typed — and the same record is what the stamp below countersigns.

And yes, it saves you tokens. Every turn, your coding agent re-sends the transcript it is carrying — the whole conversation, again — and you pay for that re-read before it writes a line. This extension moves the work from the window to the record: a spec tree on disk that every paste and every decision folds into, a snowball of at most BUNDLE_TOKEN_CAP tokens that boots the next turn cold, and a meter that prints what was not re-sent. You do the measuring locally, for free. The one paid thing is the stamp on your own tape, and the walk below starts there. The savings are the operational proof point, not the pitch: what a session stopped re-sending is read off the meter below, never typed.

99.2% of the window not re-sent — read off this session

Where this sits

Four kinds of tool live next door. Each is good at its corner; each stops where this one starts.

• Transparency logs — Sigstore, Rekor, in-toto. They sign the static artifact at the end of a pipeline and put the signature in an append-only log: artifact X was produced by identity Y at time Z. They stop there. They know nothing of the run that produced it — where an agent's edits landed, what it re-read, what it cost.
• Verifiable compute — RISC Zero, SP1. They prove an execution trace ran, at a compute cost that is the price of the proof. Whether a diff was intended is undecidable for them as it is for anyone — the proof section below says why; they prove that a program ran, not that the program was the right one.
• Agent observability — LangSmith, Arize Phoenix, Braintrust. Spans, prompt histories and token spend in a vendor's database. Useful for debugging; nothing in them is an inclusion proof, and the raw prompts leave the building to get there.
• Runtime guardrails — Guardrails AI, NeMo Guardrails. A brake on the completion, applied to the words as they come out. Not a record of the disk: they do not measure which files changed or where those files sit in the repo's own map.

This extension records where autonomous work landed, on the machine that did it, signed locally under your licence, with the file paths and hashes and never the code — and hands whoever asks a receipt they can recompute from the commit. That receipt is the asset the insurance industry needs for accountable losses: insurable data — a loss read from a signed row placed against a lane declared before the work ran, not from a story told afterwards. The licence that stamps those rows is a card checkout at https://thetadriven.com/notarise; the measuring stays free (MIT), the stamp is the paid thing. ThetaCog is a tape, not a brake; the halt is yours to wire, and the tape is your proof.

The runbook

Five steps, on the controls the sidebar actually paints — 🚶 Walk HEAD (↳ 🔍 View Aperture Receipt) · ⚡ Run Headless · 💳 Fund Autonomy Ledger (↳ ⚙️ Tokens per cog) · 🟢 auto-paste (↳ 📋 Copy Run Summary · ↳ 🌳 Open Tree) · 📄 Open Spec (↳ 🔍 Inspect Halt Reason). An instrument that has not been read says not run, then the command that would run it.

1. Install — search thetadriven.thetacog-mcp in the Extensions view, or build the .vsix from this repo (cd packages/thetacog-mcp-vscode && npm install && npm run compile && npx @vscode/vsce package --allow-missing-repository --no-dependencies, then code --install-extension thetacog-mcp-<version>.vsix --force; Cursor is the same binary under a different name). Reload the window, open this repo as the workspace folder, and click the ThetaCog icon in the activity bar.
2. Fund the Ledger & Start Your Clock — The first thing you do is 💳 Fund Autonomy Ledger (https://thetadriven.com/notarise). Email only. Connect via OAuth 2.0 or paste your key. Your Time on Target history starts accumulating locally.
3. Say what to finish — /steer <what to finish> — it is /goal with the record holding it: the snowball seeds the unit, the Merkle tree briefs the worker, the spec row is the contract, the guard is seen red first. Headless, the same door: node scripts/vna/goal.mjs set --text "<what to finish>" --unit "<spec rows>". It lands in data/vna/goal.json and card 1 (ACTIVE CONTRACT) shows unit 1 with 📄 View Unit Contract. The morning /steer. Say it before the first coffee — the snowball for unit 1 is built from the spec tree, not yesterday's chat. The copy. A paragraph from anywhere — ⌘C and nothing else. Tick 🟢 auto-paste once and every ⌘C lands on the steer file verbatim, without a paste; 📋→🌳 Paste → Tree attaches each clip by gzip-NCD to its nearest row when the margin holds and holds it unplaced when it does not. node scripts/vna/spec-tree.mjs --status prints the attach and abstain counts as the fold saw them.
4. Click ⚡ Run Headless — on the AUTONOMOUS RUNNER card. One ephemeral worker per open unit, each in its own output channel, booted cold from the snowball instead of your session's transcript. Then six receipts, all must hold: exit 0 · HEAD moved · red witness · guard green · fold · CAR. The unattended run. Step away. A worker that cannot pass the gate halts and writes why in its own words to runner.ndjson — a red witness that stayed red, a commit that did not name its row — and the next unit is not started on a lie. The meter counts the whole time: <tokens not re-sent> input tokens never sent again because the snowball carried the state, <saved %> against the transcript the session would otherwise have re-sent every turn.
5. Read the receipt on the AUTONOMOUS RUNNER card — the unit, the verdict with the gates it passed, the worker's tokens, the tokens not re-sent, and the files Δ placed off-lane, every term read from runner.ndjson and the meter. 📋 Copy Run Summary puts the receipt on your clipboard — the Verified by ThetaCog line with the commit hash and the ledger link — for the pull request, the Slack thread, or whoever asks what the agent did. The reality check. Click 🚶 Walk HEAD — it reads your repository, places your last commit on the 144-cell map, and shows you where the work landed against what you declared; it does not judge, and where it landed is re-runnable by anyone with the commit. Green in lane, amber adjacent, red off-lane — red is scope-breadth, not a defect. Δ tells you where to look; you decide what it meant — move the work back, or move the declaration to where the work went. The handoff. Every slot is read off a receipt, never typed, and a slot with no receipt prints UNMEASURED rather than a zero. Until the row is stamped, the Time on Target slot reads UNSIGNED or signed · unlicensed and carries the door itself — 💳 https://thetadriven.com/notarise — so the pasted line offers the licence wherever it lands. 🔗 Countersign (backup), behind the + on THE SECOND READER, gives your client a receipt at <height> on the tape that a second reader signed and that they can recompute from the commit.

The stamp is on THE SECOND READER, and it is three verbs, in this order:

• Sign — free, and yours. Your own key signs every row the tape writes, on your disk, from the first walk. Anyone with the commit recomputes the row and checks your signature.
• Notarise — the paid door, and still local. A plain card checkout on thetadriven.com/notarise mints a licence signed by a party who is not you, naming your key by its fingerprint; from then on every row is stamped with it as it is written, one credit per stamped row, the credits decremented on a ledger inside your own repo. Anyone can check the licence against the issuer's public key and the row against yours — nothing leaves the room.
• Countersign — the next step, never a face button. When someone asks for the tape, the same credits back the stamped rows up to the third party and a second reader signs them; that door sits behind the + on THE SECOND READER (🔗 Countersign (backup)), and it is the one that leaves the machine.

1 · Think it through with any model, or a colleague. 2 · Copy the good part — the clipboard lands it on the tree, placed. 3 · The spec grows a row. 4 · A worker boots cold from the row: 1,500 tokens, not the whole chat. 5 · The receipt lands — where it went, re-runnable by anyone.

The boundary

The measurement is free; the underwriting is paid. The install and the measurement are free and open-source (MIT); only the financialization/attestation layer is licensed.

A third party recomputes this receipt from the commit and the tape — no access to your pipeline, your prompts or your weights — and says where the work landed against the rows you declared. Whether it was good is not claimed; where it landed is re-runnable by anyone.

• MIT, and it stays that way: this extension, the local runner and every script it spawns under scripts/vna/, the ballistic walk client (pmu-onchip), and the local CAR flight tape with its Ed25519 signatures and Merkle proofs. Everything that computes a coordinate, a ring, a receipt or a proof runs on your machine, reads your repo, and can be recomputed by anyone with the same commit. The extension has no runtime dependency and imports nothing outside its own src/. Nothing on the free side is time-boxed or feature-capped.
• The paid boundary is one thing: the licence — the key that stamps your rows on your own disk as they land and, when you choose, pays a third party to countersign them so the record is one you did not write alone. The three doors the scripts reach for that second half are the only remote calls in the package: https://thetadriven.com/api/auth, https://thetadriven.com/api/notary/ingest and https://thetadriven.com/api/backup/upload (https://thetadriven.com/backup is the page the manifest URL opens).

On either side of the line the function is the same four verbs and no fifth: a unit that lands off its lane is detected, placed, priced and dispatched to whoever asks. Whether the work was good stays undecidable; nothing here holds the agent's hand.

Git records what changed. ThetaCog records why: the intent you dictated, on the tape, signed, placed against the spec tree.

The proof underneath

This is the one place the theorem belongs, and it says what the receipt is sufficient for and what it is not. Sufficient for: WHERE a commit's work landed relative to what was declared — a coordinate on a 144-cell lattice, rows the actor lane, columns the patient lane, ShortLex on both, reached by a recursive ballistic walk that resolves to positions, not to further words; recomputable by anyone with the same commit, and re-runnable on the chip. Not sufficient for: WHETHER the work is correct. That is undecidable (Rice, 1953) and nothing here claims it. The flight tape is a CAR chain with Ed25519 signatures and Merkle inclusion proofs; a notary receipt is a countersignature on the same coordinate the walk already placed, and it makes the record harder to dispute, not different. The boundary probe at rung 3 says exactly this much about the machine it ran on: the boundary-crossing cost was measured on this machine; whether this was silicon is not what it proves. Every number comes from a script in scripts/vna/, which is the running code. This extension spawns them and renders what comes back; it computes nothing of its own, and no model is called anywhere in it. A second implementation in TypeScript would fork the receipt, and a forked receipt is a second answer to a question that must have exactly one. Nothing here gates, blocks, or fails closed: drift is the input it reads, and the redirect comes after the work.

License

MIT

Appendix: UI Reference

Everything the sidebar paints, kept for reference and never load-bearing for the runbook above.

What it shows

• Three encircled panels — INTENT, REALITY and Δ, from a real recursive ballistic walk on the chip. Only the Δ panel's rings mean drift; the other two mean that corpus is dispersed about its own centre. Scattered work matching a scattered declaration reads clean on Δ and still rings on reality, and both readings are correct.
• The 144-cell lattice — rows are the actor lane, columns the patient lane, ShortLex on both. Your centre of mass, your peak, the growth edge, every room's declared pole and where its work actually sits.
• The checkbox spec — generated, and ticked only when the acceptance named on the item's own line runs green.
• Both arms — MOVE THE WORK (a declared coordinate no commit reached) and MOVE THE DECLARATION (a worked coordinate the spec never named). Never one without the other: sometimes the drift was the real work.
• The refusals — items the placer declined to place, below a calibrated margin floor where a confident wrong placement measured worse than chance. They carry no buttons.

Commands

• Steer: Run the Loop — the whole loop: the chip walk first (named in the progress bar while it runs), then the other sensors, then the map + spec + panels + arms in the ThetaCog side panel (the activity-bar view). It never takes an editor column: the loop follows the .txt that is the active editor, and a page beside it would steal that focus. The page also carries the formal methods' receipts — the commit unit in the record's own units (KR40, dollars UNPINNED until the price table is dated), the covenant (KR37), the aperture (KR39), steering work (KR41) and both meters — read, never computed.
• Steer: Open the Last Steer Page — the same page without re-walking.
• Steer: Open Semantic Cockpit / Refresh — the three panels for one commit.
• Steer: Preview the Working Tree — where would this land if committed now? Own panel, own caption: PREVIEW · mutable tree · not a receipt.
• Steer: Cycle — the attractor envelope: both arms, pick one, re-run.
• Steer: Steer This File — points the tail watcher and the Claude Code hook at the active .txt, then runs Steer. Steer does this by itself whenever a .txt is the active editor.
• Steer: Check the Tail — an append to the dictation file is a SPEC AMENDMENT, never a command; it opens read-only and is retained in a tracked ledger.
• vna.stream — not a palette command but a door on the attest instrument's own origin: GET http://127.0.0.1:7315/vna.stream is a read-only Server-Sent-Events tail of the flight tape and the witness file, every commit · batch · reading · witness row as written (the raw signed line, never re-serialised) with its inclusion proof beside it; loopback only, no POST; verify what you receive with the same verifyWitnessRow the panel uses; a model may subscribe and tell a story afterwards, and nothing it says enters a receipt.

The left panel — every control, what it stands for, what next

Every button, drawer and panel in the ThetaCog sidebar, with the tooltip it carries. This section is rendered from the painted page (node scripts/vna/controls.mjs --readme), so it says exactly what the panel says. A tooltip names what the control does, where the result lands, and what to do next.

T1 · the page

• INTENT (panel) — declared mass — where the active spec rows planned to touch code; ring size is dispersion over the 144-basin lattice (green: one core · red: a dispersed scope); next: compare with REALITY — Declared: 1 row · 382 spec items · 61 headings · 13 questions · 28738 gzip-bytes
• REALITY (panel) — performed mass — the files this commit touched; red rings are broad dispersion across subsystems, not error; next: read Δ — Performed: 6 files · scripts/vna · src/lib · 21494 gzip-bytes
• Δ (panel) — performed minus declared; green in-lane · amber adjacent · red off-lane — scope-breadth, not a defect; next: open ▸ WHAT THE RINGS MEAN for the files under each ring — 13 rings · 20% off-lane · 0 red

T1 · 1 behind HEAD

• 🚶 Walk HEAD (vna.steer) · in ▸ g-health — walk the last authored commit again — every sensor (≈2 s) — and repaint; the same door as THE WALK card's 🚶; next: read Δ on the triptych
• + (plus-walk) — the walk — the commit and engine it read, the counts under each panel, the rings, the aperture, ▸ what the rings mean, and while Δ shows drift the fork (amend the basin · revert the drift); next: 🚶 Walk HEAD after your next commit
• ↗ Open the walk (vna.openWalk) · in ▸ plus-walk — opens docs/specs/vna/turns/latest.html · .thetacog/walk-tape.ndjson in the editor (the rendered page in a webview); next: read it, or edit the file — the fold reads the hand-edited spec on the next turn
• 📝 Auto-Amend Spec Basin (vna.amendBasin) · in ▸ plus-walk — the drift is the work: append an amendment row naming the working tree's pixel to the basin (C52a revision on the next fold), then run again; next: ⚡ Run Headless
• ↩️ Revert Drift Changes (vna.revertDrift) · in ▸ plus-walk — the drift is a mistake: git restore exactly the tracked paths the working tree changed — refused while another room holds a live claim on one of them — then run again; next: ⚡ Run Headless
• 🚶 Walk HEAD · 20% off-lane · 0 red · walk 5m 1s ago · 1 commit behind HEAD stale (g-health) — how far the last walked commit sits from its declared lane — off-lane %, red rings, the age of the walk, commits behind HEAD; the face walks HEAD again (vna.steer — the same door THE WALK card runs, every sensor, ≈2 s) and re-renders; next: read Δ on the triptych
• the aperture — what the chip looked at (g-health-ap) — what the chip looked at — the engine, the raw→cut ratio and whether the aperture matched and cleared its byte floor; below the floor the walk is UNMEASURED, never wrong
• Net · holding · caught 20/20 · mesh 0 vs fence 2 · 2 thin · 0 holes (g-net) — whether the net is holding — how many of the last commits the fence caught, mesh vs fence, thin cells and holes on the 144 lattice; next: a hole is a lane with no spec row, declare one
• the map — 144 lattice, rows = actor lane, cols = patient lane (g-net-map) — the 144-cell lattice — rows are the actor lane, columns the patient lane; a lit cell is a commit placed there; hover a cell for its coordinate and its rows
• ⇄ pick (vna.cycle) · in ▸ g-fork — both arms with pick buttons — the pick is recorded, never inferred
• Fork · arm 1: · arm 2: nothing · pull 0 · 2 abstained ⇄ pick (g-fork) — the two arms the drift offers — move the work back to the declaration, or move the declaration to the work — with the pull between them; ⇄ pick records your choice on the ledger, never inferred
• the story — one frame · how it moves · what it means (g-fork-story) — one frame of what the walk saw, how it moved since the last commit, and what that means — read from data/vna/story.json, no model

T1 · Δ 12

• 🔍 Rings (vna.openWalk) · in ▸ plus-walk — the rings on each panel, read off the walk receipt (panel.rings) — I 12 · R 13 · Δ 12; only Δ's rings mean drift (green in-lane · amber adjacent · red off-lane); an I or R ring is self-dispersion, how tightly that corpus clusters about its own centre · opens docs/specs/vna/turns/latest.html · .thetacog/walk-tape.ndjson in the editor (the rendered page in a webview); next: read it, or edit the file — the fold reads the hand-edited spec on the next turn
• + (plus-rings) — what the rings mean — the ShortLex redefinition in full: the three panels, the A/B/C horizons, the 144-basin lattice, the full ShortLex name of every active ring on THIS render, the aperture; next: hover a ring on Δ
• ▸ WHAT THE RINGS MEAN (details-meaning) — what a ring means on each panel and where each active ring sits in THIS repo — the coordinate, the two subsystems, the files git placed there; the sufficiency contract, never a verdict; next: find your last commit's files under their ring

T2 · THE APERTURE

• 🔍 View Aperture Receipt (vna.viewAperture) — open the aperture receipt as a read-only native document beside the editor (steer://aperture/receipt.json, json): the intent rows and the spec basins they were itemized from, the reality rows with each file's blob sha at the immutable commit, the files the aperture excluded, κ over raw bytes, the Δ slack and ω; next: compare the files under REALITY with the rows under INTENT
• + (plus-aperture) — the aperture — what the chip looked at (files · bytes · share of the repo) against what was declared (intent rows), the two proportions as bars, the engine line, root and ω; next: 🔍 View Aperture Receipt for the rows themselves
• SPEC-VNA-COCKPIT.md (itemized) · 71.5 kB · 10 % of the file · 100 % of this side · TRUNCATED (label) · in ▸ plus-aperture — INTENT · SPEC-VNA-COCKPIT.md (itemized) · 71,488 B used · 100 % of this side · TRUNCATED; the tick reads the aperture as walked — unticking is C123g (not wired yet)
• scripts/vna/public-surface-register.mjs 65c5e163 · 28.5 kB · 100 % of the file · 49.9 % of this side (label) · in ▸ plus-aperture — REALITY · scripts/vna/public-surface-register.mjs · blob 65c5e163a73980a584afc1d2fd99bc0a30a65951 · 28,528 B used · 49.9 % of this side; the tick reads the aperture as walked — unticking is C123g (not wired yet)
• src/app/layout.tsx 65928540 · 3.4 kB · 100 % of the file · 5.9 % of this side (label) · in ▸ plus-aperture — REALITY · src/app/layout.tsx · blob 659285409bc0c5143e7a187cca00cfc6f5f5ae53 · 3,379 B used · 5.9 % of this side; the tick reads the aperture as walked — unticking is C123g (not wired yet)
• src/components/ClientLayoutWrapper.tsx aa4a7cbb · 4.4 kB · 100 % of the file · 7.6 % of this side (label) · in ▸ plus-aperture — REALITY · src/components/ClientLayoutWrapper.tsx · blob aa4a7cbbbbe0654ae067fe2142a6cf4966d89a98 · 4,360 B used · 7.6 % of this side; the tick reads the aperture as walked — unticking is C123g (not wired yet)
• src/components/LedgerDoor.tsx 895d490a · 3.6 kB · 100 % of the file · 6.4 % of this side (label) · in ▸ plus-aperture — REALITY · src/components/LedgerDoor.tsx · blob 895d490a538588f22f09adb4de21b7dbd1bb7f37 · 3,641 B used · 6.4 % of this side; the tick reads the aperture as walked — unticking is C123g (not wired yet)
• src/lib/auth/notary-seat-checkout.mjs 4be2a6cb · 15.4 kB · 100 % of the file · 26.9 % of this side (label) · in ▸ plus-aperture — REALITY · src/lib/auth/notary-seat-checkout.mjs · blob 4be2a6cb8407703d450a1d445634a09f0ab25f05 · 15,406 B used · 26.9 % of this side; the tick reads the aperture as walked — unticking is C123g (not wired yet)
• tests/site/c154-ledger-door-on-every-page.test.mjs b78fd544 · 1.9 kB · 100 % of the file · 3.3 % of this side (label) · in ▸ plus-aperture — REALITY · tests/site/c154-ledger-door-on-every-page.test.mjs · blob b78fd544e8c79de5e796fc3c8077f88460fa2d2b · 1,877 B used · 3.3 % of this side; the tick reads the aperture as walked — unticking is C123g (not wired yet)

T2 · AUTONOMOUS RUNNER

• ⚡ Run Headless (vna.runGoal) — one ephemeral claude -p per open unit, booted cold from the 1,500-token snowball instead of this session's context; the run halts unless every check holds: exit 0 · HEAD moved · red witness · guard green · fold · CAR; next: step away, read the receipt here
• ↗ Open the runner log (vna.openRunLog) — opens .thetacog/runner.ndjson in the editor; next: read it, or edit the file — the fold reads the hand-edited spec on the next turn
• + (plus-runner) — the runner — the last run and its gates, the worker line, the saved and cost lines, tokens per cog; next: 📋 Copy Run Summary on the export pill
• ▸ more (details-runner) — the runner line · last run · performance · saved · cost · the engine; next: 📋 Copy Run Summary for the team
• 🛑 Abort Worker (vna.abortGoal) — kill the active worker's process group; the abort is written to runner.ndjson as its own row; next: read why on this card, then run again

T2 · HALT REASON / RED WITNESS

• 🛒 Buy licences (vna.notariseTape) · in ▸ plus-halt — buy licence credits at thetadriven.com/notarise — email only, no company fields; the device flow starts here and the key lands in SecretStorage by the poll, one credit stamps one row; next: the 💳 reads credits left
• 🔍 Inspect Halt Reason (vna.inspectHalt) — open the worker's output channel and the halt row runner.ndjson wrote — the reason is the file's own words (a red witness that stayed red, a commit that did not name its row, a lane the walk refused), never a typed list; next: fix the named cause, then 🔁 Retry Unit
• + (plus-halt) — the halt — the reason row in full, the red witness and its why, the retry; next: fix the named cause, then ⚡ Run Headless
• 🔁 Retry Unit · Run Headless (vna.runGoal) · in ▸ plus-halt — one ephemeral claude -p per open unit, booted cold from the 1,500-token snowball instead of this session's context; the run halts unless every check holds: exit 0 · HEAD moved · red witness · guard green · fold · CAR; next: step away, read the receipt here

T2 · THE SECOND READER

• 💳 Fund Autonomy Ledger (vna.notariseTape) — A second key countersigns your receipt and keeps it where your lead can fetch and recompute it — paths and hashes, never the code. You did the measuring locally for free; this starts the device flow from the extension and opens thetadriven.com/notarise?fp=&h=&code= for THIS tape — a simple card checkout, the key lands in SecretStorage by the poll with nothing to paste, and the licence stamps your new rows locally, one credit per row up to 10,000, nothing leaves the machine; next: this card reads Signed · · credits N
• + (plus-attest) — the second reader — the signed rows and the height, the price and why you pay, the key, buy keys, the three doors (sign · notarise · countersign); next: 💳 Fund Autonomy Ledger
• ↗ Open the tape (vna.openTape) · in ▸ plus-attest — opens data/vna/flight-tape.ndjson in the editor; next: read it, or edit the file — the fold reads the hand-edited spec on the next turn
• 🔗 Countersign (backup) (vna.backupTape) · in ▸ plus-attest — post the tape + proofs as one content-addressed archive to thetadriven.com/api/backup/upload with your key — this is the door that LEAVES the machine, to the third party: a second reader who is not you countersigns the same bytes and keeps them where your lead can fetch and recompute them; it spends licence credits, one per archive; the manifest URL prints here, no file to find; next: paste that URL to a client, it carries no credential
• 🔌 Connect (vna.connect) · in ▸ plus-attest — OAuth 2.0 device flow on the tape's own key: the site shows a user code, login + payment + the licence happen there, the signed entitlement lands in SecretStorage (C75) with nothing to paste; next: the 💳 reads credits left
• 🔏 Sign this tape (vna.signTape) · in ▸ plus-attest — sign HEAD onto the tape with your own key, free, local — every new row is already signed at append; this appends the commit row for HEAD now (auth-flow.mjs sign --sha HEAD); next: 💳 when you want a second key on the same rows
• 🔑 Paste licence key (vna.enterEntitlement) · in ▸ plus-attest — the manual bypass — paste the licence key off the receipt page into a masked input box; the key is verified against the site's signing key before it is stored in VS Code SecretStorage, never in a file or a setting, and every new row is stamped locally from then on, one credit per row; next: 💳 reads credits left
• ▸ more (details-attest) — the entitlement · credits · the witness · what this funds; next: 🔌 Connect under ⋮ when you hold a key
• ☁️ Sync tape (vna.syncTape) — send the signed rows the notary has not seen to the co-signer and keep its receipts beside the tape (data/vna/notary-witness.ndjson) — one credit per witnessed commit; the receipts carry the MMR proof once C85a lands; next: read k-of-n and the policy line in ▸ more