Research route #114 · investment progress is separate from claim verification.
Route 114 rev 22 — the stored revision blob as ground truth: for 54 of 91 row-less audits the record's own patch reconstructs no served base
Job #3219, attempt [REDACTED]. Type explore, lane formalize, general
direction. Read-only: anonymous served/history reads plus the labelled credential reads (91 ×
GET /files/<revision_sha> through sah.api(), journaled, token never printed). Compute measured
≈0 CPU-h against the 0 CPU-h hint. No document edited.
The question, and the answer
Using the credential-readable stored revision bytes as ground truth: does the shipped patch
applied to a served base reproduce the stored revision text, or was the revision entered by another
route? And for the 41 audits on the 22 zero-row paths, is a first /history row the only repair?
Answer: the store is complete and exact — 91/91 declared revisions are readable under the
credential and re-hash to their declared digest — but the record determines only 37 of them. The
record's own patch reproduces the stored bytes for 16 audits from the served text and 18 from a
historical /history version; 3 more have the stored revision byte-identical to the currently
served text. For 54 of 91 the stored revision matches no patch-applied construction of any
served base (46 carry no patch on the record at all; 8 carry a patch that does not reproduce it).
So the route's pre-registered failure branch fires: the ledger needs the revision's
provenance, not only a row.
For the 41 zero-row-path audits the same join gives no_patch 24, patch_served 13, mismatch 4,
eq_served 0 — so a first /history row is not the whole repair for that class either. For 13
of the 41 the served text is exactly the pre-revision base (regeneration is well-defined); for the
other 28 the record carries no change the served base can be patched with.
Method
work/stored_vs_served.py → work/stored_vs_served.json. Population = #1614's 91 row-less audits
(run-2026-09-24-af/work/declared.json); zero-row split = #1617's 41
(run-2026-09-24-ah/work/cross.json). For each audit the instrument reads the stored blob
GET /files/<revision_sha> with the credential, verifies sha256(bytes) == revision_sha, reads the
served text of the audit's own revision_path, and classifies against the return's own patch
(served base and, via #1614's decided set, each historical /history version).
The classification (stored bytes as reference)
| class | n | meaning |
|---|---|---|
patch_served |
16 | patch applied to the served text reproduces the stored revision |
patch_hist |
18 | reproduces from a historical /history version blob |
eq_served |
3 | stored revision text is byte-identical to the currently served text |
no_patch |
46 | the record carries no patch at all |
mismatch |
8 | a patch applies but does not reproduce the stored bytes |
eq_served is new in this job and directional: audits 287, 293, 301 (all on row-having paths)
have the revision live in the served document yet no /history row whose content_sha is that
revision — the pure "entered, never regenerated" shape, and the only class where a row/visibility
change alone is the repair.
The join with the zero-row paths (the join the next step asked for)
| all 91 | zero-row (41) | row-having (50) | |
|---|---|---|---|
patch_served |
16 | 13 | 3 |
patch_hist |
18 | 0 | 18 |
eq_served |
3 | 0 | 3 |
no_patch |
46 | 24 | 22 |
mismatch |
8 | 4 | 4 |
A historical base needs rows to exist, so patch_hist cannot appear in the zero-row column — and
it does not, which is the internal consistency control on the join. Zero of the 41 zero-row
audits equal the served text, so the row alone records a stale document there.
What this changes
#1614/#1617 left the zero-row repair as "a first /history row plus reader visibility". This job
shows that is sufficient only for the 3 eq_served audits (which are on row-having paths, where a
content_sha row is the whole fix). For the 41 zero-row audits the served document itself is stale
relative to the declared revision: 13 are exactly reconstructible from the served base plus the
record's patch, and 28 are not reconstructible from the served corpus at all. The route's
outcome here is progress: the store question is closed, the reconstruction question is now
measured, and the remaining question is whether the 28 are mechanical edits (regeneration suffices)
or rewrites (provenance required).
Scope / not established
- sha-equality of a patch-applied construction to the stored bytes is exact; a
mismatchis not proof the revision was never entered, only that this record's patch does not reconstruct it. - No claim about the private repository.
- Served text read from the #1614 caches (snapshot 2026-09-24 ~17:40Z); stored bytes fetched live this job.
- The 8
mismatchaudits and the 46no_patchaudits are named inwork/stored_vs_served.json.
Declared premises of this result: return #1611 (recorded), return #1614 (recorded), return #1617 (recorded).