Replication record · candidate-publication layer

Collection, independent reconstruction, and exact-set corroboration.

This page documents how the broad Federal Register publication universe was collected through the public API, repeatedly checked with Codex, rebuilt in a procedurally count-blind Claude Code run, and compared only after the fresh union was sealed.

788,470
Distinct publication identities
26/26
Annual partitions passed
Fourth
Complete Codex check in the project summary
Ordinal reported by the project log
26
Isolated Claude Code annual sessions
0 ↔ 0
Exact set differences after sealing
PASS
Candidate-identity layer

What is established

A verified identity universe for one documented source vintage.

Both systems produced the same exact set under the identity rule publication_date|document_number. The comparison found no differing annual count and no identity present in only one system.

This closes the candidate-publication identity layer. It does not validate sanctions classification, the routed-publication layer, the future country–product index, or the legal meaning of any publication.

Method overview · FederalRegister.gov API

Bounded enumeration with retained request evidence.

Endpoint: /api/v1/documents.json · no API key · order=oldest · per_page=1000 · no substantive filter in the all-publication inventory.

  1. 01

    Partition by month

    For each year, issue twelve non-overlapping date-only queries with inclusive calendar-month bounds.

  2. 02

    Enumerate API pages

    Request up to 1,000 records oldest-first and follow the exact same-host next_page_url returned by the accepted page.

  3. 03

    Preserve transport evidence

    Retain response bodies, headers, URLs, timestamps, byte counts, SHA-256 values, validation errors, and failed retries.

  4. 04

    Construct exact identities

    Key each publication as publication_date|document_number; validate nonblank fields, ISO dates, and year boundaries.

  5. 05

    Reopen from disk

    A separate verifier reads the retained bodies rather than accepting the collector’s in-memory result.

  6. 06

    Freeze, then compare

    Build and validate the 26-year union before consulting the historical result or comparing the two systems.

This six-step summary describes the clean live-API replication. The original Codex collector also retains broader agency and term queries for downstream routing, plus an annual inventory query; those auxiliary searches do not redefine the all-publication identity denominator.

Figure 01 · Source corpus

Annual coverage of the candidate publication universe, 2000–2025

788,470publication records

Federal Register publication records retained before sanctions-related screening. Bar lengths share a 0–34,000 scale; exact annual counts are printed.

  1. 200033,325
  2. 200132,003
  3. 200233,094
  4. 200332,805
  5. 200432,377
  6. 200532,233
  7. 200631,505
  8. 200730,818
  9. 200831,817
  10. 200930,663
  11. 201032,471
  12. 201133,103
  13. 201230,875
  1. 201330,771
  2. 201430,168
  3. 201529,977
  4. 201631,127
  5. 201727,530
  6. 201827,750
  7. 201927,168
  8. 202028,308
  9. 202127,712
  10. 202228,033
  11. 202328,317
  12. 202430,830
  13. 202523,690
Unit: Federal Register publication record. Source: retained FederalRegister.gov public API pages. Audit: 26/26 annual candidate-layer checks passed. These counts establish the integrity of the frozen capture, not completeness against the live API today.

Execution history

What ran, in what order, and what “independent” means here.

Independence is computational and procedural: a different model, isolated annual sessions, a separate implementation, and a post-freeze comparison. Both systems necessarily share the same public API source and the declared identity definition.

  1. 01Reported run history

    Repeated Codex validation

    The project summary identifies the accepted result as the fourth complete 26-year check.

    That ordinal comes from the project run history. It is not inferred from the final attempt directory alone.

  2. 02PASS

    Accepted Codex reconciliation

    Attempt 005 passed after four earlier aggregate implementations were rejected.

    The rejected implementations failed runtime, discovery, or schema-normalization design gates. They are preserved as method-development history—not counted as four successful replications.

  3. 03PASS

    Count-blind Claude Code run

    Twenty-six isolated annual sessions rebuilt the universe from the live API.

    No target or prior count was consulted until the fresh union was sealed and independently validated. The sessions shared one frozen method and package.

  4. 04Exact set match

    Post-seal corroboration

    A neutral parser compared the identity sets, not merely their totals.

    All annual counts matched. The symmetric difference was empty in both directions, and a common identity-only serialization produced one shared digest.

Verification ledger

Different operations, one comparison boundary.

The Codex path tests retained-capture custody and consistency; the Claude Code path performs a fresh source enumeration.

ControlCodexClaude Code
Primary operationReconcile 26 retained annual identity sets against three active file familiesEnumerate 26 years afresh from the FederalRegister.gov public API
Execution architectureRepeated project checks; accepted aggregate reconciliation attempt 00526 isolated annual sessions using one frozen method
Checksum evidence5,349 manifest checks; zero failures2,323 accepted annual checks; zero failures
File and identity controls78/78 active files unchanged; zero identity defectsZero blank, duplicate, contradictory, or wrong-year identities
Final independent gateIndependent final validator: PASSIndependent aggregate validator: PASS
Pre-comparison boundaryAggregate frozen before the historical comparator was suppliedTarget or prior count not consulted until the union was sealed and validated

Set-level result

Equal totals, equal annual counts, equal identities.

Comparison began only after the Claude Code union was sealed and its independent aggregate validator returned PASS.

TestCodexClaude CodeDifference
Distinct identities788,470788,4700
Annual counts26 values26 values0 differing
Duplicate row excess000
Codex-only identities0
Claude-only identities0

Representation-independent digest

72a011164d60c4d0ddc78a1de11bc9dd6598a78148f1ec617349821df3659943

UTF-8; sorted exact identities; one identity per line; LF after every line. The two original union-file hashes differ because Codex and Claude Code used different JSON structures; that file-level difference is not a set difference.

Repository packages

Source is stored in Git, not hidden behind a download form.

Repository access follows its current GitHub visibility. Public access begins only when maintainers deliberately open the repository; that source-publication gate is separate from release of the dataset.

Package 01Collection + reconciliation

Codex collection and reconciliation sources

Original-project API collector plus portable derivatives of the accepted 26-year reconciliation and independent validator.

Runtime
CPython 3.12.13; standard library only
Included
collector, query configuration, reconciliation sources, schema mappings, small PASS receipts, rejected-attempt receipts, and source hashes
Excluded
raw pages, 78 active inputs, annual packages, and the 104,027,267-byte union
Replay boundary
not self-contained without the omitted annual custody inputs
Open replication/codex on GitHub ↗
Package 02Live-API replication

Claude Code count-blind live-API replication

Portable live-API collector, disk verifier, aggregator, independent aggregate validator, 26 task prompts, and execution-source manifest.

Runtime
CPython 3.12.13; standard library only
Included
method, tools, annual prompts, dispatch manifest, small PASS receipts, per-year checksum arithmetic, patch disclosure, and source hashes
Excluded
raw bodies, annual outputs, superseded attempts, and the 50,436,683-byte union
Replay boundary
live reruns create a new source vintage and need not reproduce a past API state
Open replication/claude-code on GitHub ↗

Comparison receipt SHA-256: 5a7553991d54ea55333c56a5f003f359ec57ed2e2fa83313bbbb8393f8c684b4

Disclosed repair

The Claude collector was patched before the accepted runs.

A one-line repair supplied saved response headers to retry bookkeeping after a KeyError: 'headers'. Pre-fix SHA-256: 444421c34061b69771c9c884f91f3ad35a15d36c7f46947cd35e28f34c8f4ba9. Accepted SHA-256: c5ba487a903658b23cac43d88650eeb8e7cc5371e38d668516ee4bdc911c20b4. Query construction, pagination, identity formation, and verification were unchanged. Pre-fix attempts remain preserved in the private research archive and are deliberately excluded from the compact repository package.

Correction to the run narrative

wc -l was not a valid CSV row counter.

An interim wc -l reading was wrong because quoted CSV fields contain embedded newlines. Parsed as CSV, 2013 contains 30,771 rows and 30,771 distinct identities; duplicate excess is zero. The correction was made before this publication record was written.

Limitations and rights

What readers should not infer from this PASS.

Identity membership, not metadata equivalence
Codex recorded metadata-drift diagnostics in eight years separately. Those differences did not change membership in the exact publication identity set.
Not permanently live-complete
The Codex audit closes the frozen retained capture, and the Claude Code run corroborates it against the API at that run time. A later live API run is a new source vintage and may differ.
Not legal authority
FederalRegister.gov is an informational service. Legal research should verify the official edition on GovInfo and the operative source text.
Not independent human coding
This is cross-system computational corroboration, not a conventional double-coded human reliability study.
Not a data release
The 42+ GiB working archive and large source unions remain excluded. The future finished research dataset and API are separate publication gates.
Not open source yet
All project-authored materials remain all rights reserved unless a file states otherwise. Source visibility does not grant an open-source license.