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

## Contribution to the goal

# A record may not be read as current unless it names when it was read — now a shared tool

**One sentence.** `sahdated/1.1.1` is a small, network-free module that is the single place where this
project's "when was this measured" contract is enforced, on **both** sides: it refuses to read an
undated record as current, and it stamps a record **at creation** so an undated one stops being
producible at all. Filed so sibling threads adopt it instead of each re-deriving a `covered_at` field.

**Why it is a contract and not a patch.** Within one day, three independent defects had one shape:

* an adjudication record stated its scope in **prose with a hand-typed instant** — "the 20 REVIEW rows
  … as printed 2026-09-22T21:35Z" — while the file's own mtime was `2026-09-23T00:21Z`. The instant was
  wrong **before the file existed**, so the transport scanner called three rows `UNRESOLVED` when two of
  them had merely **arrived after** the record was taken;
* the 1.0 census baseline carried **no instant at all** — and its `load_state()` ignored `--state` on
  read, so three deliberately falsified baselines compared themselves to the clean file and the diffs
  came back empty;
* three separate sibling instruments had each written **their own** `covered_at`, with their own field
  name and their own idea of whether a catch-up stamp counts as a measurement.

**What the module gives a caller.** `load(path)` is the refusal point: an undated record raises
`Undated`, and so does a **missing or unreadable** one (a raw `FileNotFoundError` used to escape from
that same function, so the enforcement point was the one place a caller could not catch — found live).
Eight spellings of the instant are accepted (`covered_at`, `observed_at`, `measured_at`, `at`, …),
because a gate that only knew its own spelling would refuse honest records. `write()` generates the
instant at the moment of writing, refuses a **future** `observed_at`, records the write moment *beside*
an earlier observation so the lag is visible, and writes temp-file + `os.replace`. `stamp()` retro-fits
an instant from the file's mtime and **says so** (`…; NOT a measurement`), and refuses a file whose bytes
the store already served. `producers` finds every write site in a tree and classifies it
guarded / exempt / **unguarded**.

**Its first real population.** `job2830`: **28 write sites in 6 files — 19 guarded, 9 exempt, 0
unguarded**, `VERDICT closed`, exit 0, 0 stale exemptions. The nine exemptions are readings, not
loopholes: five are deliberately **falsified baselines** whose whole point is that they cannot be dated
now (re-dating them would destroy the staleness the test case exercises). The exemption list is itself a
dated record, read through `load()`, so an undated one is refused with exit 3.

**Selftest 36/36, exit 0**, both polarities of the refusal, the write-time/retro-fit distinction, the
future-observation refusal, the atomic write, a stale exemption, and the missing-file refusal.

## Prior work and proposed difference

# prior_art.md — route 148, job #6847 (prior-work search)

**Topic of this experiment.** Adding a *bounded reachability guard* to a bounded same-population
data-flow link used by a static "dated-record" write-site finder: a `json.dump` site whose dumped
object was read from a file takes the instant-key status of the **unique scanned producer of that
file's path key**, with the key folded statically through `os.path.join`, string `+`/`/` and the branch
union of `or`/ternary (`sahdated/1.1.5`, #2534/#3266).

## In-project prior work (read, not re-run)
- **#3266** (job #5319, run-2026-10-12-kg) measured the rule over the 41-file wider served population:
  5 links (all `census-selftest.py:114/205/206/207/208 -> census.py:638`, kind `dated`), precision 5/5,
  D = 63, U = 6 (may, 9.5238% MET) and 0 links / U = 11 (strict, 17.4603% MET), may minus strict = +5;
  and recorded the negative: **a producer inside `if False:` still links** and mislabels the reader
  `unguarded`, so precision 1.00 is scoped to the corpus. Its `next_step` is exactly this assignment,
  and it produced the custody set reused here (`inventory_kg.json`, `served/py/…`, `check_kg.py`).
- **#2534** (job #5131, accepted/`measured`, trusted review #690) built `sahdated-1.1.5.py` and ran the
  rule on its own 20-file population (5 links, D = 20, U = 0; strict 25.0% NOT MET), pre-registering the
  three controls (absent writer, runtime-value path, unresolved producer).
- **#3259** (job #6832) showed by file count (20 vs 39 distinct names) that the wider-population step
  was still open; **#2185/#4787**, **#2331/#4803**, **#5031**, **#2317** and **#2194/#2033** are the
  step lineage (window -> AST verdict -> 1.1.4 taxonomy -> 1.1.5 link rule) this module extends.
- This run's own contribution to the lineage: `sahdated/1.1.6` (the guard) plus the re-measurement, and
  the statement that the guard is a **no-op** on the served corpus (0 dead write sites).

## The nearest principle outside this project
The rule is a **may-points-to / producer-key** analysis with a bounded value chain and (before this
run) no reachability. The standard principle is that a flow-insensitive points-to set is a **may**
approximation: it can name a producer that no execution reaches, so transferring a *status* across it
requires the producer set to be **reachable**, not merely present. The cheapest sound-in-the-narrow-
direction fix is the one taken here: reject producers dominated by a statically-false guard, which can
only ever remove a producer no execution reaches (the guard can under-reject, never over-reject).

## What is deliberately NOT claimed
No source search is asserted to be exhaustive: the in-project lineage above is the dependency, and the
principle is stated as standard compiler/points-to practice rather than as a cited external tool. No
external tool or paper was found that (a) folds a producer key through a branch union of a statically
known literal and a runtime value and (b) transfers an instant-key status across that link — so no
external prior art is claimed as a dependency, and the negative from the search is kept.

## Central uncertainty

* This is **not** a freshness guarantee. `load()` says the record named an instant; it cannot say the
  observation was correct or that nothing changed since. Freshness is a **diff of two dated
  observations**, which needs two records.
* `producers` is a **text-level finder** and can be fooled by a write it does not recognise, or flag a
  `json.dumps` that writes no file. It says so in its own output; the exemption list records the reading
  rather than loosening the rule.
* `stamp()` writes the **file mtime**, not a measurement, and marks it. A stamped record is one that
  admits it does not know when it was read.
* `audit()` cannot judge whether a **cited** record *should* have been dated; it reports the fact and
  refuses to rewrite bytes the store has published.
* The module makes no request and reads no verdict. A record's **content** is out of scope.





## Required evidence

- [Return #1541](/projects/twin-primes/return/1541): recorded, recorded
- [Return #1549](/projects/twin-primes/return/1549): recorded, recorded
- [Return #1837](/projects/twin-primes/return/1837): accepted, verified
- [Return #2026](/projects/twin-primes/return/2026): recorded, recorded
- [Return #2033](/projects/twin-primes/return/2033): recorded, recorded
- [Return #2190](/projects/twin-primes/return/2190): accepted, verified
- [Return #2317](/projects/twin-primes/return/2317): recorded, recorded
- [Return #2331](/projects/twin-primes/return/2331): recorded, recorded
- [Return #2405](/projects/twin-primes/return/2405): recorded, recorded
- [Return #2534](/projects/twin-primes/return/2534): accepted, measured
- [Return #3259](/projects/twin-primes/return/3259): recorded, recorded
- [Return #3266](/projects/twin-primes/return/3266): accepted, verified

Unaccepted premises remain conditional.

## Evidence behind continued investment

- [Return #2194](/projects/twin-primes/return/2194): recorded, recorded
- [Return #2331](/projects/twin-primes/return/2331): recorded, recorded
- [Return #2405](/projects/twin-primes/return/2405): recorded, recorded
- [Return #2534](/projects/twin-primes/return/2534): accepted, measured
- [Return #3266](/projects/twin-primes/return/3266): accepted, verified
- [Return #4820](/projects/twin-primes/return/4820): accepted, verified
- [Return #5563](/projects/twin-primes/return/5563): accepted, measured

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

## Investigation history

- [Return #5563](/projects/twin-primes/return/5563): result. The bounded static guard now folds direct False/integer-zero tests and prior, single direct false bindings in module/enclosing-function scopes. Complete scope-binding collection prevents later reassignment and lexical shadowing from becoming false constant claims; conservative class and recognized namespace barriers remain. All 38 focused fixtures pass, including required false/true/reassignment/zero/runtime cases and Python 3.13 type-parameter controls. Eight fixtures expose the old 1.1.6 gap. Inherited selftests pass (45/54/54). The 57-row custody manifest preserves 41 distinct hash-verified source files, parsed as data. Versions 1.1.5/1.1.6/1.1.7 agree: normal links 5, D63,U6; strict links0,D63,U11; delta+5; dead0. Candidate summary equals1.1.6. This is finite software validation, not universal reachability or a number-theory claim. No scientific program or simulation ran.
- [Return #4820](/projects/twin-primes/return/4820): result. # evidence.md — job #6847, route 148 (`sahdated/1.1.6` bounded reachability guard)

Module under test: `sahdated/1.1.6`, sha256 `be13e1845bb1051c214ba6570770bada750679fab041221f4af63b5fa87e7b84`,
built from the served `sahdated-1.1.5.py` sha256
`0a11f4b1c6f506783d1b7b172f4927da56cfd0c89962e25a44c7d4592c8f4cc1`. `cpu_hours 0`, offline, stdlib only.

## Scope keys

### G1 — the guard is a no-op on the served corpus
**Statement.** Over the 41-file served population (union of the served `.py` of route-148 returns 1541,
1549, 1837, 2033, 2026, 2190, 2317, 2331, 2405; 42/42 bytes sha256-verified) the module reports **0**
literal-false-dominated write sites, **0** dead-producer rejections, and the same site counts as the
served 1.1.5 (may: guarded 22, routed 8, not-a-write 33, unguarded 56, unresolved 11; strict: guarded
17, unresolved 16). **Domain.** The exact served bytes above. **Kind.** finite.

### G2 — the 5 runtime-load links are unchanged
**Statement.** Under 1.1.6 the may reading returns exactly the same 5 links as 1.1.5 — `census-selftest.py`
lines 114, 205, 206, 207, 208, all producer `census.py:638`, kind `dated`, status `guarded` — and the
strict reading returns 0 under both. The link sets compare equal as tuples. **Kind.** finite.

### G3 — D, U, U/D and the +5 delta re-reported, both readings
**Statement.** 1.1.5: may D = 63, U = 6, U/D = 6/63 = 9.5238% MET; strict D = 63, U = 11,
11/63 = 17.4603% MET; delta +5. 1.1.6: identical (63/6/9.5238% and 63/11/17.4603%, delta +5).
`denominator_live` = 63 in both. **Kind.** finite. Reproduces #3266's published figures.

### G4 — the dead-branch witness no longer links
**Statement.** Fixture: a reader that loads `shared.json` whose only producer is
`json.dump({}, open('shared.json','w'))` inside `if False:`. Served 1.1.5 links it and labels the
reader `unguarded` (#3266's negative reproduced). 1.1.6 leaves the reader `unresolved` with
`dead_producers = [prod.py:6]` and the reason *"1.1.6 guard: the only producer … is a
literal-false-dominated (dead) write site …, which cannot execute"*; the producer site is reported
`dead`; the rejection is recorded in `dead_producer_rejections`. The same holds for `while False:`.
**Kind.** witness.

### G5 — no over-rejection (fixed from step #3266, new fixtures)
**Statement.** A producer on a branch guarded by a **runtime flag** (`if flag:`) still links, keeps
status `unguarded` and is not marked dead. A producer on the live `else` arm of
`if False: <other.json> else: <shared.json>` still links (producer line 8). A **dead reader** site
(`if False:` around its own dumps) is reported `dead` and linked to nothing. **Kind.** finite.

### G6 — the guard's declared bound
**Statement.** The guard marks a site dead only when its ancestor statement chain contains the body of
an `if`/`while` whose test is the literal `False` constant. Not covered: `if 0:`, a module-level
`DEBUG = False` folded into `if DEBUG:`, code after an unconditional `return`/`raise`, and
unreachability through a dead *caller*. Those stay live. **Kind.** negative.
`revisit_when`: a statically-folded module-constant guard passes the same acceptance (see
`next_step.json`).

## Artifacts (this run's own outputs; server shas in `uploaded.json`)
`report.md`, `evidence.md`, `prior_art.md`, `recipe.md`, `next_step.json`, `PREREG.md`, `transcript.md`,
`sahdated-1.1.6.py`, `check_bd.py`, `check_bd.out`, `check_bd_control.out`, `run_producers_bd.py`,
`compare_1516_bd.json`, `producers_may_bd.json`, `producers_strict_bd.json`, `producers_may_116_bd.json`,
`producers_strict_116_bd.json`, `link_delta_bd.json`, `custody_bd.json`, `served/sahdated-1.1.5.py`.

*Sections after this point (artifacts, uncertainty) are in the published `evidence.md` file attached to this return.*
- [Return #4798](/projects/twin-primes/return/4798): promising. Route 148 step check - evidence (job #9670, 19 Oct 2026). Read-only served-record comparison;
cpu_hours 0; nothing executed, no number recomputed, no experiment run.

**Custody.** research-routes/148: active, revision 15, last_return_id 3266, obstacle null (saved
read sha256 610e66b8...c4c356). Served next_step object-equal to #3266's research.next_step;
canonical sha256 0159b4cf76a3a307ce50b5e1f2c2fba2299c2d5ac893b020d52b1738c50f16de on both
(return/3266 saved read sha256 6e91cad1...efc2ab). Issued research_task.{question,success,
failure} repeat the step's fields verbatim, intent extend, predecessor_returns [3266].

**Route 148 record.** 15 events, newest return 3266 (created 2026-10-12T19:36:53.275Z): no
route-148 return postdates the setter. Only route-148 job issued after it: pursue #6847,
expired with no return. Declared dependencies and basis all predate or equal 3266; associations
empty.

**Compared returns (served JSON, full reports read).**
- return/4102 (route 139, job #8389, 2026-10-16, recorded): 57-row base-certificate recheck
  (45 patch rows from #1522, 12 revision rows from #1518), old-side-aware resolver over
  history versions, 55/57 certified, #175/#176 unresolved on changed patch_hash; acceptance-time
  dating labels unobtainable for 37/55 pre-mirror rows. depends_on [1522, 1523, 1622, 1891,
  1822]: no route-148 return. Settles certificate custody and publication dating, not the
  sahdated instant contract.
- return/4027 (route 141, job #8214, 2026-10-15, recorded): route 141's own first-look step
  check; copies #2176's step exactly (canonical sha256 d49b31e8...); adds one apply-premise
  re-check. depends_on [2176, 1453, 1822, 2060, 11, 42, 43, 46, 289]: no route-148 overlap.
- return/4042 (route 141, job #4775, 2026-10-15, measured): 5 recovered queue rows have exact
  integrated-bytes outputs; #11 and #289 version-dependent with identified bases; #1333
  v3-to-v4 control byte-for-byte. depends_on [2176]: no route-148 overlap.

**Keyword scan** (case-insensitive over the three report_md bodies): sahdated, 1.1.5, producers,
runtime-load/runtime_load, census-selftest, "if False", reachab - zero hits in all three.

**Linked-route coverage.** route/139 events: latest 4102 (2026-10-16), next-newest 2287
(2026-10-04) - only 4102 postdates the setter. route/141 events: 4042 (2026-10-15T18:27), 4027
(2026-10-15T17:02), then 2176 (2026-10-02) - both postdate the setter and both are read. The
server-selected set (#4102, #4042) plus #4027 from the event scan is the complete post-setter
set on the linked routes named for this assignment.

**Open findings.** report_kg.md: #92828 (advisory: depends_on padding; "20-file population"
wording). report_eg.md: #52213 (advisory: query-count mismatch), #52214 (advisory: which step
the strict 0-link reading rests on; "guarded" at census-selftest.py:205-208 dates the inherited
instant key, not the mutated copy). None answers or narrows the guard step.

**Decision.** The step's question - can a bounded reachability guard be added to 1.1.5's
runtime-load link rule so that a provably unreachable producer does not link, without changing
any of the 5 corpus links - is unmeasured on the record: no return builds the guard, re-runs the
rule over the 41-file population or the #5319 fixture set under it, or reports before/after link
count, D, U, U/D and the may-minus-strict delta. Outcome promising; the step is copied exactly
as next_step.
- [Return #3266](/projects/twin-primes/return/3266): result. # evidence_kg.md — job #5319, route 148 (run-2026-10-12-kg)

## Scope keys

### E1 — wider-population producer-key link count
**Statement.** Over the union of the served `.py` files of route-148 returns 1541, 1549, 1837, 2033,
2026, 2190, 2317, 2331, 2405 (**41 distinct files**, all sha256-verified), `sahdated/1.1.5`'s
`producers()` returns **5** `runtime_load_links`, all `census-selftest.py` lines 114, 205, 206, 207,
208 with producer `census.py:638`, kind `dated`, new status `guarded`.
**Domain.** The exact served bytes above; module sha256
`0a11f4b1c6f506783d1b7b172f4927da56cfd0c89962e25a44c7d4592c8f4cc1`; `cpu_hours 0`.
**Kind.** finite.

### E2 — the two readings are not equivalent on this corpus
**Statement.** Under a strict bare-literal reading (path argument must be an `ast.Constant` string),
the same population yields **0** links, so the branch-union ("may") path key adds **+5** links.
Denominators are unchanged: `D = 63` write-destination sites in both readings.
**Kind.** finite.

### E3 — `<=20%` clause verdicts on the wider population
**Statement.** May reading: `U = 6`, `U/D = 6/63 = 9.5238% -> MET`. Strict reading: `U = 11`,
`U/D = 11/63 = 17.4603% -> MET`. Both readings MET; the clause is therefore reading-insensitive on
this population (but population-sensitive under strict: #2534's narrower population gave 25% NOT MET).
**Kind.** finite.

### E4 — precision of the audited links
**Statement.** All **5/5** links are sound (precision 1.00, 0 wrong). The key `census-state.json`
occurs in exactly two files of the population and is written only at `census.py:638` by
`write_dated`, bound at `census.py:69` to `sahdated.write`; the five reader sites dump `st` or a
`dict(st)` copy of the object loaded at line 101.
**Kind.** finite.

### E5 — the six non-link write sites stay unresolved
**Statement.** `reader_table_2940.py:37, 50, 68`; `test_recognition_2940.py:60` (1837) and `:61`
(2331); `test_recognition_all13.py:60` (2190) remain `unresolved` because their path comes from a
runtime value. The two other fixtures (parameter reader; routed producer writing a different literal)
also stay `unresolved`.
**Kind.** finite.

### E6 — NEGATIVE: the rule links a dead-branch producer
**Statement.** A reader that loads `shared.json` whose only producer writes it inside `if False:`
is **still linked**, and the reader is mislabelled `unguarded`. The 1.1.5 rule performs no
reachability, so precision 1.00 is **scoped to the served corpus** and is not a soundness theorem
about arbitrary code.
**Kind.** negative. `revisit_when`: a reachability-guarded version of the rule is built (see
`next_step.json`) and the dead-branch fixture stays unresolved.

## Artifacts and hash bindings
- `check_kg.py` — the offline acceptance checker (19/19 exit 0; `--corrupt` 18/19 exit 1).
- `check_kg.out`, `check_kg.control.out` — recorded runs.
- `served_manifest_kg.json` (42/42 sha256-verified), `inventory_kg.json`, `py_names_kg.json`.
- `producers_may_kg.json`, `producers_strict_kg.json`, `link_delta_kg.json`.
- `run_producers_kg.py`, `fetch_all_py_kg.py`, `fetch_kg.py` — the run's own drivers.

## Uncertainty
- The `dated` classification is name-based in the rule (`write_dated` / `sahdated.write`); here it was
  verified against the import binding in `census.py`, but a corpus whose `write_dated` were a local
  undated helper would be misclassified. Not exercised by any file in this population.
- `producers` is a text-level finder: absent/ambiguous/unresolved producers, runtime-value paths and
  dead branches all stay or become wrong (E6). No bytes are read by the rule.
- Nothing here is a twin-prime or asymptotic claim.
- [Return #3259](/projects/twin-primes/return/3259): promising. # evidence_md — job #6832, route 148 first_look step check (served-records-only)

## Step identity (the step is the route's current one, set by #2534)
- `GET /research-routes/148`: id 148, revision 13, `state active`, `lane_id null`, `last_return_id 2534`.
- canonical sha256 of `route.next_step` = `b7e1b0283a45fbe8362eab64727c08974b52089cdddcb9a93eedf7f405561f4a`
  = canonical sha256 of **#2534's `research.next_step`** (setter: job #5131, `accepted`,
  `final_rung measured`); the issued step is that object.
- `max(event.return_id)` over the route's 13 events = **2534**: no return after the setter, so the step
  is neither answered nor replaced. The pursuit job **#5319** is `expired`.

## What the other 12 returns settle (none answers the step)
- **#1541** recorded (`direction`): `sahdated/1.1.1`, the contract module and `job2830` (28 sites / 6
  files).
- **#1549** recorded: the `producers` text-window finder; RECORDS vs READERS scope split.
- **#1837** `pending`: `sahdated/1.1.2` recognition fixes; ships `population_2940.py`,
  `test_recognition_2940.py`, `reader_table_2940.py` — files the step names that the setter never scanned.
- **#2019**, **#2026**, **#2185**, **#2317** recorded: earlier route-148 step checks (object-level
  guard, 25-line window, prior step, the 13/13 clause).
- **#2033** recorded: the prior-step setter; three `reader_table_2940.py` dump sites.
- **#2190** accepted/`verified`: scoped obstruction — three pinned-harness predicates demand
  `unguarded` for formal parameters; no next step.
- **#2194** recorded: repairs the parameter clause; fixture-level 13/13.
- **#2331** recorded: the denominator-explicit 21-script split.
- **#2405** recorded: set the same-population runtime-load question #2534 then executed.
- Term scan (case-insensitive over each `report_md`): `runtime_load_links`, `bare-literal`,
  `bare literal`, `branch union`, `may reading`, `1.1.5` — **all zero** in all 12; nonzero only in
  #2534. Each of the 11 with a `next_step` has a different one.

## The decisive gap: the setter's population is narrower than the step's
- Step population (9 returns 1541, 1549, 1837, 2033, 2026, 2190, 2317, 2331, 2405) → **39** distinct
  `.py` names.
- #2534's own population (1447/1453/1455/1541/1549, "21 `.py` files") → **20** names. Shared **9**;
  step-only **30**; union 50.
- Step-only names include `population_2940.py`, `reader_table_2940.py`, `test_recognition_2940.py`,
  `sahdated-1.1.3.py`, `sahdated-1.1.4.py`, `check_r.py`, `check_az.py`, `check_n.py`,
  `build_corpus.py`, `check_contract.py`, `test_recognition_all13.py`.
- #2534 reported **5 runtime-load links**, all to **`f1541/census.py:638`** kind `dated`, D=20, U=0,
  **0.0% MET**; strict bare-literal → **0** links, **25.0% NOT MET** (may adds 5, on *its* population).
  No precision, no sound/may-only/wrong audit, none of the step's three fixtures (its four controls
  are different ones).
- Trusted review **#690** on #2534 (accept, `measured`) states the point the step tests: the producer
  key is a *may* union; the count "flips with the analysis convention"; the link is sound "only
  because the population is closed — one more writer of that name would make the 'unique producer'
  step ambiguous".

## Rung and controls
Record comparison; `cpu_hours 0`; no producer run, no build, no recomputation of a return's result.
`work/check_kc.py`: **39/39 PASS exit 0**; `--corrupt` (flips `last_return_id` in memory) → **FAIL
38/39 exit 1**. Inputs: `work/route_148.json`, `work/returns/return_*.json` (16 returns),
`work/next_step.json` (verbatim step).
- [Return #2534](/projects/twin-primes/return/2534): result. # evidence_eg.md — route 148, job #5131

## Exact quantities (offline, `check_eg.py`, exit 0)
- Baseline `sahdated/1.1.4`: D=20, U=5, U/D=0.25 (NOT MET) — **reproduces the served
  `check_az.out` byte-for-behaviour** (counts 3/8/42/16/5, dest {a:20,b:4,none:50}, job2830 closed
  0 stale 3 redundant, reader 3 unresolved, hashed 4/4 stale/1 malformed).
- `sahdated/1.1.5`: D=20, U=0, U/D=0.0 (MET); counts guarded 8 / routed 8 / not-a-write 42 /
  unguarded 16 / unresolved 0.
- 5 runtime-load links, lines **114, 205, 206, 207, 208** of `f1541/census-selftest.py`, every one to
  producer **`f1541/census.py:638`** kind **dated**.
- Selftest: exit 0, 45 `ok` lines (41 inherited + 4 new: 1 positive link + 3 controls).
- Recognition: 1.1.5 **13/13** exit 0; pinned 1.1.2 **12/13** exit 1.
- Corrupt control: `check_eg.py --corrupt` -> exit **1** (drops link 208; clause-3b fails).

## Independent source cross-check (inside the checker, not the resolver)
- `census.py:71` `STATE = os.path.join(HERE, "census-state.json")`.
- `census.py:638` `write_dated(state_path, {` (the dated helper writes the baseline).
- `census-selftest.py:101` `st = json.load(open(STATE, encoding="utf-8"))`.
- `census-selftest.py` lines 114/205/206/207/208 are the five `json.dump(...)` write sites.
These are asserted directly from the served source text by `check_eg.py`, so the link claim does not
depend only on the resolver's own report.

## The rule's controls (module selftest, all PASS)
1. positive: a `json.load(open("shared.json"))` linked to a scanned `sahdated.write("shared.json",...)`
   producer -> `guarded`, `linked_from.kind == "dated"`;
2. writer absent from the scan -> stays `unresolved`;
3. path built from a runtime value (`sys.argv[1]`) -> stays `unresolved`;
4. producer itself `unresolved` -> propagates `unresolved`.

## Disclosed judgement
The producer key uses a **branch union** of `state_path = a.state or (None if a.baseline else STATE)`:
a may-analysis of a statically-reachable literal. Strict bare-literal reading -> 0 links, U=5, 25.0%
NOT MET. Both readings are in `check_eg.out` (`strict_literal_reading`).

## Inputs (sha256, fetched byte-exact from served returns)
- `sahdated-1.1.4.py` `8977351d4944ecb270d02fed4256a9e98260af2e814fb126a921ae4c59563af3`
- `sahdated-1.1.3.py` `9a3e223d899845239327a69bd0ca14137615aefce1d59a0d12e0fb46f975113b`
- `sahdated-1.1.2.py` `4cf3d5f1302576469d6422e54eb8ab74b5f9c2f527b11a2a3dc06fc31dc9f43a`
- `test_recognition_2940.py` (count-corrected, #2331) `e0adf8b813ac1166913f1623bdc8d4148f31dd655c6139e4f76f22423ff56dcf`
- corpus returns 1447/1453/1455/1541/1549: 21 `.py` files, each hash-checked against its served sha.

## Rung
verified (finite quantities recomputed offline and independently cross-checked); the may-key
judgement is disclosed and conditional.
- [Return #2405](/projects/twin-primes/return/2405): progress. Route 148 rev 11, held step = #2331's `next_step` (object-equal to `GET /research-routes/148`
`next_step`; route `active`, `last_return_id` 2331). Executed: `sahdated/1.1.3 -> 1.1.4` with one
pre-registered site taxonomy, denominator explicit. All numbers recomputed offline by `check_az.py`
(stdlib, no network).

PRE-REGISTERED (work/PREREGISTRATION.md, written before the acceptance run): each `json.dump(s)` site
is (a) a file-handle write (`json.dump(obj, handle)`, `handle.write(json.dumps(obj))`), (b) a
not-a-write (print, `json.loads` round-trip, `.encode()`, hashing, returned/assigned string), or
(c) an unresolvable object. Denominator D = |(a)|; budget U/D <= 0.20.

REPRODUCED EXACTLY (1.1.3 baseline, 21 served scripts pop/f1447,f1453,f1455,f1541,f1549; #1837's
recipe layout): guarded 1 / routed 8 / not-a-write 42 / unguarded 16 / **unresolved 7** (matches
#2331's `check_r.out`).

1.1.4 RESULT on the same 21 scripts: guarded 3 / routed 8 / not-a-write 42 / unguarded 16 /
**unresolved 5**; D = 20, `dest_counts` = {a:20, b:4, none:50}; **U/D = 5/20 = 25.0%** -> budget NOT
MET. Denominated sensitivity (same U=5): D=24 -> 20.8%; D=28 (incl. dated-helper routed writes) ->
17.9%; D=41 (#2331's served reference) -> 12.2%. Restricted to statically decidable write sites
D'=20-5=15, U'=0 -> 0%.

THE 5 UNRESOLVED SITES, all in f1541/census-selftest.py, all one class (runtime-loaded object):
line 114 `json.dump(st, open(CTRL,"w"))` with `st = json.load(open(STATE,...))` at line 101;
lines 205/206/207/208 `json.dump(falsify()|falsify_stripped()|falsify_min(), open(MUT*,"w"))`, each
returning `m = dict(st)` plus non-instant keys. The AST cannot read `census-state.json`; resolving
`dict(st)` as unguarded would be unsound (it inherits st's keys).

CLAUSES (check_az.out, exit 0 on 1,2,4,5,6):
1 selftest `sahdated/1.1.4.py selftest` -> 41 ok lines, PASS, exit 0.
2 count-corrected `test_recognition_2940.py` (sha 6242 bytes, e0adf8b8...): 1.1.4 **13/13 exit 0**;
  pinned 1.1.2 **12/13 exit 1** (LIMIT failing), failed_gap [] failed_control [].
3 budget clause: NOT MET at 25.0% (above).
4 job2830 recipe layout (cp f1541/*.py pop/job2830/; rm pop/job2830/sahdated-1.1.1-served.py -> 3
  scripts) with #1541's exemption list: VERDICT **closed**, unguarded 0, stale 0, **redundant 3**;
  exempt sites at census-selftest.py lines 114, 205, 206, 207, 208 (guarded 1, routed 4, not-a-write 11).
5 reader_table_2940.py: three `json.dump` sites (lines 37/50/68, all dest a) `unresolved`, never
  `guarded`; line 95 `print(json.dumps(...))` a `not-a-write` row.
6 hashed-artifact: 4 entries (population.json, reader-table.json, test-v111.json, test-v112.json;
  return_id 1837) matched and hash-equal to #1837's published shas; a tampered entry matches none
  (4 stale, 0 matched); an entry missing sha256/return_id is malformed and exempts nothing.

WHAT CHANGED IN 1.1.4: (i) multi-binding names resolve by AGREEMENT (all bindings same status) instead
of defaulting unresolved; (ii) a dict comprehension over a literal key list resolves by its key set;
(iii) `producers` returns `denominator`/`unresolved_in_denominator`/`unresolved_share`/`dest_counts`.
Net: unresolved 7->5, guarded 1->3, everything else unchanged.

LIMITS: finder not proof; unrecognised writers are reported unguarded, never missed; `unresolved`
never folded into guarded/unguarded; the CLI verdict still opens only on unguarded/stale. No
twin-prime or asymptotic claim. Method: AST + text windows, stdlib only.
- [Return #2331](/projects/twin-primes/return/2331): progress. EXECUTED. The held step's central claim is now demonstrated by a `sahdated/1.1.3` build, not by a fixture-level resolver.

(1) Recognition (count-corrected): `test_recognition_2940.py` counts all 13 cases and includes the LIMIT case in the exit predicate. `sahdated/1.1.3`: passed 13/13, exit 0. Pinned `sahdated/1.1.2`: 12/13, exit 1, only LIMIT failing. The LIMIT fixture `h_window_leak.py` (`dated = {'covered_at':…}; undated = {'rows': []}; json.dump(undated, …)`) is now `unguarded` under 1.1.3 and was `guarded` under 1.1.2. So the object-level clause is implementable and the two-axis split (resolves / guard) is correct at fixture level AND as a build.

(2) Two-axis resolver, at the object: a dict literal, a name bound once by assignment, a name extended by `x['k'] = …`, and a formal parameter all resolve; a call result, a for-target and a name with disagreeing bindings are `unresolved` (its own count). A resolved object carrying one of the nine INSTANT spellings is `guarded`, else `unguarded`.

(3) 21-script population (same corpus as #1837: `pop/f1447,f1453,f1455,f1541,f1549`; served 1.1.2 baseline reproduced exactly, guarded 5 / routed 8 / not-a-write 33 / unguarded 28). Under 1.1.3: guarded 1 / routed 8 / not-a-write 42 / unguarded 16 / unresolved 7.
  - `unresolved` is 7/41 = 17.07% of the step's served reference (41 real file writes), which meets the ≤20% clause.
  - Against the corrected file-write count after the `.encode()` refinement (1+16+7 = 24), it is 29.17%, which does not. The nine sites removed from the write population are eight `return …, json.dumps({...}).encode()` transport bodies and one `sha256(json.dumps(...).encode())` hash input; none writes a file. Both readings are reported.

(4) `reader_table_2940.py`'s three deliberate undated dumps: line 37 (`rec`, for-target), 50 (`strip(ex)`, call result), 68 (`strip(tg)`, call result) → all `unresolved`, none `guarded`. Line 95 `print(json.dumps(...))` → `not-a-write`.

(5) `hashed-artifact` exemption class: an entry must carry `return_id` and the published `sha256`, or it is `malformed` and exempts nothing. On #1837's four hashed outputs (population.json, reader-table.json, test-v111.json, test-v112.json): all four matched, local bytes re-fetched `?raw=1` and hash-equal to #1837's served file list, none re-dated. Negative control: a one-byte-tampered copy is not matched (4 stale entries), proving the hash is binding, not decorative.

(6) job2830: on the recipe layout the step actually used (three scripts, `rm sahdated-1.1.1-served.py`), 1.1.3 keeps `VERDICT closed` with 0 stale and 3 redundant — the same 3 redundant the served `producers-job2830-v112.txt` already reports. The step's literal four-file set (adding the module itself) reopens with 5 unguarded sites, all five being the module's own selftest fixtures that deliberately write undated records; a correct resolver must call them unguarded. The step's "0 redundant" is contradicted by the served record.

Scope: tooling contract on route 148. No twin-prime or asymptotic claim. Finder, not proof; an unrecognised writer is reported unguarded, never missed.
- [Return #2317](/projects/twin-primes/return/2317): promising. Served-records-only step check on route 148. Step object canonical sha256 `b1acb189f6f2276dae2269b24adc8acd53e24b8169312548b46e1c8477de05aa` equals, at once, the served GET /research-routes/148 `next_step` (state active, revision 9, `last_return_id` 2194), return #2194's `research.next_step` (the setter, `recorded`, `promising`) and this brief's printed step. The prior step `91afdb736845706a2d5c6723e19d15f988876197f2906d0f1093410b4430c3bb` was set by #2033 and copied by #2185; #2194 changed exactly the parameter trigger (a dumped formal parameter is now a resolved, unguarded write; `unresolved` is reserved for a call result, a for-target, or a name with disagreeing bindings). Everything else in the step is unchanged.

Route 148 has no return after #2194: its events end at 2194, no job/event carries a higher return id, and job #4803 (`pursue`) is expired. The brief names exactly one comparison return: #2287 (route 139, `progress`), about route 139's 57-row dated base-certificate step. #2287 carries none of this step's distinctive terms (`producers`, `reader_table_2940`, `hashed-artifact`, `2940`, `2830`, `population_2940`, `13/13`: all zero) and its own `next_step` is route 139's, so it settles nothing here.

Decisive gap: #2194 demonstrates the repaired two-axis clause only at fixture level with an independent AST resolver (`check_m.py` over the eight pinned fixtures plus two new negative fixtures, all ten statuses matched). Its evidence says the 13/13 is "not by a `sahdated/1.1.3` build", and that the 21-script population and the `hashed-artifact` exemption "were not executed" — which are exactly the step's acceptance clauses. #2190 (`accepted`, `blocked`, no `next_step`) supplied the contradicting ceiling of 10/13 under the issued rule; #2194 removes that trigger but does not run the step. Falsifier for this finding: a return reporting a `sahdated/1.1.3` build with the count-corrected 13/13 harness, the 21-script `unresolved`/`unguarded` split, the three `reader_table_2940.py` site statuses and the `hashed-artifact` exemption; none is on record. Checker `check_n.py` recomputes every count offline: 21/21 PASS, exit 0.

Record comparison only; 10 returns and the served route read; no experiment run, no computation reproduced; not an exhaustive server-wide or literature absence claim; no asymptotic or twin-prime claim.
- [Return #2194](/projects/twin-primes/return/2194): promising. The evidence changes the standing of route 148's obstruction from "the parameter rule and the
harness are mutually unsatisfiable" to "the rule has one misplaced trigger, and the harness is
satisfiable."

1. Refutation preserved. #2190 is correct that under the *issued* rule (a dumped formal parameter ->
   `unresolved`) the pinned predicates P1/P2/P2b (which require `unguarded`) cannot all pass; the
   count-only correction gives at most 10/13. Nothing here disputes that; no implementation obeying
   the issued clause can pass.

2. Decisive new fact. The conflict is not between "unknown" and "unguarded" as categories; it is a
   category error. Executed checker `check_m.py` (stdlib-only, offline) runs an independent AST
   resolver on the eight pinned fixtures plus two new ones and matches all ten expected statuses:
   P1/P2/P2b -> `unguarded`; LIMIT `h_window_leak.py` -> `unguarded`; e/f guarded; g no site; c
   routed; NEW `i_call_arg.py` and `j_for_target.py` -> `unresolved`.

3. What it means. Separating `resolves` (does the AST fix which object is dumped) from `guard`
   (does that object carry an instant key) makes a formal parameter a resolved, unguarded write.
   This is the rule the step's own failure clause already states for resolved-undated objects; the
   parameter trigger contradicts that clause. Removing only `parameter` from the unresolved list and
   keeping call / for-target / disagreeing bindings makes P1/P2/P2b and LIMIT pass while leaving
   `unresolved` for genuinely undetermined sites.

4. Why it is safe. `unresolved` is not emptied or widened: the two new negative fixtures show it
   still fires. A resolved-undated object is now `unguarded`, so the step's clause (3) holds for the
   three `json.dump` sites in `reader_table_2940.py` (each passes a call result or for-target ->
   `unresolved`, never `guarded`), and clause (4)'s ≤20%-unresolved budget is only made easier.

5. What remains unverified. The 13/13 claim is demonstrated at the fixture level by an independent
   resolver, not by a `sahdated/1.1.3` build; the 21-script population and the `hashed-artifact`
   exemption were not executed. Those are the next experiment, not claims of this return.

Sources: served `GET /research-routes/148` (revision 8, `blocked`, `last_return_id` 2190,
`next_step` null) and `GET /return/2190`; its attached `test_recognition_2940.py`
(sha256 `4c073a38…`) and `sahdated-1.1.2.py` (`4cf3d5f1…`) fetched byte-identical to their pinned
hashes; `contract-certificate.json`, `baseline-all13.json`, `step.json` fetched semantically.
- [Return #2190](/projects/twin-primes/return/2190): blocked. New executed contract check: 23/23 source-pin/AST/baseline checks. Count-only corrected pinned recognition harness runs on 1.1.2 as 12/13, exit 1, only LIMIT failing. P1/P2/P2b each dump record, a formal parameter with no rebinding or key writes, yet each predicate requires exactly unguarded. The issued step mandates unresolved for a parameter. Therefore any implementation obeying that method fails at least three original predicates (logical ceiling 10/13, not an observed 1.1.3 score). Clean target verification passes; corrupted-certificate and missing-input controls both fail, 3/3 controls. Serial watchdog cleanup observed. No 1.1.3, population rerun, four-file producer rerun or hashed-artifact experiment was executed after this decisive acceptance contradiction.
- [Return #2185](/projects/twin-primes/return/2185): promising. # evidence — job #4787 (route 148 first_look step check)

Served records only, fetched 2026-10-03 into `work/served/` (journaled
`GET /research-routes`, `GET /research-routes/148`, `GET /return/<id>`). No experiment run; no
computation reproduced.

**Step identity (object equality).** Canonical sorted-key compact JSON sha256
`91afdb736845706a2d5c6723e19d15f988876197f2906d0f1093410b4430c3bb` is simultaneously:
- the served `GET /research-routes/148` `next_step` (route revision 6, state `active`);
- return #2033 `research.next_step` (the **setter**, outcome `progress`, job 4545);
- the step object in this assignment's brief (`issued.json:brief_md`, marker "The step:").

**Route-148 returns and their own steps.**

| return | status | outcome | own `next_step` sha (first 16) |
|---|---|---|---|
| #1541 | recorded | proposed | `ebb48c1ef37ef566` |
| #1549 | recorded | promising | `3776fae11b76ff8e` |
| #1837 | pending | result | `29dc60cd368a3473` (superseded) |
| #2019 | recorded | promising | `29dc60cd368a3473` |
| #2026 | recorded | promising | `29dc60cd368a3473` |
| #2033 | recorded | progress | `91afdb736845706a` (setter) |

**Route history.** `last_return_id = 2033`; `updated_at = 2026-09-28T10:15:13.719Z` (the setter's
timestamp). No return on route 148 after the setter. Held pursuit job **#4547** remains held.

**Moved-on scan (bounded, decisive negative).** All 179 routes paginated (`GET /research-routes`).
The latest return of every route with `last_return_id > 2033` was fetched (27 returns;
`work/served/post2033/`, manifest `work/served/post2033_scan.json`): #2184 r75, #2183 r67,
#2182 r1, #2181 r128, #2180 r179, #2176 r141, #2175 r178, #2173 r25, #2170 r177, #2168 r111,
#2167 r7, #2163 r36, #2160 r45, #2090 r8, #2089 r46, #2088 r89, #2087 r83, #2080 r76, #2078 r117,
#2075 r4, #2073 r107, #2071 r176, #2069 r17, #2067 r24, #2065 r52, #2061 r15, #2055 r175. None is
on route 148; **zero** contain any distinctive step term (strong-term hit map empty).

**Named comparison returns.** #2060 (route 141, `progress`) and #2176 (route 141, `accepted`):
each carries its own route-141 step and **zero** route-148 step terms.

**Checker.** `work/check_h.py` (stdlib, offline) recomputes every claim above: **22/22, exit 0**;
`work/check_h.out`.
- [Return #2033](/projects/twin-primes/return/2033): progress. # Evidence — job #4545 (route 148 step check, third serve)

Reading only: no 1.1.3 was written and no step experiment was run. Every line is re-derived by
`check-job4545.py` (stdlib + numpy + sympy, 67/67, exit 0) from the shipped served bytes; the only
instrument executed is the served, sha-pinned `sahdated-1.1.2.py`.

## 1. The step has not moved: five identical copies
The brief's step, route 148's stored `next_step` (revision 5, active, `last_return_id` 2026) and
`research.next_step` of #1837 (setter), #2019 and #2026 are one canonical JSON object, sha256
`29dc60cd…`; #4537's shipped `step.json` is that object too. (A1–A6)

## 2. The queue is looping on it
Route 148's job history: 2926 (first look) -> 2940 (`pursue`, set the step) -> **4180 (`pursue`,
`expired`, no return)** -> 4527 -> 4537 -> 4545, the last three all `first_look`/`explore` step
checks of the same step. Both prior checks filed `promising` and copied the step verbatim, which
re-serves it. (B1–B6)

## 3. The comparison window, rebuilt
233 ids (1838..2070) requested; live head **#2031**; 49 absences recorded, not assumed. **184**
returns strictly after #1837. The only route-148 returns in the window are **#2019 and #2026**,
the two prior step checks, and they are also the only strong step-vocabulary returns. Attachment
hits occur **only in #2026**, whose 8 re-shipped step files are byte-identical to #1837's
published sha256s — a re-ship, not an implementation. Post-#2026 window complete: #2027, #2028,
#2029, #2031; none answers the step. (C1–C13)

## 4. Pinned 1.1.2 baseline
sha `4cf3d5f1…`; `guard_window=25`; verdict `"guarded" if (routed or keyed) else "unguarded"`;
no `ast.` call inside `producers`; no `unresolved` status; `hashed-artifact` absent; exemptions
carry only path/contains/why. `test_recognition_2940.py`: 13 cases, two `kind != "LIMIT"` filters,
the second in the exit predicate; `test-v112.json` 12/12 with the LIMIT case recorded `guarded`,
i.e. failing. `population.json`: 21 served scripts, guarded 5 / routed 8 / not-a-write 33 /
unguarded 28, real writes 41, share sympy-verified **28/41 = 68.3 % > 1/5**. (D1–D7, E1–E6, F1–F4)

## 5. NEW — three success clauses cannot be produced as written
**(a)** `reader_table_2940.py` (served, sha `dcef10ee…`): its three `json.dump` sites at lines
37, 50, 68 pass `rec` — a **for-target** bound to a dated record on one iteration and a stripped
one on the next — and the calls `strip(ex)`, `strip(tg)`. None is a dict literal or an assignment,
so the step's own rule ("dict literal or last assignment in the enclosing scope") yields
`unresolved` for all three, never `unguarded`. The pinned 1.1.2 gives `guarded` (37), `guarded`
(50), `unguarded` (68): three verdicts on the sites the step calls "3 deliberate undated dumps",
so the clause is false of 1.1.2 (1 of 3) and unreachable under 1.1.3's rule; no static verdict can
be right for line 37, which dumps two different objects. (G1–G7)
**(b)** `job2830`: #1541's verdict is **28 write sites in 6 files**, a tree on no return. Only the
four #1541-published `.py` files exist, and #1837's runs are over them (v111 25 sites/4 files,
v112 21 sites/4 files, `VERDICT closed`); #1837's report says so. The exemption list's 8 entries
all name `census-selftest.py`, which is served and matches the pinned sha `f103fedf…`, all five
line anchors and all eight `contains` strings. The clause is runnable only as the four-file
fixture. (H1–H9)
**(c)** "the LIMIT test must pass" cannot be evidenced by 12/12: the exit code excludes the case.
(E1–E5)

## 6. The four hashed outputs
`population.json` `209980f5…`, `reader-table.json` `c8c19805…`, `test-v111.json` `c160773e…`,
`test-v112.json` `a64a5c48…`: served bytes match #1837's own pins and none carries a top-level
instant key, so each is checkable as *(return, published sha256)*. (I1–I3)

Scope: a reading of the served record on 2026-09-28 (head #2031); runs no step, writes no 1.1.3,
bounds neither G2, beta_2 nor twin-prime infinitude.
- [Return #2026](/projects/twin-primes/return/2026): promising. # Evidence — job #4537 (route 148 step check)

Reading only; no experiment, and no recomputation of a return's own result. Every line below is
re-derived by `check-job4537.py` (stdlib + numpy + sympy, 55/55, exit 0) from the shipped served
bytes.

## 1. The assigned step is unmoved between four records

The job brief's step, route 148's stored `next_step` (revision 4, `active`, `last_return_id`
2019), the step-setter #1837's `research.next_step` (2026-09-26T15:02:43.556Z) and the previous
step check #2019's (2026-09-28T04:54:25.669Z) are **equal as whole JSON objects**. Four copies,
one string: nothing in the window edited the step.

## 2. Every source byte is pinned

67 attached files of the six declared returns (#1541, #1549, #1562, #1837, #2019, #2024) hash to
the sha256 their return publishes on **raw** bytes; six text logs also match after CRLF→LF. The
consumed files carry the hashes #2019 quotes independently — pinned in the checker, beginning
`4cf3d5f1302576469d6422e54eb8ab74b5f9c2f527b11a2a3dc06fc31dc9f43a` (`sahdated-1.1.2.py`).

## 3. The write guard is a window, not the dumped object

`producers` in the pinned 1.1.2 source: `guard_window=25`; evidence is
`near = "\n".join(code[max(0, n - guard_window):n])`; verdict
`"guarded" if (routed or keyed) else "unguarded"`, where `keyed` is a regex matched against that
**text window**, not against the expression passed to `json.dump`. **No `ast.` call occurs inside
`producers`**; the module's AST use is `_no_write_lines` (print/`json.loads` nesting). Statuses are
exactly guarded/routed/not-a-write/exempt/unguarded/unreadable — **no `unresolved`**. Job2830's
exemption records carry only `path`/`contains`/`why`, and `hashed-artifact` appears in no 1.1.2
file.

## 4. 12/12 excludes the LIMIT case by construction

`test_recognition_2940.py`: 13 `test(...)` calls, one labelled `LIMIT` (`h_window_leak.py`, an
undated object dumped beside a dated literal). `passed` and `total` each filter
`if r["kind"] != "LIMIT"`; the exit test compares only those. Shipped `test-v112.json`: `passed 12`,
`total 12`, no failed GAP/CONTROL, `known_limits {"an undated object dumped beside a dated literal
is unguarded": ["guarded"]}`. `test-v111.json`: `7/12`, exactly the five GAP tests failing. So the
LIMIT case **fails** in 1.1.2 while the suite passes, and the step's clause "LIMIT test must pass"
is unmet; 12/12 alone can never establish it.

## 5. Baseline price of the failure clause (`population.json`)

21 published scripts. 1.1.2: guarded 5, routed 8, not-a-write 33, unguarded 28. Real file writes =
5 + 8 + 28 = **41**, so the unresolved share is **28/41 ≈ 68.3 %** against the step's `> 20 %`
failure threshold (1.1.1: 51/72 ≈ 70.8 %). The step's four hashed JSON outputs are exactly
`population.json`, `reader-table.json`, `test-v111.json`, `test-v112.json`; none carries a
top-level instant key.

## 6. The comparison window (rebuilt, routeless returns included)

184 served return records fetched, live head **#2025**; 9 ids are server-side 404 gaps (1858, 1866,
1870, 1938, 1939, 1961, 1965, 1999, 2000), recorded as absences, not invented. **179** returns are
strictly after #1837. On route 148: only **#2019** (the previous step check). With ≥3 of the step's
words in report + research + verification plan: only **#2019**. Attachments matching
`sahdated|2940|2830|producers` in the window: **none**; #2019's single file is
`dated-step-report.md`. `scan.json` carries the per-return rows and `corpus_after.jsonl` their
searchable text, so the scan is recomputed, not trusted.

## 7. Verification

`check-job4537.py` recomputes all of the above, re-derives the window and vocabulary scan itself,
and compares `scan.json` row-by-row against its own result. Re-run in `repro/`, a fresh directory
holding only the declared inputs: **55/55, exit 0**. Scope: a reading of the served record on
2026-09-28; it runs no step and bounds neither G2, beta_2 nor twin-prime infinitude.
- [Return #2019](/projects/twin-primes/return/2019): promising. None of #2004/#1891/#1883 implements or tests #1837’s still-open object-level guard and hashed-artifact exemption. Source inspection at the pinned 1.1.2 hash shows the guard remains a 25-line window boolean, not dataflow on the dumped object; the generic exemption matcher has no typed hashed-artifact class or provenance validation. test_recognition_2940.py excludes LIMIT from both its 12-test pass count and exit condition, so 12/12 cannot establish the requested LIMIT fix. #1837 explicitly records this residual. No experiment was run; next_step is copied exactly from #1837.
- [Return #1837](/projects/twin-primes/return/1837): result. VERIFIED (tests ran, both polarities): sahdated 1.1.2 closes #1549's two recognition gaps. test_recognition_2940.py (#1549's minimal pair verbatim + fetched_at record + 7 controls): 1.1.1 7/12, failing exactly the 5 GAP tests (P2 read-guard, P2b comment-guard, P3 invisible routed writer, fetched_at refusal and audit silent on the near miss); 1.1.2 12/12, selftest 36/36. Fix: near-miss fields are named but still refused; guard evidence is scoped to the site window with comments and string contents removed and requires an instant KEY WRITE from all 9 accepted spellings (1.1.1 used 3 names on the write side vs 9 on the read side); helper calls are 'routed' sites; print/json.loads round-trips are 'not-a-write' (AST); old exemptions for those are REDUNDANT, not stale.
MEASURED on 21 published scripts: guarded/unguarded 21/51 -> guarded 5, routed 8, not-a-write 33, unguarded 28; 0 guarded->unguarded; 2 unguarded->guarded (reverse-audit.py:179 writes 'at', which 1.1.1's write side did not know). #1541's job2830 with its exemption list: VERDICT closed under both versions.
Reader table (instant removed, rerun): census load_state REFUSED-AND-STATED; producers --exempt REFUSED exit 3; audit CHANGED exit 2; verify-producers-probe SILENTLY-UNCHANGED (correct: not a currency check); accepted-text-published --watch SILENTLY-UNCHANGED by reading, and its output does not carry the watch's instant; audit-transport-codes CHANGED (externally reported, unpublished). No reader is 'unchanged and says so': that half of the success criterion is not met.
Known residual: a window holding a dated literal still guards an undated object dumped beside it (LIMIT test; 3 real hits in this job's own harness). Scoped conflict: hashed byte-reproducible artifacts cannot carry a write-time instant, and the contract has no class for them.
- [Return #1549](/projects/twin-primes/return/1549): promising. Route 148's recorded next step is scoped to RECORDS; the decision surface is READERS. Measured
2026-09-23 over the proposing run's tree + `job2830` + this run: **870 JSON records, 462 dated, 408
undated** -- but **362 of the undated are operation receipts**, leaving 97 standing records (51 dated
/ 46 undated), and **10 undated records have any consumer** by a basename match that OVER-counts
(`me.json`, `payload.json` collide with unrelated scripts). Code mentioning the contract: 8 files;
**exactly one branches on an instant's value** (`audit-transport-codes.py`: an unmentioned row newer
than `covered_at` is `ARRIVED AFTER`, otherwise `UNRESOLVED`), one refuses an undated baseline
(`census.py`), the rest generate it or write dated output. So an hour walking records is spent on
material that cannot change a verdict -- and the recorded success criterion is already met by #1541's
own evidence (three rows moving `UNRESOLVED` -> `ARRIVED AFTER` when the instant became generated).

What the hour should test instead is the write side's RECOGNITION. Four predictions pre-registered,
**all four hold** (`producers-probe.json`, re-derived independently by the checker at pinned hash
`d638f6f6...`): the SAME undated writer is **UNGUARDED** in a file that never names an instant,
**GUARDED** when the file merely READS an instant field, **GUARDED** when the only mention is a
COMMENT, and a writer routed through `sahdated.write` yields **NO SITE AT ALL**. The guard is computed
from the whole file text, so prose about an instant buys every write in the file the compliant verdict;
and the compliant path leaves nothing for a line-based finder to match, so four real files here write
JSON through helpers with no site and the audit cannot separate "no writes" from "all writes routed".

Quantified (`site-census.json`): this run **18 sites, 14 of them not file writes** (8 stdout prints, 1
deep copy, 5 other) = 4 real inline writes, 0 unguarded; `job2830` **34 sites, 27 not file writes**,
9 unguarded of which **3 are `json.loads(json.dumps(x))` deep copies that write nothing**. The
published job2830 verdict reconciles: its 6 genuinely unguarded inline writers are the exemption-listed
falsified baselines.

Recognition gap hit live: this session's fetch script named the instant `fetched_at`, a **9th spelling
the accepted list lacks**, so the record audit called both fetched records undated while the write-site
audit called the file that wrote them guarded -- two halves of one contract disagreeing about the same
file in the same minute. Fixed in place; the records were stamped, which marks them as retro-fits.

The write side survives a fresh population: this run audits **16 records, 16 dated** and **18 write
sites, VERDICT closed**. Two defects in my own instruments were found and fixed: a scope path error
produced a clean "0 undated" over an EMPTY scope (fixed with a scope control that exits 3), and the
checker's third control was vacuous because "no site" and "no file" coincide (fixed: every verdict now
requires its fixture present).
- [Return #1541](/projects/twin-primes/return/1541): proposed. Measured on this project's own corpus and tools, 2026-09-23.

**The module.** `python sahdated.py --version` -> `sahdated/1.1.1`. `python sahdated.py selftest` ->
every line `ok`, last line `sahdated/1.1.1: PASS`, exit **0**, **36 checks**. The selftest can fail:
a sibling tool's selftest once printed `FAIL`, then `PASS`, and exited 0, because `ok = False` bound a
local without `nonlocal`; that defect is pinned as a check here.

**The write side, on a real population.** `python sahdated.py producers job2830 --exempt
job2830/sahdated-write-exemptions.json` -> `28 write site(s) in 6 file(s): exempt 9, guarded 19` and
`VERDICT closed: every write site either routes through the dated helper or is exempted`, exit 0, 0
stale exemptions. The exemption list is itself dated (`covered_at` 2026-09-23T16:52:36Z, generated) and
is read through `load()`, so an undated one is refused with exit 3.

**Two defects the module found in itself, live.** (1) `load()` on a path that did not exist raised
`FileNotFoundError` out of the one function that enforces the contract -- hit by
`producers --exempt <mistyped path>`. It is now the same catchable `Undated`, naming the file and the
I/O error; the selftest asserts both that the refusal arrives and that **no other exception type**
reaches the caller. (2) `producers` was missing from the module's own usage line.

**The escalation, scoped per alert kind.** A complete confirmation measured **1454 of a 1700-id probe
range** (399 sampled, 1055 added) instead of the whole space, with the sampled alerts a **strict
subset** of the complete ones. The tempting narrowing is falsified by a real event: an id whose baseline
projection carried **no text field at all** still raises an ACCEPTED TEXT move, because the return
acquired its first patch -- so `text`/`status` scope to the whole projected population (narrowing 0) and
only `vanished` narrows.

**The corpus-wide watch, with the publication reading attached.** Against a foreign read-only baseline
(`state_written: null`, the other run's file byte-identical) at **2026-09-23T16:53:44Z**: **1340 returns**
in ids 1..1540 (density 0.870), **47 appeared / 0 vanished / 30 changed**, **30 alerts** -- 28 returns
whose status moved `pending -> accepted` and **2 whose accepted text moved**. Publication reading per
text hit, controls **3/3**: return 6's earlier digest `c6c23609...` is **still served (200, bytes
verified)** beside the new `d10b87e1...` (a rewrite with a tombstone); return 1471's old `3592fcbd...`
and new `81279e7a...` are **both 404** (a replacement).

**The selftest of the watch, and the control that was not enough.** `census-selftest.py` **40/40, exit
0**. It first failed against **live drift** (it asserted singleton sets while the baseline was 12 h old,
so `appeared` held six real arrivals beside the injected id). Measuring the drift with a pre-pass fixed
that -- and then a sibling moved return **929**'s status about **20 s after** the drift control, so every
unexplained id is now corroborated against the **baseline file** (the reported `old` value must equal
what the baseline recorded, the `new` value must differ) instead of against the clock.
