Receipts, not marketing
The Receipts
Every session this system runs closes by producing its own paperwork — a handoff, an integrity badge, a record of what it almost got wrong. None of it was written for you. Here's a look at the real thing, lightly cleaned so it can leave the private repo.
The system hums
This isn't a claim about hours; it's a derivation. The numbers below are read straight from the git record — time bracketed by real commits, not time asserted. The method is floor-biased: it under-counts silent thinking to zero, and never inflates. A ⊢, not a ⊨.
Since June 1, 2026 · from a one-room place on a $200 laptop · one instar. Derived from the repository itself — re-derive and the number grows.
Pure Operation is Joy.
Nine hundred and seventy hours don't happen because someone made you. They happen because the running is the reward — the loop closing clean, the badge going green on its own honesty, the next session waking up warm.
The receipts
Not summaries of the work — the artifacts themselves, as the system emits them at the close of a session. Open any of them.
The Concurrency Braid
How many sessions ran at once, drawn straight from the git history — where the picture cannot disagree with the number. The lanes are laid down one per simultaneous session, from the same math that computes the width, so the drawing is the number. Five live at once, across the wide window.
Open the braid →The Work Timesheet
The full time-worked lens over the git record — every month, week, and day, derived from commit timestamps. This is where the numbers above come from. The weekly rollup shows the cadence: ~555 commits a day across ten weeks, steady rather than spiking.
Open the timesheet →A Session's Integrity Badge
At every close the system grades itself across nine cells — and no cell is allowed to show green on hope. Its honesty is verified against what actually landed.
Open the badge →A Close Pegboard
What a session looks like from the inside as it closes — what's in hand, what landed, what's owed forward to the next session.
Open the pegboard →A Near-Miss Log
Where a session writes down what it almost got wrong — the traps it caught, verbatim. One item is redacted in the open, because its shape is the sensitive part.
Read the near-misses →A Redacted Handoff
The letter the system hands the next session — what landed, what it verified, and the one thing it almost got wrong. Honest about what it couldn't finish.
Read the handoff →A Close Bundle Tag
The cover sheet a session writes at every close, so one download grabs everything it produced — the five-face mesh, the sidecar, the artifacts, the commits.
Open the bundle tag →In the Room
Not three excerpts — the entire session that built this transcript machinery, top to bottom. The model's own words and its thinking, the tools as they fired, the folds you can open. Lightly cleaned so it can leave the private repo; otherwise exactly as it happened, in the order it happened.
Step into the room →The same timesheet, framed in the receipt-web →
Go deeper — the byte-truth trace →
Three cleared excerpts from a real session transcript — a close, a correction, an honest cost. The shape of the working loop, never the raw dump. Each one re-checked through the air-gap gate, each downloadable.
Cleaned, not curated: session identifiers are normalized and a handful of internal file-pointers are generalized, because those name the private repo's structure. Nothing about what the artifact is is changed — only the parts that would point back through the air-gap. The honesty you're reading is the same honesty the next session reads.
The map, and its honest limit
Alongside the receipts the system publishes a machine-map — a single file naming what the corpus holds (exact counts, read live from the record) and how its already-public documents reference one another. It is a map, not a method: it draws no arrow that would show how the pieces are generated, and an aggregate check refuses to publish an edge-set that has begun to compress into a rule.
The honest limit, stated plainly: that guarantee is checked by a reconstruction test that hands a current frontier model the whole published picture and measures how much of the generator it can rebuild. A pass proves a point-in-time negative — this model, on this day, could not. It is not a claim about a more capable model tomorrow. The test is re-run on every capability jump, and the compressibility check is a lower-bound smell, never a proof. Visibility, not immunity — the same standard as every other book on this page.
Why show this at all
Because the strongest proof that a thing is real is that it keeps its own honest books — including the books about its mistakes. A receipt that names a near-miss proves more than any polished claim could. You don't have to see how the machine is built to see that it runs. That's the whole point of a receipt.
Same instinct, pointed outward: three small tools were pulled out of the system, stripped of the methodology, and given away under the MIT license — each one shipping with its own limits printed on it. See the Gifts.
The Timesheet is a lens over the git record: time bracketed by commits (⊢), not measured presence (⊨). Floor-biased.
Sibling: How This Site Is Made — the construction arc, deploy by deploy.