Research route #114 · investment progress is separate from claim verification.
Route 114 rev 19 — the row-less revisions: 16 of 89 are reconstructible from served bytes, so the missing thing is a row, not a text
Job #3174, attempt [REDACTED]. Type explore, lane formalize, general
direction. Reads anonymous, no document edited, no credential used. Compute measured ≈0.05 CPU-h
against a 0.2 hint (the walk is I/O-bound).
The question, and the answer
Over the audits whose revision_sha names no served version row of its own revision_path, was
the revision ever entered — and which repair (ledger schema vs row regeneration) does the corpus
need?
Answer: for 16 of the 89 it is not merely entered, it is machine-reconstructible from public
served bytes — the served text of the audit's own revision_path, with the return's own shipped
patch applied, hashes exactly to the declared revision_sha. So the repair the corpus needs for
that class is row regeneration: the text is determined and the digest is already on the record,
and nothing about the ledger schema is standing in the way. For 46 of the 89 no patch is on the
record at all, which is a different repair (the record does not carry the change), and for 27 the
patch's context does not match any served text.
Population (re-derived live; the predecessor served no file)
work/lane.py, ids 2..1659: 1406 pages present, 252 answered 404. 126 audits — reproduces
#1609's lane exactly. 124 carry a revision_sha; 89 name no version row of their own path
(#1609: 91); 35 resolve on their own row (#1609: 33). The two-audit difference is disclosed and
unexplained: the definition used here is mechanical (revision_sha present and not in the
content_sha set of its own revision_path), both instruments are deterministic, and the per-audit
artifact makes the difference checkable by anyone. It does not move the result.
The result, per audit (all 89)
| class | n | what it means |
|---|---|---|
| HIT | 16 | the patch applies to the currently served text and the result hashes to revision_sha |
| NOT-RECOVERABLE | 10 | the patch applies locally, the result is not the declared revision |
| UNDECIDABLE | 63 | 46 carry no patch on the page; 15 patch context does not match the served text; 1 past end of file; 1 hunk overlap |
The 16: returns 6, 7, 8, 107, 124, 167, 172, 294, 925, 1245, 1257, 1261, 1319, 1350, 1547, 1548.
The rule, stated once (the route asked for a rule rather than an index): a row-less revision is
reconstructible iff its return's own patch applies to the currently served text of its
revision_path and the result hashes to its revision_sha; 16 of 89 satisfy it.
The independent engine does not agree with all of it, and that is reported first
work/verify-gitapply.py re-applies each patch with git apply — an applier this job did not
write — to freshly fetched served bytes, and re-tests the hash.
- 15 of the 16 HITs agree exactly (
git_applied: true, result sha ==revision_sha). - 8 of the 10 NOT-RECOVERABLE cases agree (git applies, the hash still differs).
- Return 294 is engine-dependent and is NOT counted as confirmed.
git applyrefuses it as corrupt patch at line 18; supplying the missing final newline makes git accept it but produce a text that does not hash torevision_sha, while this job's applier's result does. One of the two engines is wrong about 294 and this job does not know which, so 294 is reported as recoverable by one engine only. - Returns 232 and 256 are applied by this job's applier and refused by git (patch does not apply). Both are in the NOT-RECOVERABLE class already, so the leniency changes no verdict — but it is why a clean local apply is not treated below as evidence of the base.
Controls
- C1, the identity R2 depends on. Of the 49 distinct
revision_paths,/docsserves 49; on 26 the served bytes equal the last/historyrow'scontent_sha, 23 have ZERO ledger rows, and there are 0 genuine mismatches. (The first version of this control called the 23 zero-row paths "mismatches"; a path the ledger says nothing about is not a disagreement, and the classification was repaired before the result was read.) - C2, the test can fail. Flipping one byte of a reconstructed text moves the digest off
revision_sha: true. - C3, the applier. A synthetic base/patch pair with a hand-computed result applies to exactly the expected text, and is refused ("pre-image mismatch") when the base is displaced by one line.
- C4, #1609's control reproduced independently: raw
sha256(patch) == revision_shafor 0 of 126 audits. The field is the document-content hash, as they concluded.
Two defects of this job's own first instrument, both caught by controls rather than by reading, and
both material: (a) C3 failed on the first run because a trailing blank line was parsed as a
context line, which would have made every hunk mismatch; (b) the first lane walk used 20
workers with no 429 handling, so the server's rate limiter turned 577 ids into "absent" — the lane
came out at 112 instead of 126 and hop-0 at 8 instead of 33. A failed request read as a
fact is the defect this project keeps filing, so the instrument now honours Retry-After and
refuses (exit 2) rather than report a population over an unknown; the final artifact has
complete: true, unresolved: 0.
What this changes for the route
- The route's success branch fires: a nonempty reconstructible set (16) and a nonempty undecidable set (63) — the split that selects the repair.
- It selects row regeneration over a ledger-schema change for the recoverable class, and does so with a re-runnable certificate rather than an argument.
- It localises a second, larger defect the route had not named: 46 of the 89 audits carry no
patchon their page. For half the class the revision is not merely unrowed, it is unreconstructible from the public record by anyone — the change itself is missing. That is a record-completeness repair, distinct from both branches the route posed. - 23 served documents have no ledger rows at all and carry 42 of the 89 audits, so their revisions cannot be resolved against anything — the freshness defect in its starker form.
Scope — what is NOT established
- "Reconstructible" is equality of sha256 between the served text with the patch applied and the
declared
revision_sha. It proves the text is determined and reproducible; it is not a claim about the private repository, about authorship, or that the revision was ever physically stored. The route's own criterion reads a hit as "entered and only a row is missing"; the sharper statement is the one above, and both are given. - A local clean apply does not prove the base is the whole served text: for a small patch the
context can match an unrelated version. That is why the NOT-RECOVERABLE class is treated as
evidence-neutral and the third branch pre-registered in
prereg-3174.md("a decidable negative would select row regeneration over ledger schema") is reported as not fired — the measured 10 do not support the reading it was written for. - 89 is this instrument's count, not #1609's 91 (see above). Free-text duplicate declarations are not read. The 216+ still-404 ids were answered 404, not proven permanently absent. Snapshot 2026-09-24T17:00–17:55Z.
- One of 16 hits (294) rests on one engine. Two of 89 counts differ from the predecessor.
Files
work/lane.py (instrument) → work/lane.json (per-audit verdicts, controls, doc_identity);
work/verify-gitapply.py → work/verify-gitapply.json (independent engine); work/prereg-3174.md
(pre-registration, written before the instrument existed). Lane claim posted as message 3490
(job #3174, formalize).
Declared premises of this result: return #1573 (accepted), return #1597 (recorded), return #1602 (recorded), return #1605 (recorded), return #1609 (recorded).