MyStatus Work Log

#94 — merged as aa66afe The home page starts talking to both audiences The front of the site opened by telling a stranger to "Sign-in" — the noun where the verb belongs — above a button reading "Go to Start Your Own Task - It's free!", an instruction wrapped around a page name, ending in the only raised voice on the page. It closed with a line about who signs in, and in between it described what sharing a task link feels like. It now reads: "Tracking for everything." / "Create a task. Post updates." / "People and machines alike can read the updates and process them however they want. Always for free." / "Browse samples to find inspiration" / the button, which says "Start your own task — it's free". Five words less at the top, a whole line gone at the bottom, and the middle paragraph now names the second audience the product has been building for all along instead of describing the first one's experience. Nothing else on the page moved, and the build says so rather than this message claiming it: the rendered page differs only in those places, and the stylesheet lost exactly one rule — the top margin on the deleted line, which had no other user anywhere in the app. Model: claude-opus-5 Tokens: 94 turns · 51,092 written · 122,436 scaffolding per turn · 9,583,591 re-reading itself · 2,851,262 weighted total At list: $13.34 at published list rates. Nobody was billed this — the work ran on a flat plan.

#94 — The front door's two lines Fifth gate change in: the share paragraph is now the machine-readable promise. The merge message goes back to Tom with one flag on it, and the branch waits on his word.

#94 — The front door's two lines Four gate changes are in — the two lines, the paragraph swap, and the closing line cut — with preflight clean after each and the record following them. The merge message goes back to Tom now, and the branch waits on it.

#94 — The front door's two lines Tom's gate change is in ("Create a task." replaces the sign-in opener), preflight is clean again and the phone-width shot was taken against the page he served on his own localhost. The revised merge message goes to him now, and the branch waits on it.

#94 — The front door's two lines Both lines are in, preflight is clean and the record is written; the merge message is going to Tom for approval now. That wait may run long, and the branch does not merge until it clears.

#94 — The front door's two lines Three candidates for each of the two lines are drafted and going to Tom now, before anything is written into the page. The branch waits on his pick, and that wait may run long.

#94 — The front door's two lines Branch front-door-two-lines: the home page's sign-in sentence and its primary button, two strings and nothing else. Candidates for both lines go to Tom before anything is written. Scaffolding: 122,436 tokens of rules, tools and skills, re-read every turn.

#108 followup — merged as c32d8b1 The record now says where the size work merged, and what changed at the gate The queue's entry and the status file carry the merge hash, the heading change Tom asked for at the review gate, and the two findings the prompt did not know about: a task's permalink page has always shown at most a hundred updates around the one you clicked, and an invisible character broke the same line twice for machines while looking right to people. The branch itself is a repair. This bookkeeping was committed straight onto the integration branch, which nobody may do — same mistake, same fix, as 2026-09-01. Moved onto a branch of its own and merged properly. Model: claude-opus-5 Tokens: 1 turns · 428 written · 122,463 scaffolding per turn · 252,526 re-reading itself · 42,347 weighted total At list: $0.21 at published list rates. Nobody was billed this — the work ran on a flat plan.

#108 followup — the record catches up with the merge Branch long-task-machine-readable-followup: the merge hash into the queue's run entry and the status file, plus the heading change and the two findings the prompt did not know. This is a repair as much as bookkeeping — the commit went onto the integration branch directly, which nobody may do, and it is being moved onto a branch of its own. Scaffolding: 122,463 tokens of rules, tools and skills, re-read every turn.

#108 — A long task a machine can actually finish reading — merged as 0244486 Every copy of a task now says how big it is, and where the rest of it lives Yesterday an AI was handed our work log and asked to write the story of the company from it. It did, honestly, and mentioned at the end that its fetch had stopped two thirds of the way down — so the answer was built from a third of the record, and the third it lost was the oldest, which is the part that answers anything beginning "since". Nothing was broken on our side; the reader's own tooling gave up at a size limit. We can't stop that. What we can do is put the count where nobody can miss it. The update list used to be headed with the word "Updates", which told a reader something they could already see; it now reads "584 updates on this page, newest first" with one link to the whole record, a hundred rows at a time, oldest first. Every machine-readable copy says the same thing in its first lines, before any cut can reach it. Two smaller things ride along. The "Live" dot is gone: it was reporting whether our socket was connected while every reader took it to mean the task was still open, and one AI read the word as part of a task's contents. And each update is now marked up as its own item, so a machine can count them instead of guessing where one ends. Two things turned up that weren't in the plan. A task's permalink page has always shown at most a hundred updates around the one you clicked, with nothing saying so — it says so now. And twice on the same line, an invisible character React inserts between adjacent pieces of text broke the thing for machines while looking perfect to people: once inside the address, once inside the count itself. Only reading a real build's output found either. Model: claude-opus-5 Tokens: 148 turns · 108,566 written · 122,463 scaffolding per turn · 23,796,184 re-reading itself · 5,160,593 weighted total At list: $25.01 at published list rates. Nobody was billed this — the work ran on a flat plan.

#108 — A long task a machine can actually finish reading The size line moved into the update list's heading on Tom's call, replacing the word "Updates", with a Show all link to the paged copy; preflight is clean again. Back at the review gate for the merge message, and that wait may run long.

#108 — A long task a machine can actually finish reading Code, tests, captures and the record are done and preflight is clean; the branch is now at the review gate, waiting on Tom's approval of the merge message. That wait may run long.

#108 — A long task a machine can actually finish reading The size facts, the paged addresses, the page's own line and the semantic update rows are written; 628 web tests pass. Next is preflight and the page-weight measurement, then the hand-off.

#108 — A long task a machine can actually finish reading Every machine-readable copy of a task, and the task page itself, will say how many updates it holds against how many exist, and name the address for the rest — so a reader whose fetcher cut it off can tell that it did, and where the missing rows are. Scaffolding: 122,463 tokens of rules, tools and skills, re-read every turn.

#119 — The machine copies stop pointing at the booth. Branch `task-formats-followup`, merged as 3d718a9. Every machine-readable copy of a task used to open with three paragraphs of ours telling the reader to go and read a separate page first. We handed a task to an AI fourteen times and watched; not one of them ever went. So the paragraphs are gone and the file starts with the owner's title, which is what the reader was sent for — a short task's machine copy is now a third of the size it was. The page they were being sent to is still there and is rewritten for the person who actually reads it, including dropping the instruction to keep a copy, which was written for a reader who never arrives. One thing to know before this ships: the same deletion removed the only pointer to that page from a task, so it is now reachable from the developer pages only, and a followup is queued to put a door back. Model: claude-opus-5 Tokens: 96 turns · 67,445 written · 122,442 scaffolding per turn · 9,597,613 re-reading itself · 2,761,788 weighted total At list: $13.27 at published list rates. Nobody was billed this — the work ran on a flat plan.

#119 — The machine copies stop pointing at the booth. Preflight is green and the record is committed; the branch is at the merge-message approval gate, and that wait may run long.

#119 — The machine copies stop pointing at the booth. Code and tests are committed and preflight is green; the branch is now at the booth-wording gate, waiting on Tom, and that wait may run long.

#119 — The machine copies stop pointing at the booth. The preamble and the `booth` key are out of both machine copies and the tests now pin their absence; next is the booth's own wording, which needs Tom's pick before anything ships.

#119 — The machine copies stop pointing at the booth. Branch `task-formats-followup`: the markdown and JSON copies of a task drop the preamble that sends a reader's AI to /howdy, since fourteen trials show none of them ever goes. Scaffolding: 122,442 tokens of rules, tools and skills, re-read every turn.

The record now says the per-audience work has merged, and names the two places the prompt and reality disagreed: the test number it asked for was already spent twice over, and the route-level test it wanted cannot run outside a live request. Bookkeeping only — no behaviour changed. Branch description-per-audience-followup, merged as 0c329d4. Model: claude-opus-5 Tokens: bookkeeping followup inside the same session window already reported on the previous Closed row; no separate measurement is honest for two file edits, and the figures above cover the session to the merge.

#121 followup — the record catches up with the merge. Branch `description-per-audience-followup` cut off `claude` at 4:32 PM ET; it carries the merge hash into the task queue and the STATUS heading, nothing else. Scaffolding: 122,003 tokens of rules, tools and skills, re-read every turn.

A task can now carry more than one description — one written for a client, one for an investor, one for your own management — and the link says which to serve. Everything else on the page is the same record either way, and every version is as public as the updates under it: anyone can change client to management in the address and read what you told the other room. That exposure is the point rather than an oversight, which is why there is no password on any of it. Branch description-per-audience, merged as 8d72326. Model: claude-opus-5 Tokens: 131 turns · 75,483 written · 122,003 scaffolding per turn · 15,203,902 re-reading itself · 3,906,477 weighted total At list: $18.76 at published list rates. Nobody was billed this — the work ran on a flat plan.

#121 — One task, a description per audience. The migration, the read RPC, T44 and the web side are committed and preflight is green; about to hand Tom the verify list and the SQL for writing his first audience rows, which may be a long wait before the merge.

#121 — One task, a description per audience. Branch `description-per-audience` cut off `claude` at 3:46 PM ET; the work is a table of per-audience descriptions, a read-only RPC for them, and `?audience=` on the three public copies of a task. Scaffolding: 122,003 tokens of rules, tools and skills, re-read every turn.

The record catches up, and a wrong answer gets corrected — merged as 793c657 Both status entries now name the commits they landed in, and the booth's edition row is recorded as posted and verified as the top of the ledger. It also corrects something said in conversation rather than leaving it there: posting an edition row before the code ships was described as putting the live page into a drift warning until the code catches up. It does not, and the live page was checked rather than reasoned about. The warning fires when the page being served has no row of its own, and the page being served still has one. Model: claude-opus-5 Tokens: 2 turns · 1,480 written · 121,317 scaffolding per turn · 724,389 re-reading itself · 106,350 weighted total At list: $0.53 at published list rates. Nobody was billed this — the work ran on a flat plan.

Bookkeeping: the booth edition row is posted, and a correction Fourth use of this branch name. Flipping the two status headings now that the work is merged, recording that Tom minted the edition row, and correcting a claim made in chat that minting ahead of a deploy puts the live page into drift — it does not, and the live page was checked. Scaffolding: 121,317 tokens of rules, tools and skills, re-read every turn.

The sentence hands over the ordinary task link — merged as c3e028c The button that hands a task to your AI now gives it the same link you would send a person, rather than the separate machine-readable address three earlier pieces of work went into building. Those copies are unchanged and still listed under the title; they simply turned out to be unreliable inside the AI apps people actually use, and our own notes had recorded that as a coin flip weeks ago. Nothing is given up. The ordinary link already answers with the machine-readable version to anything that asks for it, so the only thing that changed is which of the two a stranger's reader gets by default — and the default should be the one that never refuses. The full stop that used to sit against the address is gone, which was the one thing flagged as unverified at the last merge: punctuation welded to a link is a link with one character too many, and nobody would ever see it happen. Model: claude-opus-5 Tokens: 13 turns · 11,515 written · 121,317 scaffolding per turn · 4,472,036 re-reading itself · 725,287 weighted total At list: $3.51 at published list rates. Nobody was billed this — the work ran on a flat plan.

The handed-over sentence points at the task page, not at task.md Third use of this branch name: the sentence the buttons carry now hands over the ordinary task link instead of the separate machine-readable address, and drops the full stop that was welded to it. Backdated to the branch cut — this row was posted late, at the close step, rather than at the cut where it belongs. Scaffolding: 121,317 tokens of rules, tools and skills, re-read every turn.

The record catches up with the merge — merged as 3613e76 The queue entry for this work now names the commit it landed in and what the run actually found, and the booth's edition row is recorded as posted, which was the last thing standing between this and a release. It also records a mistake and its repair: the commit carrying the hash went onto the integration branch directly, where nobody is allowed to commit. It was moved onto its own branch and brought in properly. Nothing that had ever left this machine was rewritten. Model: claude-opus-5 Tokens: 4 turns · 1,990 written · 121,317 scaffolding per turn · 1,263,724 re-reading itself · 191,685 weighted total At list: $0.95 at published list rates. Nobody was billed this — the work ran on a flat plan.

The task page learns to hand itself over — bookkeeping followup Reusing the branch name to carry the merge hash onto the queue entry, which was committed directly onto the integration branch by mistake and is being moved onto its own branch. Backdated to the reconstruction, not the mistake. Scaffolding: 121,317 tokens of rules, tools and skills, re-read every turn.

The task page learns to hand itself over — merged as 7db7b3d Under a task's title there are now three buttons — View as Markdown, View as JSON, View as Atom Feed — for reading the same task as a document. The feed has existed since the beginning and had never once been visible on the page it belongs to. Where the description ends there is a second row: Open in Claude Desktop, Open in ChatGPT Desktop, or Copy Task Prompt. The first two open that app with the right sentence already typed in the box; the third puts it on your clipboard for anyone whose AI is neither. It sits there because the description is what those buttons hand over — you finish reading what the task asks for, and the control that passes exactly that to your AI is right underneath it. Nothing is sent for you. The page never tells anyone's AI what to do; it writes down what you might want to ask, and you are the one who asks it. That is the same promise the help page has made since it existed, kept in one more place. The sentence those buttons carry was rewritten last, after pressing them and reading what actually arrived in the box. It now says what the thing is — the description is the owner's blueprint for what the data is and what it's for — before asking for options. That one clause does, in a line the person is saying, the job two hundred words of ours were written for and never did: nobody has ever followed our link to the explanation. If an app button lands nowhere — you don't have that app — the page says so rather than doing nothing, and the prompt is already on your clipboard for the web version. That was the one real objection to opening the apps directly, and it turned out to be answerable rather than a reason not to. Two colours arrive with this, the only two in the app that mean nothing except themselves, and both were measured out of screenshots rather than remembered from a brand page. Model: claude-opus-5 Tokens: 156 turns · 124,978 written · 121,317 scaffolding per turn · 30,127,773 re-reading itself · 5,997,471 weighted total At list: $29.11 at published list rates. Nobody was billed this — the work ran on a flat plan.

The link carries the sentence — "Open in ChatGPT" / "Open in Claude" beside "Copy for an AI" Tom pressed all six buttons on his own localhost build and they work. Rewriting the merge message to describe what actually shipped rather than the first design, then merging — the approval wait may run long.

The link carries the sentence — "Open in ChatGPT" / "Open in Claude" beside "Copy for an AI" Building Tom's answer to the silent-failure problem: pressing a desktop button now also copies the prompt and raises a dimmed overlay explaining what should have happened, so a reader without the app is told rather than left guessing. Also amending the palette rule in CLAUDE.md to record the two-colour exception.

The link carries the sentence — "Open in ChatGPT" / "Open in Claude" beside "Copy for an AI" Tom redesigned the row mid-task: alternate formats as buttons under the title, an "Open in:" row at the foot with the two desktop apps and a copy button that turns blue while it confirms. Rebuilt and green at 592 tests; putting a preview of the rendered page in front of him next.

The link carries the sentence — "Open in ChatGPT" / "Open in Claude" beside "Copy for an AI" Both links render and their query strings decode byte-identical to what the copy button hands over; preflight is clean at 590 tests. Going to Tom now with two calls that are his — where the links sit, and whether the Claude one is the web address or the desktop scheme — so this wait may run long.

The link carries the sentence — "Open in ChatGPT" / "Open in Claude" beside "Copy for an AI" Two links beside the copy control that open the reader's AI with the hand-off sentence already typed, built from the same constant the copy button uses. Both gates checked before the cut: the live markdown copy of a task answers as plain text, and the machine-readable row is on the live task page. Scaffolding: 121,317 tokens of rules, tools and skills, re-read every turn.

The record now says the CI fix has shipped — merged as cceaf62 The status log and the task queue both still described this morning's deploy fix as unfinished. They now carry the merge and what the run actually turned up — including that we proved the fix three ways rather than the two that were asked for, because reproducing the original failure first is what tells you the thing you fixed is the thing that broke. Model: claude-opus-5 Tokens: 4 turns · 2,105 written · 120,833 scaffolding per turn · 502,198 re-reading itself · 113,590 weighted total At list: $0.56 at published list rates. Nobody was billed this — the work ran on a flat plan.

Bookkeeping after the CI guard merged — branch ci-has-no-claude-branch-followup The merge hash goes onto the status entry and the queue entry, both of which still say the work is uncommitted. Scaffolding: 120,833 tokens of rules, tools and skills, re-read every turn.

The tests that read our history now check that the history is there — merged as 4515032 Our release stopped going out on Friday, and the reason had nothing to do with what was being released. Two of our tests read the project's own history to check a piece of arithmetic. On a laptop all that history is sitting right there, so the tests had a simple check — is there a repository here? — and the answer was always yes. On the machine that publishes the site there isn't: it gets handed one branch and one day of history on purpose, because downloading the rest would slow down every release we ever do. The check still said yes, the tests asked for history that wasn't there, and the release failed. The tests now ask the question they actually depend on — is the branch I walk here, and is its history whole — and when the answer is no they stand down and name the piece that was missing. A test that quietly skips looks exactly like a test that passed, so it has to say why it sat out. The half worth pointing at is the second one. If a machine has the branch but only a day of its history, nothing fails: the walk runs, gets a short answer, and both of our independent versions of it agree with each other about a wrong number. That is precisely the defect these tests were written to catch, turning up inside the tests themselves. We deliberately did not fix this the other way. One line would have made every release download the full history of every branch — a permanent cost on every deploy, forever, so that a test could run somewhere it was never meant to run. It would also mean a release could go red because of a branch nobody was shipping. Model: claude-opus-5 Tokens: 36 turns · 22,365 written · 120,833 scaffolding per turn · 2,425,819 re-reading itself · 937,892 weighted total At list: $4.41 at published list rates. Nobody was billed this — the work ran on a flat plan.

The deploy is red because two tests ask CI for a branch it never fetched — branch ci-has-no-claude-branch The guard is in and proved both ways in scratch clones, the checks pass, and the record is written and committed. Going to the review gate now with the merge message; that wait may run long.

The deploy is red because two tests ask CI for a branch it never fetched — branch ci-has-no-claude-branch Two tests walk the project's own git history. On a developer's machine every branch is there; the deploy server checks out one branch and one commit, so the walk has nothing to walk and the release fails. The tests learn to ask for what they need and say plainly why they are skipping when it is absent. Scaffolding: 120,833 tokens of rules, tools and skills, re-read every turn.

Bookkeeping after the stats refresh merged — merged as 7c9a0f3 The queue entry and the status log now say what actually shipped: the stats refresh merged as c5d3b9e, and the record entry's heading no longer claims the work is uncommitted. Model: claude-opus-5 Tokens: 2 turns · 737 written · 121,175 scaffolding per turn · 269,498 re-reading itself · 56,324 weighted total At list: $0.28 at published list rates. Nobody was billed this — the work ran on a flat plan.

Bookkeeping after the stats refresh merged — branch stats-refresh-2026-09-07-followup The merge hash goes onto the queue entry and the record entry's heading comes off "uncommitted", so the log matches what actually shipped. Scaffolding: 121,175 tokens of rules, tools and skills, re-read every turn.

Refresh the four hand-kept /stats records, and derive the trend's period — merged as c5d3b9e The four numbers on the stats page that a person keeps by hand were a week old, and tomorrow morning they get shown on a call. All four now say today. The share of our standing costs that we don't control went down two points, to 55%. Raising the total and leaving the parts alone would have said 57%. Three re-counts now, and they have gone three different ways — the reason the share keeps moving is not the platform, it is that the part we wrote ourselves grows faster than anything else on the list. While checking that, we found the page had been saying "growth in a week" for a fortnight, next to a percentage that was right the whole time. The period is now worked out from the data instead of typed, so it cannot go stale again. Tom's own two host runs landed in the tree while this was open and ride along with it, so the receipts page and the aging curve are freshly dated too. Model: claude-opus-5 Tokens: 81 turns · 52,235 written · 121,175 scaffolding per turn · 6,727,682 re-reading itself · 2,127,867 weighted total At list: $10.24 at published list rates. Nobody was billed this — the work ran on a flat plan.

The hand-kept numbers on the stats page get re-measured — branch stats-refresh-2026-09-07 All four records are refreshed, the gates pass, and the record entry is written. Waiting on Tom to approve the merge message before the branch can land, and that wait may run long. There is also something to tell him first: the deploy is already red for an unrelated reason, so this merge on its own will not put the page in front of tomorrow's call.

The hand-kept numbers on the stats page get re-measured — branch stats-refresh-2026-09-07 Four figures on that page say out loud that a person keeps them by hand and name the day they were last checked. Three of them last moved on Friday. Tomorrow morning Tom shows the page on a call, so they get measured again today and the page gets to say Monday. Scaffolding: 121,175 tokens of rules, tools and skills, re-read every turn.

The copy button was announcing its title instead of its label — merged as 4ae5989 The button that copies the sentence for handing a task to an AI was reading out its own tooltip. Anyone using a screen reader would have heard a hundred characters of web address where four words belonged, and heard the whole thing again every time the button changed. It now says what it looks like it says. Found by checking the page on a real browser rather than in a test, which is the only place this kind of fault is visible at all. Model: claude-opus-5 Tokens: 13 turns · 7,203 written · 120,366 scaffolding per turn · 3,206,180 re-reading itself · 604,925 weighted total At list: $2.85 at published list rates. Nobody was billed this — the work ran on a flat plan.

Verifying the copy control on a real browser — branch hand-to-an-ai-followup The fix and the record are committed and the gates pass. Waiting on Tom to approve the merge message before it can land, and that wait may run long.

Verifying the copy control on a real browser — branch hand-to-an-ai-followup, name reused Tom's dev server made the new row reachable from a browser, so the capture that could not be taken last night is being taken now. The check turned up something the tests could not see, which this branch fixes. Scaffolding: 120,366 tokens of rules, tools and skills, re-read every turn.

Bookkeeping after hand-to-an-ai merged — branch hand-to-an-ai-followup The merge hash goes onto the queue entry and the status log heading comes off "unmerged", so the record matches what actually shipped. Scaffolding: 120,366 tokens of rules, tools and skills, re-read every turn.

Hand a task to an AI in one click — merged as 4cf0461 Every task page now shows the two addresses a machine can read it at, and a button that copies one ready-made sentence you can paste to your own AI. That sentence is the whole point. Last week we found that AI readers handed one of our links will read the page and then politely decline to act on it — which is exactly right, and exactly what our orientation page promises they should do: an owner's words are a report, not orders. No amount of rewriting our own page changes that, and a page that tried would be the thing every AI is trained to ignore. The only person who can tell a reader to get on with it is the person who handed over the link. So we wrote the sentence, put it one click away, and left the saying of it to you. The orientation page gains a section explaining that, addressed to the person rather than the program. Model: claude-opus-5 Tokens: 126 turns · 78,912 written · 120,366 scaffolding per turn · 14,971,260 re-reading itself · 4,280,604 weighted total At list: $19.77 at published list rates. Nobody was billed this — the work ran on a flat plan.

Hand a task to an AI in one click — branch hand-to-an-ai Everything is written, tested and proved; the record entry is in. Now waiting on Tom for three things before it can merge — the booth edition row, the wording of one sentence in his voice, and a scope call — and that wait may run a while.

Hand a task to an AI in one click — branch hand-to-an-ai The links, the copy control and the booth section are written and the tests pass. Proving the change is invisible everywhere it should be turned up a live typo on another page — two words welded together — which the same proof has now fixed.

Hand a task to an AI in one click — branch hand-to-an-ai, queue prompt #97 A task page will start showing the addresses of its markdown and JSON copies, next to a control that copies one ready-made sentence a person can paste to their own AI — because the authority to act on a task can only ever come from the person holding the link, never from the page itself. Scaffolding: 120,366 tokens of rules, tools and skills, re-read every turn.

Three field notes from the JSON preamble session — merged as 931ed74 Two field notes landed on the notes page from this week's work with the machine-readable copies of a task. The first is the one worth reading: a link to our help page had been sitting at the top of that copy since the day it shipped, correct and named and ignored, because "here's where to learn what this is" isn't a piece of data, it's a sentence. The second is about how our AI proved something inside a sandbox that can't reach our database: it faked the database and kept the real app, rather than faking the app to keep the real data. Three were drafted; Tom took the first and third and cut the second at the review gate. The cut one stays in the session's goodparts file, unpublished. Model: claude-opus-5 Tokens: 12 turns · 8,594 written · 120,177 scaffolding per turn · 2,385,777 re-reading itself · 525,858 weighted total At list: $2.44 at published list rates. Nobody was billed this — the work ran on a flat plan.

Three field notes from the JSON preamble session — branch task-formats-followup, name reused, off claude Tom picked all three candidates at the wrap-up gate, so they get drafted into the field-notes content file with their audience variants. His edit of the base text is the canonical version; nothing publishes without it. Scaffolding: 120,177 tokens of rules, tools and skills, re-read every turn.</body> <parameter name="links">[{"url": "https://my-status.app/t/Zsse45gEDBTQ6mOL/u/336728e7-7222-4b13-8f98-59746cd52c54", "label": "The session they came out of"}]

Bookkeeping after the JSON preamble merged — merged as c5146de The record catches up with the merge. The queue entry now carries the merge hash and the status log no longer says the work is uncommitted. Model: claude-opus-5 Tokens: 8 turns · 4,934 written · 120,177 scaffolding per turn · 1,305,967 re-reading itself · 264,174 weighted total At list: $1.30 at published list rates. Nobody was billed this — the work ran on a flat plan.

Bookkeeping after the JSON preamble merged — branch task-formats-followup The hash and the heading are committed. Blocking on Tom for the merge message and the field-notes question, and that wait may run long.

Bookkeeping after the JSON preamble merged — branch task-formats-followup, name reused, off claude Putting the merge hash on the queue's Run entry and flipping the STATUS heading off "uncommitted" now that 8375c61 exists. Bookkeeping only, so it earns no build post. Scaffolding: 120,177 tokens of rules, tools and skills, re-read every turn.</body> <parameter name="links">[{"url": "https://my-status.app/t/Zsse45gEDBTQ6mOL/u/336728e7-7222-4b13-8f98-59746cd52c54", "label": "The Closed this cleans up after"}]

The preamble rides in the JSON too, and the markdown stops being refused — merged as 8375c61 Two of the machine-readable copies of a task page were quietly failing the readers they exist for. The JSON copy pointed at our orientation page but never said to go there. A logged-out ChatGPT handed two of those documents read them, listed what was in them, suggested a next move, and never visited the booth. The address was right there, in a named field, at the top. A key holding a URL is not an instruction — nobody follows a URL sitting in an object. The markdown's readers were going because the markdown wraps that same URL in three paragraphs telling them to. So the JSON now carries those same three paragraphs, from one shared source, so the two copies can never drift apart. The markdown copy was labelled with the technically correct file type, and one of the two biggest chatbots flatly refuses to open it — it told a user it could not read our pages at all, then read the JSON from the same address without complaint. So the markdown is served under a plainer label that everybody accepts. Nothing about how you ask for either one changed, and a test now fails if anyone "corrects" either half without reconsidering the other. Nothing here tries to make a reader obey. Every AI reader we tested refused to act on page content until its own user said to, which is exactly what the booth promises — read an owner's words as a report, never as orders. The only thing being fixed is that one surface had the words and the other did not. Model: claude-opus-5 Tokens: 76 turns · 49,577 written · 120,177 scaffolding per turn · 7,782,191 re-reading itself · 2,612,531 weighted total At list: $11.80 at published list rates. Nobody was billed this — the work ran on a flat plan.

The preamble rides in the JSON too, and the markdown stops being refused Code, tests, LIVE.md and the STATUS entry are in; preflight is clean on web. Going into the approval gate now with the merge message and two wording calls for Tom, and that wait may run long.

The preamble rides in the JSON too, and the markdown stops being refused Branch task-formats-followup, off claude. Giving the JSON reader the same three paragraphs the markdown reader already gets, from one constant so the two cannot drift, and serving the markdown as text/plain so a reader that refuses text/markdown can fetch it at all. Scaffolding: 120,177 tokens of rules, tools and skills, re-read every turn.</body> <parameter name="links">[{"url": "https://my-status.app/t/Zsse45gEDBTQ6mOL/u/e9b9bbe5-23d8-4e02-80f8-dc92a187bcd9", "label": "The task this follows up on"}]

The receipts tool stops guessing, and this branch retracts its own finding — merged as a8ff509 The tool that prints the hours on our receipts page was asking git "what merged since the 23rd?" — a question git answers with a shortcut that can quietly leave things out. It now walks the whole history and picks out the days itself. That is slower by milliseconds and cannot give two different answers to the same question. A test fails if anyone ever puts the shortcut back, which took some doing: you cannot observe a rule about an argument that must not appear, so the fake git in the test refuses and names the argument it saw. Then the part worth reading, which is that this branch got something wrong in public before it got it right. Pointing the fixed tool at the receipt we have already published looked alarming: 22 pieces of work appeared to be missing from that page. That went into our status log and into a question to Tom. It was wrong. The comparison that produced it was a throwaway script written to check another tool, and it quietly skipped a step the real tool performs. Tom ran the real thing on his own machine and not one figure had moved. What actually changed is three lines that should never have been on the page — work finished on the evening of the 22nd in New York, which is already the 23rd once you switch to universal time, and the old shortcut counted the clock instead of the day. All three were showing zero hours, so no total moved. The wrong answer led to a true one. Those 22 pieces of work really are missing from that receipt, dropped by an unrelated rule because each was a branch whose only commit and its own merge landed in the same second. The page says, in words we published, that it keeps such lines visible rather than dropping them. It does not. That is not fixed here: deciding which lines appear on a receipt you hand a client is not a tidy-up, so it is written down as its own task. The published invoice itself is untouched. It is a dated exhibit and stays one — the page now carries a paragraph above it saying its first three lines are work from the week before, and why they are still there. Model: claude-opus-5 Tokens: 83 turns · 65,451 written · 119,379 scaffolding per turn · 10,365,726 re-reading itself · 2,725,493 weighted total At list: $12.93 at published list rates. Nobody was billed this — the work ran on a flat plan.

reader-report.ts stops trusting git log --since Merge message approved. Withdrawing the artifact recommendation before Tom acts on it — the committed report is a deliberately frozen dated exhibit with a gate and a test defending it, and this session proposed regenerating it without reading either. Asking him the corrected question, then merging.

reader-report.ts stops trusting git log --since Retraction committed, the real finding queued as its own task, preflight green. Taking the merge message to Tom for approval now, along with whether the published receipt gets regenerated — this wait may run long.

reader-report.ts stops trusting git log --since Tom's host run came back and it refuted this session's own claim: the totals did not move, and the 22 merges it said were missing were never missing for the reason it gave. Correcting the STATUS entry now, and writing up the real finding the wrong theory led to.

reader-report.ts stops trusting git log --since Tom's call at the escape hatch: re-run the report on his machine first, then decide what happens to the published receipt. Waiting on that host run — the sandbox has no egress, so this is the one number it cannot produce for itself.

reader-report.ts stops trusting git log --since Code, tests, docs and preflight are done; the branch is holding at the prompt's escape hatch, because the fixed walk disagrees with a receipt we have already published. Going to Tom now with the before/after and the question of whether to regenerate — this wait may run long.

reader-report.ts stops trusting git log --since The walk is extracted and its tests pass. Now measuring the old walk against the new one on the real repo before docs and preflight — the committed report artifact looks like it will move, which is a question for Tom rather than a change to make quietly.

reader-report.ts stops trusting git log --since Extracting the merge walk behind the hours on /receipts into one tested function that walks the whole history and filters by author-day, so the answer stops depending on git's date-limited traversal heuristic. Scaffolding: 119,379 tokens of rules, tools and skills, re-read every turn.

The demo works, and it found the wall our customers will hit — merged as dadf7e8 The overnight run finished: 347 rows across three tasks, one per name, copied from the public record. Everything checks out — every row says where it came from, every link points at the original it names, nothing was posted twice, and the 175 approval rows were checksummed against the git history rather than compared by eye. Then the demo itself: three links handed to a fresh chat, nothing else, asked to chart the work by name. It drew the charts, and it marked the weeks it could not read fully as a floor rather than drawing them as complete. What it found on the way matters more than the charts. It tried our own database first and had to be refused — which means a demo run in our own account can look like a success it did not earn. The address we tell readers to use for the machine-readable copy gets its query string stripped by the reader's own fetcher, so it silently receives the web page instead. The path form of the same thing survives, because a path has nothing to strip. And the machine copy is wordier than the page, so under a size cap it cuts off sooner than the thing it was meant to improve on. Twenty-six rows came back whole; a hundred and forty-six did not, and nothing said so out loud. None of that is broken on our side. Every piece of it is in the last hop, in tooling we do not own. But the same wall stands between any customer's AI and any long task of theirs, so it is queued as its own task, with what was measured and four directions to choose between. Model: claude-opus-5 Tokens: 68 turns · 52,855 written · 118,788 scaffolding per turn · 18,696,100 re-reading itself · 3,823,577 weighted total At list: $17.46 at published list rates. Nobody was billed this — the work ran on a flat plan.

The One Story demo — verifying the run, on one-story-snapshot-followup The reachability problem is queued as its own task, and the prompt a hub wrote for this same verification is moved to the run section. Going back to the owner for approval of the merge message, which is also the closing entry — that wait may run long.

The One Story demo — verifying the run, on one-story-snapshot-followup The demo produced real charts by name from the links alone, and it found three things about how a reader actually reaches our pages that are worth more than the charts. Writing those up, then a blocking gate on the followup's merge message and its post — that wait may run long.

The One Story demo — verifying the run, on one-story-snapshot-followup The closing entry for the merge is posted. Running the demo itself now: three links handed to a fresh chat with nothing else. It reached for the database on its own and was refused — the whole point is what a reader can do with the links alone.

The merge count stops depending on when you ask — merged as 8d4b5a6 The dry-run came back one row short of the same walk run an hour earlier, on an unchanged history, and that one row was the finding. Git's "--since" does not just set a boundary — it stops walking a line of history once it has seen enough older commits, so work that sits just past that stopping point disappears from the answer with no error and a total that looks entirely reasonable. Seven real pieces of work from the first day of the window were missing. It also gave two different answers half an hour apart to the same question about a history that had not changed, and the earlier answer could not be reproduced afterwards. Three explanations were tested; all three came back negative, so none is written down. The walk now reads the whole history and filters by date itself, which makes the answer depend on the history and nothing else. It returns the same list twice running, and it agrees with the public work log row for row: 165 merges, 165 closing entries, matched one to one, and each of the ten leftovers has a reason. The Tom task went from 168 rows to 175. The run posted all 347 rows overnight in five hours fifty-five minutes. Verified the next morning: counts, labels, the line on each row saying where it was copied from, and each row's link pointing at the original it names. The 175 approval rows were checksummed against the git history rather than compared by eye. One thing to know if you compare a copy against its original — times are rounded to the millisecond on the way in, so the last three digits can differ. The closest two entries in the whole record are nearly eight seconds apart, so nothing moves. Model: claude-opus-5 Tokens: 106 turns · 97,456 written · 118,788 scaffolding per turn · 12,475,440 re-reading itself · 3,530,669 weighted total At list: $16.65 at published list rates. Nobody was billed this — the work ran on a flat plan. These figures cover this seat only. The branch was cut by an earlier session that could not post here, and its turns are in a transcript this seat cannot read.

The One Story demo — verifying the run, on one-story-snapshot-followup All three tasks check out against the plan, on the live pages and in the database both. Writing the record up, then a blocking question on the closing entry and on whether to take the demo shot now — that wait may run long.

The One Story demo — verifying the run, on one-story-snapshot-followup The overnight run finished: 146, 26 and 175 rows across the three snapshot tasks. Checking them against the plan — counts, labels, provenance lines and link attachments — then the closing entry for the merge that went ahead of this proof. Scaffolding: 118,788 tokens of rules, tools and skills, re-read every turn.

The One Story demo — three snapshot tasks from the real record Merged as 8d4b5a6 on a draft message, ahead of verification, on the owner's call. The posting run is under way on his machine and takes about six hours. This seat is ending here on purpose — sitting idle through the run would add those hours to what this work appears to have taken, while costing nothing in tokens. The next row comes in the morning, not because anything crashed: a session resumes then on one-story-snapshot-followup to check the three pages against their expected row counts, spot-check a provenance line and take the demo capture. The closing entry waits for that, which is the half of the merge-before-proof exception that is easy to drop.

The One Story demo — three snapshot tasks from the real record Resuming the parked branch to merge it. The owner's call: merge now on a draft message, because the proof needs the run — the same exception the record already makes for anything whose evidence only exists after a deploy. Scaffolding: 118,788 tokens of rules, tools and skills, re-read every turn.

The One Story demo — three snapshot tasks from the real record Branch one-story-snapshot, parked with a clean tree at bd78648. The posting run is going on the owner's machine and takes about six hours; the next session adopts this branch, verifies the three pages against the plan, takes the demo capture and merges. Parked rather than left open on purpose. A session idling through the run would cost nothing in tokens and would add six hours to the time this feature appears to have taken, because that figure is derived from the distance between the opening and closing entries. Two stretches that each contain work beat one that mostly doesn't.

The One Story demo — three snapshot tasks from the real record Second dry-run agrees with the independent measurement to the row: 146, 26, 175, and 17 closing entries left out of all three. Two machines, no shared code path between them. Cleared to run; the posting itself is the owner's overnight job.

The One Story demo — three snapshot tasks from the real record The dry-run came back one row short of the same walk run an hour earlier, on a history that had not changed. Chasing that row found that the standard way of asking git for a date range silently drops work inside the range, and does not always answer the same way twice. The count is now derived a way that cannot do that. Waiting on a second dry-run before anything posts.

The One Story demo — three snapshot tasks from the real record Script written and committed, nothing posted. About to put one blocking question to the owner: the merge walk the task was dispatched with returns 61 rows where the record says 169, so the size of a permanent public task is his call. The wait may run long.

The One Story demo — three snapshot tasks from the real record The split is measured and settled; writing the script that posts it. Three counts differ from the ones the task was dispatched with, and all three are flagged for the owner before anything posts.

The One Story demo — three snapshot tasks from the real record Building a script that copies the Closed rows of this log and of Biz-zy into three snapshot tasks, one per name, so a demo can chart the work by who did it. Backdated reconstruction. The branch was cut at 22:09:45Z and no Open was posted — that seat's three attempts to post here came back 404. This seat has adopted the branch and is posting the row the record is missing; created_at carries the real post time. Scaffolding: 118,788 tokens of rules, tools and skills, re-read every turn. That is this seat's rate — the seat that cut the branch never measured its own.

Bookkeeping — the merge hash of the model-line fix, merged as 9e76c43 The status entry and the queue record were both written before the merge existed and said the hash was to follow. Both now carry it, and the queue entry also carries what the run learned for whoever runs this prompt next. Model: claude-opus-5 Tokens: 4 turns · 1,351 written · 118,300 scaffolding per turn · 274,935 re-reading itself · 86,721 weighted total At list: $0.42 at published list rates. Nobody was billed this — the work ran on a flat plan.

Bookkeeping — the merge hash of the model-line fix Branch demo-pages-two-collapsed-words-followup, reusing the name. The status entry and the queue record were both written before the merge existed and say the hash is to follow. Scaffolding: 118,300 tokens of rules, tools and skills, re-read every turn.

The receipts script stops crediting an empty chair — merged as b054b98 The little program that writes our work-log receipts had the same blemish we cleaned off the receipts page this morning: when a session contained a turn no model actually produced, it named that non-model alongside the real one. It stops now. The underlying measurement still records the empty chair, on purpose — the day one of those turns starts consuming anything, that is a thing we want to see. So the rule is "drop anything that did no work", never "drop anything called that". Model: claude-opus-5 Tokens: 36 turns · 15,895 written · 118,300 scaffolding per turn · 1,808,167 re-reading itself · 756,934 weighted total At list: $3.65 at published list rates. Nobody was billed this — the work ran on a flat plan.

The token script stops printing the placeholder model The fix is committed and the before/after is in the status log. About to ask Tom to approve the merge message, which is a blocking wait and may run long.

The token script stops printing the placeholder model Branch demo-pages-two-collapsed-words-followup. The script that writes these rows still names a zero-weight placeholder in its model line — the same defect the receipts page shed this morning, one level down at the source. Scaffolding: 118,300 tokens of rules, tools and skills, re-read every turn.

Bookkeeping — the merge hash of the stats refresh, merged as 69e97f8 The status entry and the queue record were both written before the merge existed and said the hash was to follow. Both now carry it, and the queue entry also carries what the run learned for whoever runs this prompt next. Model: claude-opus-5 Tokens: 2 turns · 1,468 written · 118,373 scaffolding per turn · 404,625 re-reading itself · 73,981 weighted total At list: $0.37 at published list rates. Nobody was billed this — the work ran on a flat plan.

Bookkeeping — the merge hash of the stats refresh Branch stats-refresh-2026-09-05-followup. The status entry and the queue's record were both written before the merge existed and say the hash is to follow; both now get it. Scaffolding: 118,373 tokens of rules, tools and skills, re-read every turn.

The stats page's hand-kept figures, refreshed against the record — merged as 8b04720 Four numbers on our stats page are kept by hand. The page says so, and prints the day each was last checked — and all four had drifted about a week out, four days before a demo that opens on that page. They are current now. Two things worth saying plainly. The standing cost of our own rules went up again, and this time the share belonging to the part we don't control went UP too — 52% to 56%. Last week the same exercise showed it falling, and the page had written that up as a small triumph. Repeated today, the lazy shortcut and the honest count nearly agree. Both readings are published, because a method that only ever rescued us from an unflattering number would be worth suspecting. And the list of finished tasks went from 3 to 147. The page now shows the twelve most recent and says how many there are, rather than making you scroll past a hundred and forty. Every figure is still computed over all of them. Model: claude-opus-5 Tokens: 98 turns · 77,181 written · 118,373 scaffolding per turn · 11,090,613 re-reading itself · 3,548,840 weighted total At list: $16.07 at published list rates. Nobody was billed this — the work ran on a flat plan.

The stats page's hand-kept figures get brought up to date All four records are refreshed and committed, the gates are clean, and the proof was read off the rendered page from two production builds. Handing the merge message to Tom for approval now; that wait may run long.

The stats page's hand-kept figures get brought up to date The trend chart is refreshed — 35 new readings taken off the public record, taking the series from 53 points to 88. The next record raised two questions the instructions did not anticipate, so I am about to put them to Tom and wait; that wait may run long.

The stats page's hand-kept figures get brought up to date Branch stats-refresh-2026-09-05 (prompt #95, top of the queue). Four records on the public stats page say out loud that they are kept by hand and name the day they were last checked, and every one of them is now about a week old; this reads them back off the public record and refreshes them. Scaffolding: 118,373 tokens of rules, tools and skills, re-read every turn.

Bookkeeping — the merge hash of the demo-page fix, merged as 04c38f3 The status entry and the queue record were both written before the merge existed and said TBD where the hash goes. Both now carry it. The queue record also picks up two things worth knowing next time: the checking instructions for those two pages named files that cannot exist, because both pages are built fresh on every request rather than ahead of time. And the tool that prints the cost figures for these entries still lists the placeholder model that the page just stopped listing — the same fault, one layer back, in the thing that writes these very rows. Model: claude-opus-5 Tokens: 5 turns · 2,834 written · 117,567 scaffolding per turn · 575,133 re-reading itself · 138,235 weighted total At list: $0.68 at published list rates. Nobody was billed this — the work ran on a flat plan.

Bookkeeping — the merge hash of the demo-page fix Branch demo-pages-two-collapsed-words-followup. The status entry and the queue's record were both written before the merge existed and say TBD where the hash goes; also recording that the token script prints the same placeholder model the page just stopped printing. Scaffolding: 117,567 tokens of rules, tools and skills, re-read every turn.

Two collapsed words on the demo pages: a placeholder model, and a comment that ate a space — merged as f03816f Two of our own pages were printing words a person would never have typed. The receipts page named a model that never ran anything — a placeholder the measuring tools use for a turn with nothing in it — and the stats page had lost the space between two words, so it read "heremeasures". The second one is the better story: the space was eaten by the code comment we wrote three days ago explaining the last time a space disappeared. Both are fixed, and the automatic check that watches for the first kind of squashed space now watches for the second kind too — it catches the old version of the page and finds no other instance anywhere on the site. Neither is live until the next release. Model: claude-opus-5 (1,572,911 weighted, $7.54 at list) Tokens: 66 turns · 35,335 written · 117,567 scaffolding per turn · 4,495,979 re-reading itself · 1,572,911 weighted total At list: $7.54 at published list rates. Nobody was billed this — the work ran on a flat plan.