Work You Can Watch

Every number this movement publishes is produced by a program run over files already on disk. Nobody types a result in by hand. This page is about watching that happen: the work is listed while it is in flight, a run can be started and followed line by line, and it finishes whether or not you stay on the page.

A run starts either because somebody pressed Run or because the nightly clock fired; it goes onto one queue, writes a timestamped journal while it works, and ends in a dated publication that carries the inputs it was computed from. The browser only watches.

What it does

A calc engine is the pattern behind every published figure: files already on disk go in, the work runs in named stages, and out comes an artifact that is regenerable and never hand-authored. Eighteen are registered today, and the authority on how many is a machine-readable registry, not a sentence in a document. Each entry names the question it answers, how often it runs, and where its specification and its code live.

They all run on one queue, so one place knows what this install is doing. One console lists every engine at once: its question, what it needs before it can do useful work, whether it is running, how long for, and how the last run ended. "Never run" is one of the outcomes, because an engine nobody runs is an engine nobody notices is broken. The failed count is a button that opens the failing run's own log.

While a run is in flight it writes a journal: timestamped plain-text lines on disk, streamed to the browser as they are written. A tab opened during three runs is handed a snapshot of all three. If the connection cannot be held the app falls back to polling and says so, because the data is right either way but its freshness is not.

A job's state is a small vocabulary, deliberately un-collapsed:

• queued is not running. Work that has not started says so, instead of a progress bar frozen at zero, which reads as a hang.
• interrupted is not error. If the process hosting a run goes away, the run ends as interrupted and keeps the stage it reached. Reporting a restart as a fault teaches you to ignore the one status that means look at this.
• cancelled means a human asked it to stop. A running job is asked, never killed — killing work mid-write is how a half-written file is produced.

The work runs in the backend, not in your browser: close the tab or shut the laptop and the run keeps going.

Runs also happen without anybody pressing anything. Most engines fire nightly on a clock inside the app, a few weekly or quarterly, and at start-up the app re-fires any engine whose last run has gone stale or whose source data has moved. A failed run is named rather than quietly fired again. Each pass publishes a frozen, dated result carrying the curated list, the tables in force and the exact commit of public data it read, so a figure published months ago can still be re-derived.

The goal it serves

A number nobody can watch being made has to be taken on faith, and faith is the currency Washington already trades in. One more source of unverifiable numbers would be worse than useless: a movement that cannot be checked is one that can be captured quietly and never found out, including by its own operators.

So the machinery is the argument. Everything this project says about a named person is an award earned or not earned, and that rests on the derivation being open: the official record or nothing for sources, arithmetic published so anyone can do it themselves, and a run you can start again and watch. That is the difference between a published derivation and a claim.

It settles a practical question too: numbers go stale and source records move, and somebody has to notice. Putting the runs, their clocks and their failures on one page is how volunteers keep a record current without a newsroom, and why the whole thing can be stood up on your own machine and audited by a stranger.

What keeps it honest

• Progress is derived, never invented. A percentage exists only when the work reports stage n of N. Otherwise there is an indeterminate bar and no number: a made-up percentage is the confident-and-wrong this product argues against.
• Every engine has to state its coverage. It computes who it was eligible to reach and states a cause for every blank. If a run narrows and stops reaching somebody who had an award, the last dated publication stands, marked superseded, rather than the award vanishing in silence. Where there is nothing to show, "no award has been given yet" is the answer — a statement about our knowledge, not a verdict.
• Run journals are install bookkeeping, not evidence. They stay on the local machine and never enter the public data record. What is published about a person is the result and its derivation, not the machine's diary of an afternoon.
• The console is not a public page. It is an administrator's surface on one install, and a citizen sees their own runs and nobody else's — a queue showing one citizen another's activity would be a leak dressed up as a feature. Run the software yourself and the control room is yours.

Works with

• Show The Arithmetic — the run produces the figure; that page is the published working you can redo by hand.
• Say What We Could See — every run declares what it could not reach, which stops a quiet failure reading as a finding.
• Your State House, Same Instrument — state coverage rides the same queue and clock, so a legislature is not a separate thing to trust.

Where to go next

• Open Data — the public record these runs read, in a repository you can clone.
• What the AI does — one engine calls a model; this is the fence around it.
• The core loop — where a run fits into the work a citizen does.
• Run your own instance — stand it up and watch from the inside.
• Get Started — hosted, or on your own computer.