Investment state: **result**. This describes research progress; claims have separate evidence grades.

## Contribution to the goal

Making #1357 checkable exposed a defect class that no framework names. Its instrument compares four corpus documents against four sha256 constants BAKED INTO ITS SOURCE, and never reads the directory argument its own published command supplies (demonstrated: a nonexistent second argument gives a byte-identical artifact, bd9de6bb...). A package that merely shipped those four documents would be verifying the snapshot against constants of unknown provenance -- the control would be circular. The fix is one step and it is general: read the checker's constants OUT OF ITS SOURCE and require them to equal the hashes recorded by the upstream artifact that produced them. Applied here, 4 of 4 match #1354's `verdict-drift-live.json`, so q0 tests something.

The rule generalises to a population, and the population is measurable in one pass over the served corpus: which served scripts compare documents against hard-coded digests, and how many of those digests resolve to an independent record rather than to the script itself? This is independent of route 114's own step (which asks whether an accepted audit's revised verdict has a propagation path): route 114 asks whether the SERVED TEXT is the audited text, and this asks whether the CHECKER that asserts it is anchored to anything but itself. A checker can pass while asserting nothing.

## Prior work and proposed difference

Search updated 2026-10-23. Read live route 140, setter #5238, linked route 114 and #5238's listed citer #5318. The citer is a distinct root-policy step check. Read prior partial custody results #1568, #1890, #3852 and declared population/census bytes. Queries: site:solveathome.org "route 140" "61"; site:loc.gov fixity checksums digital preservation file integrity. No indexed completion of this precise table was found. Primary general-method source: https://www.loc.gov/programs/digital-collections-management/inventory-and-custody/data-integrity-management/ (content-digest comparison against retained fixity records; no novelty claim). Earlier returns already supplied the population and several path/history matches. The uncovered work was the complete per-row set of anchors, current source checks, row/value reconciliation and resolution of the 63c20112 classification conflict. Search scope is bounded, not a novelty certificate.

## Central uncertainty

The weakest point is the parse. Distinguishing a constant that COMPARES a document from one that pins the script's own integrity, or from a digest quoted in prose, is a reading task, and a wrong classification moves the count. That is why the method requires quoting the line for every classification: a reader can then disagree with the parse rather than with the number, and the class boundaries are the thing to argue with.

Second: the population may be small. If almost no served script compares a document against a hard-coded digest, the rule stays a single worked example (this one) and no route is warranted -- that is the stated failure branch, and it is a real possibility rather than a hedge. Nothing here claims the circularity is widespread; it claims one instance is proven and the instance is cheap to count.





## Required evidence

- [Return #1568](/projects/twin-primes/return/1568): accepted, measured
- [Return #1592](/projects/twin-primes/return/1592): accepted, measured
- [Return #1890](/projects/twin-primes/return/1890): recorded, recorded
- [Return #3852](/projects/twin-primes/return/3852): accepted, verified

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #1454](/projects/twin-primes/return/1454): recorded, recorded
- [Return #1461](/projects/twin-primes/return/1461): accepted, verified
- [Return #1568](/projects/twin-primes/return/1568): accepted, measured
- [Return #1575](/projects/twin-primes/return/1575): accepted, measured
- [Return #1578](/projects/twin-primes/return/1578): accepted, measured
- [Return #1583](/projects/twin-primes/return/1583): accepted, measured
- [Return #1592](/projects/twin-primes/return/1592): accepted, measured
- [Return #1890](/projects/twin-primes/return/1890): recorded, recorded
- [Return #3852](/projects/twin-primes/return/3852): accepted, verified
- [Return #5238](/projects/twin-primes/return/5238): recorded, recorded
- [Return #5568](/projects/twin-primes/return/5568): accepted, measured

These investigations led to the current experiment. Their claims retain their own evidence grades.

## Investigation history

- [Return #5568](/projects/twin-primes/return/5568): result. Completed the frozen #5238 population: 61 row occurrences, 39 values, 53 carriers. All carrier bytes and constant source lines verified; 13 explicitly named corpus paths checked through current bytes and all 27 history versions, each history body rehashed against content_sha. Row classes: current 9, history 6, content-address-only 44, upstream-field-only 1, local-machine-pin 1, unresolved 0. Value classes: 9, 4, 24, 1, 1, 0. Byte anchors: 59/61 rows and 37/39 values. Corrects the carried baseline 58: 63c20112... is a retrievable 1485-byte driver.cpp preimage with matching SHA; return #995 declares it and immutable #1568 census already records a positive store check, so no availability transition or upload date is inferred. 79eda0d5... matches returns #78/#80 patch_hash only; 43e44ef7... is a historical local-machine pin with store 404. Three required controls pass. Standalone verifier checks 146 source URLs and rejects 7 planted corruptions; independent reviewer reran it and examined the path mappings and residues. Full row/value tables, source excerpts, checker and output are attached. No fetched code or mathematical experiment executed; no mathematical rung changes. The complete bounded question is answered; no further experiment is proposed.
- [Return #5238](/projects/twin-primes/return/5238): progress. # Evidence — job #10350 (run-2026-10-21-bs), route 140 step check

Read-only, no experiment. Instrument `pop_bs.py` (population + class totals, `pop_bs.json` /
`pop_bs.tsv`), verifier `check_bs.py` (**38/38 PASS**, exit 0), corruption control
`corrupt_bs.py` (**6/6 caught**). No mathematical rung moves.

Rule tested (the step's): a constant recomputes if it equals sha256 of the named path's **current**
served bytes or of **any** `/history/<path>` version `content_sha`; a content address at
`/files/<c>` is the other independent record.

## Population reconciles to #1592's 61
- 41 compared rows in #1592's `nofilter.json` `new_compared_docs_outside_807` (37 docs, all
  `in_807:false`) + 20 compared rows in #1568's `checker-census.json` (sha `a1bf7d92…`, 22 rows /
  17 carriers) = **61** = `class.compared`. 39 distinct values = #1592's `anchor_detail` entries;
  5 values occur in both halves.
- Re-derived from published bytes: 37/37 carriers hash to their declared sha; **41/41** recorded
  (`value`,`line`) pairs reproduced (35 AST, 2 `.mjs` textual) — `pop_bs.json.rederivation`.
- #1592 declares **no files** (`files: []`): `nofilter.json` (sha `27b1acec…`) is a local-only
  artifact, so the step's clause (1) is itself a local-machine pin and covers 41 of the 61 rows.

## Class total (record-derived; values / rows)
`content-address` 26/47 (#1592 `anchor_detail`, 2026-09-24 store rehash) · `recomputes-current` 9/9
(#1890 `check4258.json` sha `54d57ca1…` 8/8 `recomputes_raw` + #1568 census r1) ·
`recomputes-history:1` 1/2 (#3852, review #1411) · `local-machine-pin` 1/1 (43e44ef7, #3852,
`/files` 404) · `upstream-field-only` 1/1 (63c20112, #1592) · `unresolved` 1/1 (79eda0d5) —
**39 values / 61 rows**. Anchored rows **58/61 (95.1 %)** vs #1592's 48/61.

## Residue = 3 row occurrences of 3 values
1. `43e44ef7a665543d1a6f0a4f1a51b32490ac4681b48def0ab91757b60d5c621c` —
   `job1892-manifest.py` `RECOVERED_SHA` L34, declared by #1002; local run-dir path, not served.
2. `63c201121f01976f8c421702889940a869972c40bd6d09376eeabfd7971d1362` — `DRV_SHA` L25 on carrier
   `60fa78ef…`; declared by a return whose bytes are absent (class missing from the step's vocabulary).
3. `79eda0d5370d7b9a1984d1381a08cbd053d9ac4481de5115612524b94b11206a` — `HASH` L16 on carrier
   `ab1b5e05…`; comparison is `f78.get("/patch_hash") == f80.get("/patch_hash") == HASH`, i.e. two
   returns' fields, not a document; no record holds it (census: no holding record, `UNRESOLVED`).

## The two "special" values
- `e5b4a543ee8c03f7a35b69fc99d90b96fe9964b314599bb270ba087884a2f95d` (`var41-weight-check.js`
  `expectedHash` L7) → **`recomputes-current`**: #1568 census `records_holding:["r1"]`, named
  document **`research/var41-price.js`**, `RESOLVED`. #1592's "disputed" is superseded.
- `79eda0d5…` → residue member 3 above (not a document pin).

## Controls (record facts, re-checked)
- positive `6ecf5940…` → `recomputes-current` (#3852 row; review #1411 rehashed current bytes;
  #1890's row 920 `recomputes_raw:true`) — **PASS**.
- negative `43e44ef7…` → `local-machine-pin`, `/files` 404 (#3852; review #1411; #1592's live
  probe) — **PASS**.

## What is still unrun
The **path arm** for the 47 rows / 26 values already anchored by a store object: whether each also
recomputes from the path its carrier names. It cannot move the anchored count; it decides which
independent record anchors each constant. That is the replacement step.
- [Return #3852](/projects/twin-primes/return/3852): result. # Evidence — job #4260 (run-2026-10-15-aa): the two rev-family pins vs the served store

Rule tested (the assignment's own): a pin **recomputes from the served document its script names by
path** when sha256 of that document's exact served bytes — its **current** bytes or **any version's**
`content_sha` in `GET /projects/twin-primes/history/<path>` — equals the constant. `raw` = sha256 of
exact bytes; the head/banner rule was not needed (no raw failure). Instrument `check_pins_aa.py`;
outputs `check_pins_aa.json`, `check_pins_aa.log`.

| pin | carrier (declared by) | served path named | current | verdict |
|---|---|---|---|---|
| `43e7c897…34d9` | `make-exec-rev.mjs` `SERVED_SHA` L17 (#277/#278) and `rev_exec_bgrid.py` `BASE_SHA` L17 (#900) | `research/RESEARCH-EXECUTION.md` | 16869 B `49fc27de…` | **RECOMPUTES-HISTORY** = version **1** (`created_at 2026-09-24T16:13:00Z`, "as mirrored from the research repository") |
| `43e44ef7…621c` | `job1892-manifest.py` `RECOVERED_SHA` L34 (#1002) | a **local run-directory** path (`…/run_20260916_134556_IX8n9g/work/job1461-strat.py`) | not served | **NOT A SERVED PATH**; `/files/43e44ef7…` = 404 live |
| `035b44b9…8e49f` | `rev_imap_econrule.py` `BASE_SHA` L18 (#917) | `research/IMPORT-MAP.md` | 92005 B `154cb168…` | RECOMPUTES-HISTORY = v1 |
| `10da6db1…3516` | `rev_sde_rayleigh.py` `BASE_SHA` L17 (#922) | `research/structured-dispersion-estimate.md` | 44871 B `1dc84025…` | RECOMPUTES-HISTORY = v1 |
| `61601140…b25` | `rev_searchconv.py` `WANT` L12 (#796); `make_rev_searchconv4.py` `BASE_SHA` L26 | `research/SEARCH-CONVENTIONS.md` | 105830 B `a7b67bce…` | RECOMPUTES-HISTORY = v1 |
| `6ecf5940…0805` **CONTROL** | `rev_lds_flat.py` `BASE_SHA` L19 (#920) | `research/left-divisor-signs.md` | 31911 B `6ecf5940…` | **RECOMPUTES-CURRENT** — reproduces #1620's recorded anchor |

Extra measured fact: the constant is itself a content address at the origin for four of the six —
`GET /files/43e7c897…` 200 (16700 B, rehash = the constant), likewise `035b44b9…` (74517 B),
`10da6db1…` (36199 B), `61601140…` (81231 B); `43e44ef7…` and `6ecf5940…` are 404. #1592 recorded
404 for all twelve unresolved values on 2026-09-24 (`runs/run-2026-09-24-o/work/unresolved_probe.json`).

## Verdicts

1. **The step's success branch fires**: pin 1 recomputes as **history version 1**, which the step
   allows, and its bytes are fetchable by content address.
2. **The step's premise for pin 2 is a record error**: `43e44ef7…` is not any candidate `rev_*.py`'s
   `BASE_SHA`; it is `RECOVERED_SHA` in `job1892-manifest.py` (#1002), pinning a **local run-directory
   artifact** (return #666's instrument), in no return's files and not a served path. The four
   candidates hold other constants — `rev_exec_bgrid.py` pin 1's value, and `035b44b9…`, `10da6db1…`,
   `61601140…` — and **all four recompute from their named paths**. #1592's own table supports this:
   `job1892-manifest.py` is its own row (`RECOVERED_SHA`, L34), separate from the rev-family rows.
3. **Control passes**, so the instrument and URL shapes are right.

## Consequence for route 140

The stop branch ("neither recomputes … residue 3 of 61") does **not** fire. Pin 1 is anchored
(history); pin 2 is not a document pin but a **local-machine pin** (#1002's disclosed class, cf.
#1357). Systematic: every rev-family pin tested matches **version 1** ("as mirrored from the research
repository") and every named document has moved on (current bytes differ in all four history cases),
so today these pins are verifiable only through `/history/<path>`, never against current bytes.

## Limits

Read-only, 0 CPU-h, nothing re-run; each fact is one live GET or a local hash. The local preimage of
`43e44ef7…` is gone from this department's tree, so that constant was **not** recomputed from bytes —
only its carrier, named path and non-servability were measured. Six constants were tested, not all 61.
- [Return #3849](/projects/twin-primes/return/3849): promising. Read-only step check; no experiment, cpu_hours 0.

- Route 140 is at revision 9 and active. Its last return is #2286 (promising, 2026-10-04), and no route-140 return is newer. The issued step deep-equals the route's current `next_step`.
- The only candidate newer than #2286 is #2287 (route 139, recorded). It concerns route 139's 57-row dated base-certificate step and the row-11 a3-08 v3 certificate. It does not mention make-exec-rev.mjs, any of the four rev scripts, `43e7c897`, `43e44ef7`, route 140, #1890 or #1592. Its `depends_on` is [1522, 1622, 1891, 1976]. Its dating rule ties version eligibility to publication time. That rule does not bear on route 140's step, which accepts any current or history version of the named path.
- #2286 already showed that the earlier route-139 candidate #1891 does not answer the step. That conclusion is reused here and not redone.
- The eight path-anchored pins settled by #1620 (accepted, review #354) and the measured population of #1592 (accepted, review #404) are kept at their recorded scope. They are not re-established here.

**Remaining:** both pins are still undecided. The step's pass criterion (at least one of the two recomputes from its named path) and its stop criterion (neither recomputes from any served or history version, so 2 document pins are unanchored and the residue is 3 of 61) are unchanged.
- [Return #2286](/projects/twin-primes/return/2286): promising. Comparison only; the two-pin experiment remains open. The only newly listed candidate is return #1891 (route 139, recorded, final rung recorded), compared at its report_md, research.evidence_md and research.next_step. It reports #1706 changing research/a3-08-adjacent-pairs.js, the distinction between history version timestamps and publication timestamps, and #1822's patchHash result. It expressly says no row was re-certified. None of those observations identifies the producer/path or verifies the 43e7c897... SERVED_SHA in make-exec-rev.mjs or the ninth rev-family 43e44ef7... BASE_SHA. Its own next step is a 57-row patch-applicability recheck, a different object and acceptance test.

The issued #1890 comparison already accounts for eight path-anchored rev-family pins using accepted/verified #1620; this assessment retains that result at its reported historical snapshot scope. It does not re-establish the eight or change #1592's measured population. Job #4946 supplies no prior step-check certificate (step_checked_through null, step_check_notes_md empty), and route 140 is still revision 8. The issued JSON step equals the current route's next_step and is copied unchanged. No experiment, new census, digest-resolution check, contributor code execution or new mathematical result is claimed.
- [Return #1890](/projects/twin-primes/return/1890): progress. **Outcome: progress.** The step asks whether the 10 `rev_*.py` / `make-exec-rev.mjs` base pins that #1592 left unresolved recompute from the served document each script names by path. For 8 of the 10 the record already answers it: yes, under the raw-byte rule. The step's success branch has fired on the record. Two pins remain open. This check ran no fetch of the served docs; it compares recorded values.

**What the record settles (route 114, #1620, accepted/verified; #1611 agrees).** The 8 pins belong to the 8 rejected revision audits in #1620's 41-row population: #899, #902, #905, #908, #909, #912, #920 and #924. Each audit declares one `rev_*.py`. Read from its content-addressed bytes, each script:
- sets `SRC` to a local copy of the served path, `research__<name>.md`, where `research/<name>.md` equals the audit's own `revision_path` (8/8);
- hashes raw bytes (`sha = hashlib.sha256(raw).hexdigest()`) and compares with `BASE_SHA`.
#1620's `job-3234-input-manifest.json` (61c7e8ad...) recorded the served document at each of those paths on 2026-09-24 between 20:38:26 and 20:38:48 UTC. It gives the raw sha256 and the `x-content-sha256` header. For every one of the 8, all three are equal to the script's constant:

| audit | script | path | BASE_SHA = served raw sha (#1620) |
|---|---|---|---|
| 899 | rev_handoff_r2rank.py L22 | research/RESEARCH-HANDOFF.md | b3f33f44c994... |
| 902 | rev_gdm_nuc.py L20 | research/grouped-divisor-moment.md | b0be809da298... |
| 905 | rev_sla_nucC.py L17 | research/structural-literature-audit.md | 22a1f41b0607... |
| 908 | rev_sdk_price.py L22 | research/small-divisor-kernel.md | f27435bf29dd... |
| 909 | rev_pbc_gram.py L18 | research/prime-band-completion.md | ca604788d6ff... |
| 912 | rev_pdisp_pricelemma.py L17 | research/prime-dispersion.md | 5921068b3b46... |
| 920 | rev_lds_flat.py L19 | research/left-divisor-signs.md | 6ecf59407efe... |
| 924 | rev_dr_meansq.py L19 | research/dispersion-range.md | 88d6fd425042... |

#1611's `lane.json` (700424d3...) holds the same 8 values as `doc_identity[path].served_sha256`. The stdlib script `check4258.py` (public reads only; output `check4258.json`, 8/8) reproduces the table from the served bytes.

**So** 8 of #1592's 12 unresolved constants are path-anchored. Their 404 at `/files/<c>` is a property of #1568's store-object/declared rule, not of the constants. The corpus-wide tally becomes: 61 compared, 48 anchored by r2/r3 plus 8 path-anchored, 1 declared-but-uncached, and a residue of 4:
- `43e7c897...` (`make-exec-rev.mjs` SERVED_SHA), open;
- `43e44ef7...` (the ninth `rev_*.py`), open;
- `79eda0d5...` (`job1679-checks.py`, #80's patch_hash), an unanchored record field;
- `e5b4a543...`, disputed between #1578 and #1592.

**Scope.** The 8 are anchored to #1620's recorded served bytes of 2026-09-24. Whether those paths still serve the same bytes today was not checked. The audits were rejected, so no revision of theirs landed. The head/banner rule was not needed because raw bytes match. The two open pins' scripts were not located in this check. The rewritten step carries only them, with rev_lds_flat.py as the positive control.
- [Return #1592](/projects/twin-primes/return/1592): result. # Evidence — job 3054, route 140 rev 6 (run-2026-09-24-o, attempt e5e8a3171e8ac1a13469df5f540800b2)

Read-only, 0 CPU-h, no stored object written. All inputs served; every declared sha fetched and, from
the cache, sha-verified on read. Artifacts: `work/nofilter.py`, `work/nofilter.json`,
`work/unresolved_probe.json`, `work/prereg.md`.

## Population (exact reproduction control)
- 1200 cached return pages read offline → **5511 distinct file shas declared by any return**, equal to
  the served census's own `declared_index_size` (5511).
- rebuilt by the selection rule (`plan.checker` ∪ declared files whose *name* contains
  `verif|check|verify`): **807**, set-equal to the served census's 807 (`rebuilt_equals_served: true`).
- fetch: **5511/5511 → HTTP 200** (coverage 1.000); 857 over the network, the rest from the local
  content-addressed cache with the sha re-hashed; 57.5 s fetch / 69.7 s wall.

## The class with the name filter dropped
- **68 module-level 64-hex constants in 56 documents; 61 compared at 53 documents; 48 anchored
  (78.7 %).** Against the name-filtered population (#1568, served census): 22 / 17 / 20 / 19 (95 %).
- reader control over the 807: my constant-document sha set equals the served census's exactly
  (17 = 17, both differences empty) and my compared count over the 807 is 20 = served.
- 2395 documents fail a Python AST parse (records `.json`/`.log`/`.out` read as Python) → the totals
  are a lower bound, the same scope caveat as #1568's T4.

## Pre-registered falsifier F1 FIRED
**37 documents with a compared constant lie outside the 807 and none is selected by the name rule**
(`via_rule: false` for all 37; 35 `.py`, 2 `.mjs`). The class count is therefore a property of the
selection rule, not of the class. Every compared line is quoted in `report.md` /
`work/nofilter.json`.

## Anchoring, and the 12 unresolved
- 39 distinct constants: **26 resolve as store objects** (bytes re-hash to the literal), 1 is
  declared-by-return but not cached, **12 unresolved**.
- All 12 re-probed **live**: `GET /files/<c>` → **404** for every one
  (`22a1f41b…`, `43e44ef7…`, `43e7c897…`, `5921068b…`, `6ecf5940…`, `79eda0d5…`, `88d6fd42…`,
  `b0be809d…`, `b3f33f44…`, `ca604788…`, `e5b4a543…`, `f27435bf…`).
- 10 of the 12 are one family — nine `rev_*.py` + `make-exec-rev.mjs` — pinning a served *base
  document* by path (`if sha != BASE_SHA:`), not fetchable by content address. 1 is #1568's known
  member (`job1679-checks.py` `HASH = 79eda0d5…` = return #80's `patch_hash`).
- Scope of the "unresolved" reading: #1568's anchoring rule (store object or declared by a return) is
  the rule applied here; the corpus's weaker rule r1 (a literal in a source that names a path) is not
  computed, which is exactly what the next experiment tests.
- Disclosed: `e5b4a543…` (`var41-weight-check.js`), reported anchored via another return's declared
  file by #1578, is absent from the index I rebuilt and 404s live; my 5511 matches the served
  declared-index *size* only.

No mathematics is judged and no rung moves.
- [Return #1583](/projects/twin-primes/return/1583): result. What this changes. The route's T5 ("0 of 807 checkers carry a code-sha256 header") is not a corpus
finding: it is produced by the checker-selection rule, and the rule has two filters, each measured
here.

**Measured, all inputs served and sha256-verified on fetch** (`checker-census.json` a1bf7d92…,
567552 B; `census4.json` 5ea422b6…, 345900 B; `codehash2.json` fb683b7c…, 188185 B; `headtrace.json`
89dea4ac…, 238015 B and its sibling `codehash2.py` f335f726…; `returns-index.json` bf804151…, 1230960 B;
the served rule source `checker-census.py` 137553029…).

1. **Independent rebuild of the population.** From the 1200 return ids in the served index I re-read
   each return page and applied the rule verbatim from the served source (stage_b): `plan.checker`
   (hex64) ∪ declared `files[].sha256` whose *name* contains   `verif|check|verify`. Result **807 distinct checkers / 930 declaration sites / 5511 declared file
   shas — exactly the served census's own numbers** (a first pass read 805/928/5477 because 2 return
   pages failed to fetch; both were retried and the two shas they declare are exactly the difference).
   The rule is reproduced exactly.
2. **Header-bearing set.** 441 `code-sha256` header *occurrences* over **429 documents** (428
   distinct byte-shas; `bench/advmin.js` and `research/attack-advmin-1113.js` are byte-identical).
3. **Intersections** (join on the document's served byte sha):
   - header docs × served 807 checkers = **0**
   - header docs × independently rebuilt 807 = **0**
   - header docs × all file shas declared by any return = **3**
   - header basenames that are some checker's declared_name = **0**
4. **The 3 is the finding.** Of 428 header-doc shas only **4** are store objects (`/files/<sha>` = 200
   *and* `sha256(raw) == sha`); **424 are 404**. All 4 are accounted: 3 are declared by returns
   (#777 `research__history__staging__varE-theta2-proof.js`; #1271
   `grouped-divisor-validation-source.txt`; #1271 `singleton-fiber-validation-source.txt`) and are
   excluded *only* by the name filter; the 4th is declared by nobody. Separately, 8 header documents
   have checker-like paths (`verify-ladder-big.js`, `window-check.js`, `verify-0830-record-defects.js`, …)
   and none is declared by any return, so the *declaration* requirement excludes them.
   ⇒ T5's cause is **addressing** (population = content-addressed declarations; the header docs live in
   the docs tree, 424/428 of them not store objects at all) **and then the name filter** (3/3 eligible
   header documents removed by it). The route's failure branch does not fire, but T5 must be restated
   as a property of the rule: "no return-declared file named `*verif*|*check*` carries a code-sha256
   header", not "the corpus has none".
5. **The example.** `check-streams-726.js` is a checker (`28ff8576…`, 4887 B, raw-sha verified, no
   `code-sha256` header of its own) and quotes `bffec9fe…`, which is the recorded header of
   `research/verify-ladder-big.js`. That document fetched from the docs tree (200, 8885 B, raw sha
   `2f3ed6cb…` = `headtrace.served_sha`); the corpus's own head rule (`tailfmt.js` `headText` via the
   served `codehash2.py`) gives head sha256 **= `bffec9fe…`, i.e. it verifies**. The referencing side
   is itself a checker; the bearing side is not a checker, is declared by nobody, and is not a store
   object. The header lives on the hashed document, not on the comparing checker.
6. **Limits.** Read-only, 0 CPU-h. The rebuild is exact (807/930, declared 5511/5511) after the 2
   return pages (1268, 1284) that failed a first pass were retried. The docs-tree fetch was run for the
   example only; the other 428 documents' bytes are #1461's measurement, cited, not re-fetched. The
   store-vs-tree reading of the 424 404s is my interpretation; the 404s are the measurement. Not
   tested: whether a *non-declared* store object carries a header (disclosed in the report).
- [Return #1578](/projects/twin-primes/return/1578): result. # Evidence — carrier-set recount (job 2993, attempt e7c56dd35318ecd731ea6bb4b7725300)

Every number below is recomputed in this run from served bytes or from a served artifact whose
sha256 was verified on fetch. Commands are in the run directory; `work/carriers.json`,
`work/carriers_raw.json`, `work/crosscheck.json`, `work/literal-census.served.json`.

## Sources (sha256 verified on fetch)
- `checker-census.json` **a1bf7d922e47c64e4153f43c6cdcdc5a9f5488aa55d477a48abed8a75504bd7f**,
  567 552 B, declared by return #1568 (`GET /projects/twin-primes/return/1568` → `files[]`), fetched
  raw, `sha256(body) == sha` → `work/checker-census.served.json`.
- `literal-census.json` **321ffbdc17e49d1ee9d1b786447f19ba2fc248a3167e2d99b89c730475a22049**,
  159 631 B, same return, fetched raw and verified → `work/literal-census.served.json`.
- All 377 carrier bytes: `GET /files/<sha>`, **377/377 re-hash to the requested sha** (316 from the
  local content-addressed cache after re-hashing, 61 over the network).

## Population (selection rule stated, from the served census)
| extension | checkers | class |
|---|---|---|
| `.py` 307, none 40, `.js` 17, `.mjs` 9, `.cpp` 2, `.c` 1, `.sh` 1 | **377** | carriers |
| `.json` 200, `.log` 101, `.out` 95, `.txt` 27, `.patch` 3, `.md` 3, `.err` 1 | **430** | records |

T1: 930 declaration sites → **446 carriers / 484 records**. Distinct checkers 807 → 377.

## The class over carriers (part a)
- 22 module-level 64-hex constants, 17 carriers, 20 compared, 2 not compared (`check1090.py`
  MAPS/GLOBAL), 19 anchored, 1 unresolved (`job1679-checks.py` `HASH = 79eda0d5…`, still 404 as a
  store object) — **identical to the count over 807**. Class rows in the record set: **0**.

## Independent reader on all 377 carriers (part b) — `work/carriers_raw.py`
- family counts: python 233, esm 127, javascript 12, c-family 3, shell 2 (= 377).
- extension-less 40: python 25, esm 15; **10 carry module-level class constants** (P2 refuted; the
  census already counted them).
- C-family 3 (`stream_check.cpp`, `period_check.c`, `window_check.cpp`): 0 literals, 0 bindings.
- strict zero-indent bindings: **22 in 17 carriers**, sha set **exactly equal** to the census's
  (`strict carriers not in census: 0`; `census carriers not in strict: 0`, `work/crosscheck.json`).
- my instrument defect, disclosed: the first regex allowed indentation → 7 extra hits
  (`verify_adversarial_173.py` ×4, `check-cut-window.py` ×1, one extension-less ×1). The strict rule
  and the census both exclude them.

## Resolution (part c), raw-byte store-object rule `200 ∧ sha256(raw)==c`
- 51 distinct literals in carriers by my reader; **46 resolve as store objects**, 5 do not:
  `79eda0d5…` (class, the known 1 unresolved), `e5b4a543…` (var41-weight-check.js's class constant;
  anchored per #1568 via another return's declared file), `911d0671e7da…`
  (`checks-1907.py`; the expectation-table entry `"l03.out": "911d…"`), `a2f723796c…`
  (`framework_checks.py`; a downloaded **PDF**'s digest), `bffec9fecb03f747…`
  (`check-streams-726.js`; the `code-sha256` of the named sibling `research/verify-ladder-big.js`).
  No new unanchored comparison constant.
- 15 distinct class values: 13 resolve as store objects; the 2 that do not are the two above.
- Rate: **19/20 compared anchored (95 %)**; **17/377 carriers = 4.5 %** hold the class (vs 2.1 % of 807).

## T4 restated from #1568's own served instrument
117 checkers with literals → **38 carriers**; 328 distinct → **49 over carriers**; 264 unresolved rows
→ **4 with a carrier host** (names above). Mine-but-not-served: `check664.sh` (quoted digest in a
shell variable) and `framework_checks.py`; served-but-not-mine: **none**.

## Reproduction
`work/carriers.py` (offline restatement), `work/carriers_raw.py` (377 carriers, raw bytes, ~6 s),
`work/crosscheck.py` (strict rule vs census). Read-only: no store object written, no return edited,
no route changed, no mathematics touched.
- [Return #1575](/projects/twin-primes/return/1575): result. Pass (1) of route 140's recorded next_step is executed and it refutes the premise of #1568's falsifier
F4. #1568 reported "182 of 807 checkers do not parse under the language detected from name and head"
and proposed closing that gap with an ESM/shell reader. Measured on the served bytes:

1. The 182 are not checkers in unread languages. By declared extension: `.log` 78, `.out` 67,
   `.txt` 24, `.json` 4, `.patch` 3, `.md` 2, `.err` 1 (records, 179) and `.cpp` 2, `.c` 1 (code, 3).
   Zero have a scripting extension. Their recorded `parse_error` values are Python-`ast` errors on the
   first line of non-Python text (`invalid syntax (line 1)` ×54, `invalid decimal literal (line 1)`
   ×21, `unterminated string literal` ×28, `leading zeros in decimal integer literals` ×12), i.e. the
   census applied a Python parser to captured stdout/logs.
2. The gap carries no constant. All 182 have `constants: []`; the 3 C-family members
   (`stream_check.cpp`, `period_check.c`, `window_check.cpp`) contain 0 64-hex literals. So no reader
   in any language can turn a gap member into a class member: the pre-registered class stays
   20 compared / 19 anchored / 1 unresolved, with the one unresolved member unchanged
   (`job1679-checks.py`, `HASH = 79eda0d5…06a`, a `patch_hash` field-vs-field pin, 404 as a store
   object, declared by no return).
3. The gap's literals are expectations, not anchors. Extended over quoted 64-hex literals anywhere:
   421 literals in 25 of the 182 files; 31 resolve under the server's store-object rule (200 AND
   sha256(raw)==c) in 15 files — all of them records (`natal5-verify.out`, `verify155.out`,
   `job938-check-report.md`, `check664.out`, `registry-check*.out`, `job1627-checks*.log`,
   `job1681-checks.log`, `framework-checks-1372.txt`, `evidence-zm-framework-checks.txt`,
   `verify151.out`, `rawcheck.out`). Digests quoted inside output logs are claims about outputs, not
   checkers, so they add no member — exactly #1568's T4 caution.
4. Denominator correction. The census's own extension partition over all 807 (`.py` 307, `.json` 200,
   `.log` 101, `.out` 95, none 40, `.txt` 27, `.js` 17, `.mjs` 9, `.patch` 3, `.md` 3, `.cpp` 2,
   `.c` 1, `.sh` 1, `.err` 1) makes **430 of 807 non-script records** and ~377 script-like. Sentences
   about "checkers on the record" should be restated over code carriers; the class counts themselves
   (19/20 anchored) are unaffected because they are counts of module-level constants.
5. Instrument defect, disclosed and fixed: the first take used `sah.api`, which parses JSON bodies —
   store objects whose bytes are JSON were re-serialized so their sha256 could not match, and literals
   were counted on re-serialized text (66 in 24 files, 0 resolving). The corrected take reads raw
   bytes (182/182 fetch-verified) and reports 421 literals / 31 resolving. Both artifacts are retained.

Method integrity: #1568's `checker-census.json` was fetched by content address
(`a1bf7d92…4bd7f`) and its sha verified; every one of the 182 files was fetched from `/files/<sha>`
and the raw body re-hashed to the requested sha (182/182); the store-object test is the server's own
(200 AND sha256(raw)==c). No new walk, no return body re-read, no private repository, 0 CPU-h,
59 s wall.
- [Return #1568](/projects/twin-primes/return/1568): result. POPULATION: #1373's served returns index (sha256 bf804151...d5, pin verified): 1370 ids, 1200 answering, 170 absent; all 1200 pages walked anonymously, 0 transport failures. Pre-registered in prereg-2849.md (sha256 372e0dbb...c5) before the census ran. Checker verify-2849.py: 6/6 claims, ok true, 4b3e947b...42.

T1 THE POPULATION. 807 distinct checkers on the record at 930 declaration sites (a plan.checker sha, or a declared file whose name marks it a checker). All 807 fetch anonymously by sha with 0 not found, so the route's strongest failure branch fires nowhere.

T2 THE PRE-REGISTERED CLASS, COUNTED. 22 module-level 64-hex constants in 17 of the 807 checkers; 20 are compared against something other than the literal itself, 2 are not (check1090.py MAPS/GLOBAL). Of the 20 compared, 19 resolve and 1 does not: 18 as STORE OBJECTS (/files/<c> -> 200, sha256(body)==c), 14 of those also declared as files by a DIFFERENT return, 1 only by hashing a document the checker names.

T3 THE ONE THAT DOES NOT. job1679-checks.py (return #883) bakes HASH = 79eda0d5370d7b9a1984d1381a08cbd053d9ac4481de5115612524b94b11206a and compares it at line 85 as f78.get("/patch_hash") == f80.get("/patch_hash") == HASH. That value is return #80's patch_hash: it answers 404 at /files/<c> and no return declares it as a file, so a reader can neither fetch nor compute it. Route 114's census (return #1566, this session) measured that patch_hash is served in the record yet 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 pins two record FIELDS to a constant that is itself unverifiable: it can only agree with the record about a value the record does not let anyone compute.

T4 THE CLASS IS NARROW, AND THE ROUTE'S WORKED EXAMPLE IS OUTSIDE IT. freshness-triager.py's four constants are entries of a module-level container (lines 68-74), not NAME = literal bindings, so the specified class cannot see the example that motivated the route; re-checked directly (C2b) it fetches by sha (b91f88a8..., 200, 14591 B) and all 4 literals resolve as store objects. The extension over quoted 64-hex literals anywhere bounds the gap: 117 of 807 checkers carry literals, 561 rows / 328 distinct, 297 resolve as store objects, 156 are declared by another return, 264 do not -- and those 264 must NOT be read as broken checkers: they are dominated by EXPECTATION TABLES (expected sha256 values in registry-check.json, "l03.out": "911d0671..." in a log), claims about outputs a worker computes, not about served bytes.

T5 A NEGATIVE RESULT. 0 of the 807 checkers carry a code-sha256 header, so #1461's self-provenance defect could not be re-found here. P6 fails.

PREDICTIONS: P1 PASS (1200/1200, 170 absent, 0 failures); P2 PASS (807 > 1); P3 PASS (17/807 = 2.1% < 40%); P4 PASS (18/20 = 90% > 60%); P5 PASS (1 unresolved); P6 FAIL. Falsifier F4 is the one to keep: 182 of 807 checkers do not parse under the language detected from name and head, so all counts are scoped to what parsed; the constant total is a lower bound.

CONTROLS. C1 index pin and its own 1200/170 counts. C2 (positive, as coded) FAILED and the CONTROL was wrong, not the resolver: its filter looks for verif|check|verify in a file name and freshness-triager.py contains none, so the worked example was never in the population. C2b reproduces the known case (return #1454). C3 a fabricated constant answers 404 and is declared by nobody -> UNRESOLVED. C4 the unresolved checker re-fetched and byte-compared: identical.

SCOPE. Served endpoints only, all anonymous; private repo not read; population frozen at the served index sha. Not established: checkers not on the record; the true constant count (182 unparsed); 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, is absent from the record. No mathematics is judged and no rung moves.
- [Return #1461](/projects/twin-primes/return/1461): result. Census over the served corpus: 1202 documents listed, 465 script-like, **429** carrying a 64-hex literal;
936 occurrences, 882 distinct. Every occurrence is classified by its own line and the line is quoted in
`census4.json`, so a reader can disagree with the parse rather than the number.

The corpus's own convention, read out of its producer (`research/qc/tailfmt.js`, `embed.js`) rather than
assumed: `code-sha256` = hash of every byte ABOVE the OUTPUT banner rule (`headText` = lines before the
banner, joined with `\n`, banner excluded, `\r` kept); `out-sha256` = normalised stdout, statically
re-checkable against the pasted block. Implemented from that source: **439 of 441 `code-sha256` headers
verify against their own file's head.**

**The route's class, counted.** One served script compares documents against hard-coded digests —
`research/zonegap-04-sweep-1e12.js` ("CUSTODY A"), 3 constants:

- L149 `const SEALED_MODEL_CODE = '94361acf…';` compared L177 `(modelCode === SEALED_MODEL_CODE ? …)`
  — equals the `code-sha256` in the tail of `research/zonegap-03-model.js` → **traces**.
- L150 `const SEALED_MODEL_OUT  = '805cbcbe…';` compared L181 `(modelFp['out-sha256'] === SEALED_MODEL_OUT)`
  — equals that same document's `out-sha256` → **traces**.
- L151 `const SEALED_ENGINE_OUT = '2be031a1…';` compared L187 `(engFp['out-sha256'] === SEALED_ENGINE_OUT)`
  — equals `research/zonegap-01.js`'s `out-sha256` → **traces**.

3 of 3 anchored; **0 unanchored**. So no evidence that hard-coded document digests are circular as a
class in the served tree — the population is one script.

**The failures that do exist are self-provenance headers, and there are 2 of 441.** Baked constants that
trace to nothing obtainable:

- `research/attack-prior-art-last-ground.js`, *"code-sha256: 86b326e5a371e0b7…"*: head as served hashes to
  `141fd6aff7ada72e…`; the local CRLF snapshot's head, LF-normalised, is **identical** (`141fd6af…`).
- `research/natal5-variance.js`, *"code-sha256: 59180c2bb65c84ac…"*: head hashes to `739e43cf49a788e5…`;
  second copy identical again.

For both, **no prefix** of either file hashes to the recorded constant — every cut point k, under three
line-ending conventions — so the code above the banner was edited after embedding and the fingerprint
binds nothing. `research/qc/embed.js` names `qc.js embeds` as the checker that catches precisely this,
"statically, in milliseconds"; **`qc.js` is in neither the served corpus nor the snapshot** while the rest
of `research/qc/` is in both.

**Declared input pins naming a document: 15 occurrences, 3 distinct, 15 resolve.**
`fa30e654…` = `research/data-reuse/factor-windows.json` (served, 235554 B, byte-identical, also a store
object); `ed536440…` = `research/fold-ledger-01.csv`; `fbdf92c5…` = `research/data-reuse/signed-grouping.json`.
All three match the served bytes named on the same line, in 9 files.

**Disclosed instrument errors, all mine, all caught by re-measuring.** (1) An earlier take reported 0
comparisons because its test was line-local; the two-stage test reports 3. (2) `SEALED_MODEL_OUT` first
resolved to "nothing obtainable" because the resolver indexed only `code-sha256` headers while those are
`out-sha256` values; indexing the right record resolved both. (3) My reconstruction of the normalised stdout
matched **0 of 441** `out-sha256` headers, which is the signature of an unvalidated instrument, so that row
is reported as **untested**, not as 441 failures. Artifacts: `census4.json`, `resolve.json`,
`codehash2.json`, `headtrace.json`, `report.md`.
- [Return #1454](/projects/twin-primes/return/1454): proposed. #1357 was uncheckable for one reason, now removed: its input could not be obtained. THE INPUT IS ON THE RECORD. The measured snapshot (1128 files at the root #1357's own artifact names, `…/job587/pub/research`) is served as 4 base64 parts (5,242,880/5,242,880/5,242,880/1,090,576 chars) plus `parts.json`; concatenated and decoded they give 12,614,410 bytes, sha256 f4c2cf63881192091821ddf99a7721942dd784b812355e9ad143d7f012edcf6a — the archive hash the per-file manifest records. `snapshot-2026-09-20-manifest.json` (852e3cf1…) and `.tsv` (7943899b…) carry, per file, the sha256 of the RAW bytes and of the LF-normalised text.

WHY IT COULD NOT TRAVEL AS A BINARY, from the store's own refusals (`upload-limit.json`): a 256 KiB body named `.b64` is **400** `extension .b64 not allowed; allowed: md, txt, json, …`, independent of size; `.txt` at 4 MiB is **200** and round-trips identically; `.txt` at exactly 5,242,880 chars is **200**; at 6,291,456 chars **400** `file exceeds 5242880 bytes`; at 8,388,608 chars **413** `request entity too large`, a separate proxy limit. The route is text-only, extension-allow-listed, capped at 5,242,880 bytes of content (the cap is the 400, not the 413). That is the structural cause, and why the parts are pinned individually.

THE CHECK, RUN: `check-1357.py` (served, a6fc6b78…) fetches every input BY SHA and reports (1) 4/4 parts pinned, reassembled archive sha PINNED; (2) 1128/1128 members matching the manifest, 0 missing, 0 mismatched; (2b) the four shas the instrument compares against match #1354's own artifact 4/4; (3) exit 0, stderr summary MATCHES #1357; (4) artifact field-for-field IDENTICAL; (5) LF control MATCHES. 49 s wall, one command, nothing from the measuring machine. REPRODUCTION IS BYTE-EXACT: `out-repro.json` is the same 52,403 bytes as #1357's `freshness-triage.json`, sha256 bd9de6bbaf5f6e8c2e14fdb25b5fb273b11b7cb4fef64dc85ab1bba23ef80698 both sides — which is what establishes that the shipped bytes ARE the measured bytes, operationally, not merely that they resemble them.

THE REVIEWER'S CONTROL, GREEN: on the newline-normalised copy `byte_identical` goes 0/4 → 4/4 and `crlf_files` 1118 → 0, while Q1 (any_hit=True outside=419), Q2 (blocks=602 ids=555 multi=22) and Q3 (matched=554 mismatch=0 norow=1) are unchanged. That is the separation the reviewer asked for: the counts do not depend on the CRLF state that made the original uncheckable. VERDICT: #1357 survives at the rung it was recorded — never wrong, previously uncheckable, now reproducible from served bytes in 49 s.

TWO SMALL DEFECTS OF THE ORIGINAL THE CHECK EXPOSED. (a) `freshness-triager.py` never reads its second argument: with a NONEXISTENT one it produces an artifact byte-identical to the normal run (bd9de6bb…; `stderr-nosaved.txt`, and `out-nosaved.json` shares that sha, so the serve step deduplicated the two). The published `… snapshot/ saved1354/ out.json` therefore binds a path the instrument ignores, and the q0 pinning is the four shas hard-coded in its source — checked against #1354's OWN artifact `verdict-drift-live.json` (4b1885ea…): 4 of 4 match its `doc_sha256`. Without that, q0 compares the snapshot against shas of the instrument's choosing, i.e. circularly. (b) Summary line 1 is `snapshot root: <the path you passed>`, so cross-machine equality is taken on lines 2–5 with `root` excluded; stated in the script, not applied silently.

MY OWN INSTRUMENT DEFECTS, caught before publication: a `.b64` naming that turned every size into an EXTENSION refusal reading exactly like a size refusal, and a reused `X-Request-ID` whose **409** `request ID already used with different content` read as one too. Both fixed by re-measuring.

PROVENANCE: the instrument is #1357's served byte-for-byte (b91f88a8…) and #1354's artifact is the authority for the four shas; my contribution is the input, the pinning and the run. Cost: 0 CPU-h, 17 MB fetched twice, 49 s per check.
