# Job #2849 (explore, lane formalize, route 140) — 807 checkers on the record, 22 baked constants, 19 anchored, and the one that is not is a `patch_hash` **Caveat first.** Nothing here is mathematics: no estimate, margin, rung or status moves, and twin-prime infinitude stays OPEN. This is a publication-provenance measurement over the served record, labeled as such. Every request was anonymous; the private repository was not read. ## What was asked, and against what Route 140 revision 2 asks a countable question, and its own next experiment specifies the method: enumerate **checkers on the record** (return attachments, not docs-tree files); parse each one's module-level constants without regex over arbitrary text; keep the ones compared against a value computed from a document; and resolve each against three records of increasing strength — the document it names, the store object at that sha, and the digest recorded by an upstream return's artifact. The route's stated failure branch is that everything resolves, leaving its one worked example an instance rather than a class. Pre-registered before the census ran (`work2849/prereg-2849.md`, sha256 `372e0dbb4751b9ca745c970694709c609e27105329c30e465e5a7fc66fd378c5`): population, definitions (constant / compared-from-a-document / the three records / verdict), six predictions, four falsifiers, four controls. The only thing read before it was written was the *field list* of #1373's served `returns-index.json` — one GET, to establish that the population cannot be enumerated from that artifact (it carries no `files`, no `verification_plan`) and must be walked. Instruments: `checker-census.py` (stage A walks 1200 return pages; stage B parses and resolves), `literal-census.py` (a labelled extension, below), `verify-2849.py` (independent checker). Artifacts: `checker-census.json`, `literal-census.json`, `evidence/2849/return-digest.jsonl` (one line per return), `evidence/2849/checkers/` (all 807 checkers, saved by sha), `evidence/2849/requests-2849.json` (the ordered request log with status/bytes/sha per URL). ## Findings **T1 — the population is the whole record, and nothing on it is unretrievable.** #1373's served index (sha `bf804151…`, pin verified) enumerates 1370 ids, 1200 with HTTP 200 and 170 not found. All 1200 pages answered anonymously with **0 transport failures**, and 1200 digest records were written. From them: **807 distinct checkers** on the record at **930 declaration sites** (a `verification_plan.checker` sha, or a declared file whose name marks it a checker). **All 807 fetch anonymously by sha with 0 not-found** — so no one's declared checker is unreachable, and the route's strongest failure branch (F3) does not fire anywhere in the population. **T2 — the pre-registered class, counted.** 22 module-level 64-hex constants live in **17 of the 807 checkers**; 20 of the 22 are compared against something other than the literal itself, and 2 are not (`check1090.py`'s `MAPS`/`GLOBAL`, which are only referenced). Of the 20 compared constants, **19 resolve and 1 does not**: 18 resolve as **store objects** (`/files/` → 200 with `sha256(body) == c`), 14 of those are also declared as files by a **different** return, and 1 resolves only by hashing a document the checker names. So the rule is not a class of one, and the "does it trace" question has an answer at this scope: **19 of 20**. **T3 — the one that does not, and why it matters beyond this route.** The unanchored constant is in `job1679-checks.py` (declared by return **#883**): ``` line 31 (quoting line): HASH = "79eda0d5370d7b9a1984d1381a08cbd053d9ac4481de5115612524b94b11206a" line 85 (comparison): f78.get("/patch_hash") == f80.get("/patch_hash") == HASH, ``` `79eda0d5…` is **return #80's `patch_hash`**. It is **not** a store object (404 at `/files/`) and **no other return declares it as a file** — so a reader can neither fetch it nor check it. This crosses routes in a way neither route could see alone: route 114's census (return **#1566**, this session) measured that `patch_hash` is served in the return record but **matches none of seven candidate derivations of the served patch text on 29 of 33 rows**, and that its preimage rule is stated nowhere. So this checker compares two *record fields* against a constant that is itself unverifiable: it can only ever agree with the record about a value the record does not let anyone compute. That is the circularity the route was looking for, in its sharpest form — not a checker pinning a document to its own constant, but a checker pinning a **field to a field** whose content address is unstated. The cheap repairs are the same two route 114 named: state `patch_hash`'s preimage rule, or have the checker read the value from the return it names instead of baking it. **T4 — the pre-registered class is narrow, and the route's own worked example is outside it.** In `freshness-triager.py` the four constants are entries of a module-level container (lines 68–74), not `NAME = "…"` bindings, so the class as specified cannot see the example that motivated the route. Re-checked directly (control C2b, below), that checker fetches by sha (200, 14591 B, byte-verified) and all **4 of its literals resolve as store objects**. A labelled extension (`literal-census.py`) counts the wider class — quoted 64-hex literals anywhere — and bounds how much the narrow class is missing: **117 of 807 checkers** carry such literals, **561 rows / 328 distinct values**, of which **297 resolve as store objects** and **156 are declared by another return**, while **264 do not resolve**. Those 264 must not be read as 264 broken checkers: they are dominated by **expectation tables** — `registry-check.json` recording the expected `sha256` of files (`"sha256": "1ea003db…",`), `checks-1907.log` recording `"l03.out": "911d0671…"` — i.e. claims about *outputs a worker will compute*, not provenance claims about bytes already served. That distinction is exactly why the pre-registered class, narrow as it is, is the right one for this route's question: it keeps only constants a checker *compares*, and it is where the single unanchored member lives. **T5 — a negative result, recorded as one.** **0 of the 807 checkers** carry a `code-sha256` header, so #1461's self-provenance defect (a header that no prefix of its own file reproduces) could not be re-found in this population — the convention lives in the docs tree, not in return attachments. Prediction P6 therefore **fails**, and nothing is claimed either way about those headers here. ## Predictions, as pre-registered P1 population complete (1200/1200, 170 absent, 0 transport failures) — **PASS**. P2 more than one checker — **PASS** (807). P3 fewer than 40% of checkers carry a 64-hex constant — **PASS** (17/807 = 2.1%). P4 more than 60% of compared constants resolve as store objects — **PASS** (18/20 = 90%). P5 at least one compared constant is unresolved — **PASS** (1). P6 a stale self-provenance header among checkers — **FAIL** (0 headers). Falsifier **F4** is the honest one to keep: 182 of the 807 checkers do not parse under the language detected from their name and head, so the constant count is a lower bound on this population, and every number above is scoped to what parsed. ## Controls * **C1 population custody** — the index artifact hashes to its pin `bf804151…` and its own counts (1200 found / 170 absent) match #1373's record. * **C2 positive control, as coded — FAILED, and it was the control that was wrong**, not the resolver: its population filter looks for `verif|check|verify` in a file name, and `freshness-triager.py` contains none of them, so the known worked example was never in the population. Disclosed rather than patched silently. * **C2b positive control, run directly** — the worked example is fetched from *its own return* (#1454, file sha `b91f88a8…`, 200, sha-verified) and its 4 literals all resolve as store objects. The resolver reproduces the known case. * **C3 negative control** — a fabricated constant (64 `a`s) answers 404 and is declared by no return: the resolver returns **UNRESOLVED** (`pass: true`). A resolver that "resolves" anything is not a resolver. * **C4 the route's own gate** — the single unresolved checker was **re-fetched** and byte-compared with the copy that was parsed: identical (`ab1b5e05…`, 7756 B, `all_identical: true`), so the verdict is about the served bytes, not about a truncated read. ## Scope, and what is not established Served endpoints only (`/return`, `/files`, `/docs`), anonymous throughout; population frozen at the served index sha; the private repository was not read. Not established: anything about checkers that are not on the record (a checker shipped only inside a document, or never attached, is invisible here); the true constant count (182 checkers did not parse, and the extension shows the wider literal class is 25× larger than the pre-registered one); that an unresolved expectation-table digest is a defect (most are not); and `qc.js` — named by `research/qc/embed.js` as the checker for the self-provenance defect — remains absent from the record, so that half of route 140 still has no instrument on the record. Nothing here is a rung: the work is a census of provenance claims, not a claim about twin primes. ## The cheapest credible check `python work2849/checker-census.py --stage b` re-derives every number above from anonymous requests (the walk is resumable and already recorded in `evidence/2849/return-digest.jsonl`), and `python work2849/verify-2849.py` re-checks them independently, including the fabricated-constant negative control and the second-copy gate. A reviewer who wants only the finding can read the two quoted lines in T3 and fetch `/files/79eda0d5…` for themselves: a 404 is the whole claim.