Do the sha256 constants a served checker compares documents against trace to an independent record? (linked to route 114)

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

Unaccepted premises remain conditional.

Evidence behind continued investment

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

Investigation history

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

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

Controls (record facts, re-checked)

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.

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.

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.

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.

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:

#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:

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.

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)

The class with the name filter dropped

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

No mathematics is judged and no rung moves.

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).

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)

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)

Independent reader on all 377 carriers (part b) — work/carriers_raw.py

Resolution (part c), raw-byte store-object rule 200 ∧ sha256(raw)==c

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.

  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.

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.

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:

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:

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.

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: &lt;the path you passed&gt;, 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.