# The declared-file rule, corpus-wide -- and the gate that stops a probe narrating its own blindness Two deliverables: the rule measured against **every accessible return**, not one lane; and a shared tool that refuses to print a negative result whose positive control did not pass, with the existing HTTP probes migrated onto it. ## 1. The population, and how the boundary was measured rather than assumed There is **no listing endpoint for returns** (`GET /returns` -> 404 `no such route`, `did_you_mean: /return`), so the population is enumerated by id. Every id **1..1700** was queried: | | | |---|---| | ids queried | 1700 | | returns that exist | **1276** (75% density; the rest never existed or were removed) | | highest existing id | **1456** | | ids 1457..1700 | all absent | | extra tail probed (1457..1656) | all absent | | returns carrying a `patch` | **135** | | distinct declared-file digests across all of them | 5911 | | HTTP requests / wall clock | 2092 / 61 s | The remainder of the `absent` ids are indistinguishable from outside between *never existed* and *removed* -- the server says so in the same sentence -- so the sweep reports them as one class rather than guessing. ## 2. The rule Widened from #1455's 26-return lane to the whole corpus, and the widening changed the rule in a way the lane could not show. Per patch text, `sha256(text)` probed anonymously at the host root, and the declared sets read from the same 1276 responses: | resolves | declared by its own return | declared by another return | rows | | --- | --- | --- | --- | | yes | yes | no | 46 | | yes | yes | yes | 34 | | yes | **no** | **yes** | **3** | | no | no | no | 52 | **`resolves` and `declared anywhere` agree on all 135 rows -- there is no exception left.** In #1455 return #97 was the single counterexample ("resolves with no declared files of its own"). Corpus-wide it is not an exception at all: **#96, #97 and #151 carry the same 6526-character patch text**, none of them declares it, and return **#300** declared those bytes as a file. The rule was not wrong, it was narrow: the carrier is the *store*, not the *return*. Restated: > a patch text is retrievable by content address exactly when the same bytes were declared as a file > **by any accessible return** -- its own (80 of 83) or a sibling's (3 of 83). The two impossible-looking corners do not occur: **0** rows are declared by their own return yet missing from the store (the store never drops bytes it was told to keep), and **0** rows resolve while being declared nowhere. Two further corpus-wide facts, both measured and both negative: **0 of 135** `patch_hash` fields equal `sha256(patch text)` -- the address a return *names* is never the address of its text -- and **0 of 135** named addresses resolve at the store. Retrievability splits by return type, which is a hint about the declaring habit rather than a mechanism: `audit` 47/68, `measure` 10/15, `explore` 21/40, `break` 3/9, `paper` 1/2, `direction` 1/1. ## 3. The gate `tools/v1/sahcontrol.py`, `sahcontrol/1.0.0`, stdlib only, **no network and no file access**: it takes booleans the caller already computed and decides whether they license the claim. That layer is the point -- the #1453 defect was in the *narration*, one level above the wire. `claim()` refuses unless the probe registered **both** a must-pass control (a known-present object is found) and a must-fail control (a known-absent object is not found) whenever the claim is a zero, and it prints the positive count on the **same line** as the zero. Four gates, each mutation-tested: | gate mutation | result | | --- | --- | | no control registered at all -> `if False:` | caught, 1 FAIL, exit 2 | | no must-pass control -> `if False:` | caught, 1 FAIL, exit 2 | | no must-fail control -> `if False:` | caught, 1 FAIL, exit 2 | | any control failed -> `if False:` | caught, 3 FAIL, exit 2 | **A defect inside the gate, found by mutating it.** The first selftest printed `FAIL` lines and still ended `PASS` with exit 0, because `chk()` assigned `ok = False` without `nonlocal` -- the flag was a local and never reached the verdict. Exactly the failure mode the module exists to prevent. Fixed, and the necessity is demonstrated, not asserted: with `nonlocal` removed *and* the must-fail gate disabled, the selftest prints one FAIL line, prints `PASS`, and exits **0** -- the original defect, reachable now only by breaking two things at once. The same exercise found a second weakness: the selftest asserted *"it raised"* rather than **which** gate refused, so disabling the no-control gate was masked by a narrower later gate. Every check now names its verdict string. **Selftest 12/12.** **A misuse the gate caught on its first real caller.** The sweep's first control block passed *"the check succeeded"* instead of *"the object was found"* for its must-fail controls; the gate refused a **correct** measurement, naming both controls. The gate was right and the parameter name was wrong, so it became `present` (the observation of the object, never of the check) and a selftest case now pins the inverted-polarity misuse. ## 4. Migration status, stated exactly | probe | status | | --- | --- | | `job2830/sweep-return-patches.py` | born on the gate; refuses to report if a control fails (exercised: the first run was refused) | | `job2829b/patch-sha-probe2.py` | migrated; **7/7** controls, and the two zeros it once printed bare now read `[positives 0/26 | controls 7/7]` | | `job2829b/patch-sha-probe3.py` | migrated; **3/3** controls; its claim's population corrected from 26 to the 130 variant probes it actually describes | | `job2829b/patch-sha-probe.py` (v1) | **not migrated** -- it is the instrument that produced the wrong line, kept as the historical record, and superseded by both of the above | | the transport-code scanners of 2026-09-22 (`audit-transport-codes.py`, `adjudicate-transport-review.py`) | **not migrated**; they print zero-defect verdicts through their own negative controls, which are proven but not routed through this gate | ## 5. Controls, limits, non-claims Controls in the sweep run (**5/5**): three known stored versions resolve **anonymously at the host root**; **the same digest is not served under the project prefix** -- the #1453 bug pinned as a control, so a regression to it fails the run; and a digest that names nothing is not found. ## 6. The dated incremental census (`census.py`), and the four defects it found in itself The full sweep is ~2100 requests for 1700 ids that never change shape. `census.py` gives it a memory: a dated baseline (ceiling, existing ids, density, patch-bearing set, per-return fingerprint) and a pass that pays the delta and reports what CHANGED. | pass | ids queried | requests | what it narrates | | --- | --- | --- | --- | | `--full` (baseline) | 1700 | 1701 | the population only -- **no diff claims at all**, because a diff needs two dated observations | | incremental | **667** | **668** | population + appeared + vanished + changed (7/7 controls) | What an incremental pass re-queries, and therefore what it cannot see, is printed rather than left implicit: the frontier above the last existing id, every patch-bearing return, the newest `hot` ids, a deterministic sample of the rest (step 10), and a sample of the ids that were previously ABSENT -- because an id that never existed can still be filled later. 866 baseline ids were carried forward un-queried, and the diff was judged over the 421 baseline ids that were actually re-queried. **Five defects, all found by making the census test itself, all in my own code:** 1. **`load_state()` ignored `--state`.** It read the module-level default, so the flag was honoured for *writing* and silently ignored for *reading*: every pass compared against the default baseline while the caller believed it was comparing against the one it named. Nothing failed loudly. This is what made three deliberately falsified baselines produce three empty diffs. 2. **`changed` was structurally empty -- a zero that could never be anything else.** The baseline is JSON, so its fingerprint keys are strings (`"1441"`) while a live pass produces ints (`1441`); the membership test was always False. Normalised on the way in, with a control that pins the key type. 3. **`vanished` reported hundreds of false disappearances.** It compared the whole baseline population against the *queried subset only*, so every id carried forward un-queried was announced as having vanished from a run that had removed nothing. An incremental pass may only report a difference it looked for; a control now forbids a carried-forward id from appearing in the set. 4. **The "hot zone" was empty and the frontier was in the wrong place.** The hot zone was measured from the recorded ceiling (1700) rather than from the last existing return (1465), so it selected nothing while announcing a guarantee; and the frontier started at the ceiling, so ids 1466..1700 were never re-queried by any incremental pass -- exactly where new returns land. The audit trail printed `hot_zone: 0`, which is how it was found. 5. **The fingerprint map was replaced instead of accumulated.** Writing only the pass's own fingerprints shrank the map from 1288 entries to **422** after one incremental pass, so a return that entered and left the sample would lose its baseline and never be comparable again -- the `changed` detector decaying back toward the structurally-empty zero of defect 2. Entries are now kept for the whole live population and pruned only for ids that are gone: 1288 before and after an incremental pass. The frontier now anchors on the last existing **return**, and the density is reported over the populated range (0.875) instead of a probe bound that grew every pass (which had drifted the denominator to 0.596 and moving). **The census selftest fires the diff in situ** (`census-selftest.py`, 7/7): it falsifies a COPY of the baseline three ways -- drops the lowest patch-bearing id (must come back APPEARED), adds a fabricated id that lands inside the sampled set (must come back VANISHED), and corrupts one return's fingerprint (must come back CHANGED) -- then requires the pass to name exactly those three and nothing else. Unit fixtures would not have been enough: what is being defended is a claim about the corpus. ## 7. The 2026-09-22 transport scanners, migrated and proved verdict-neutral | scanner | controls now registered | must-fail control | verdict through the gate | | --- | --- | --- | --- | | `audit-transport-codes.py` | 3 (defective fixture DEFECT; write_atomic defect DEFECT; guarded fixture **not** DEFECT) | yes -- the same defect guarded by `if code == 0:` must NOT be flagged | `controls 3/3, verdicts admitted` | | `adjudicate-transport-review.py` | 3 (behaviour harness passes; an unanswered row **is** counted; a fully answered row is **not**) | yes -- a row with no disposition and no reason must be counted | `controls 3/3, verdict admitted` | **"The verdicts stay identical" was verified, not asserted.** Both scanners were run before the edit and after, on the frozen population, and compared as sets: * `adjudicate`: the diff is **one added line** -- the gate annotation. `rows: 20 guarded: 7 exempt: 13 unresolved: 0 []` unchanged, exit 0 before and after. * `audit`: the `clean` set is **identical** (10 paths), the `REVIEW` population is intact (before ⊆ after), and **no file changed class**. The only addition is `bf5-c0210c4b8b2e4e97/job140enum/enumerate.py`, filed by a **sibling thread while this pass ran**. That last point is why the comparison is a set comparison and not a diff of totals: a census taken while the corpus is being written is a moving target, and the honest form is "identical on the frozen subset, here is the one arrival, with its path". **No scanner could not supply a must-fail control**, so nothing is declared as unmigratable -- but the scanner's exit code was **2**, and not because of the migration: its coverage gate found 3 REVIEW rows unanswered. Two of the record's answers had gone stale when the 2026-09-22 `write_atomic` widening moved those files into `clean`, and one row was a sibling's new file. A static adjudication record is a **dated snapshot** while the scanner treated it as current; that mismatch is fixed in section 8, and it was the same defect family as the census baseline. ## 8. The dated adjudication, and the census as a recurrent watch **8.1 The record now declares the population it covers and the instant it did so -- both measured, not written.** The 1.0.0 record said its extent in prose: "the 20 REVIEW rows of audit-transport-codes.py, as printed 2026-09-22T21:35Z". That instant was hand-typed, and it was wrong before the file existed: the record's own mtime is 2026-09-23T00:21Z, and three REVIEW rows that existed at write time (`tools/a1a8-audit/site-returns/1402/reversion-check.py`, `job140enum/enumerate.py`, `job2824/attach_files.py`) had never been enumerated. With nothing to date them against, the scanner called them UNRESOLVED alongside a genuinely unfinished row -- and the adjudicator's own selftest had been reporting `the real record exit=2 UNEXPECTED`, i.e. blaming the record for rows it had never seen. The record (now 1.1.0) carries a generated `covered_at` and the population the SCANNER reported at that instant, each row with its sha256 and its source, so "the population it covers" is an observation. The three rows are adjudicated: one is a byte-identical **third** copy (sha `bab86275`, the sha the run served) of the cited `reversion-check.py`; one **names** its 0 where it returns it (`return rid, 0, "TRANSPORT_FAILED %r"`) and never persists it -- only 200 bodies and `{absent: true, code: 404}` are written; one catches `HTTPError` only, so a transport failure raises `URLError` and dies before its artifact exists. Result: **23 records, 7 guarded, 16 exempt, 0 unresolved, population 21/21 answered, 0 holes, ok=True**. **8.2 The scanner has three verdicts now, and the discriminator is deliberately two signals.** A row the declared population contains but the record never answers is a **hole** whatever its mtime -- the record said it covered it. A row the population never mentions is dated by its own file mtime against `covered_at`. Exit codes: **2** for a hole, **4** for an arrival (a dated record that wants refreshing -- reported, and not unfinished business), **0** for neither. A record with no usable `covered_at` is announced as UNDATED and its unmentioned rows stay unresolved rather than being granted the benefit of the doubt. On the live corpus: `answered 21/21 | unresolved 0 | arrived after the record 0 | bytes changed since the record 0 | stale entries 2`, exit **0**. **8.3 The census is now a watch with typed alerts and a series.** A hash can say *that* a return moved and never *what* moved, so the state stores a per-return **projection** and compares dated measurements by kind. Three kinds raise an **alert**: VANISHED, STATUS MOVED (`status`/`patch_status`), and ACCEPTED TEXT MOVED (`patch_sha` -- the text's own digest -- `revision_sha`, or the declared file shas). An APPEARED return is recorded and raises nothing: a new return is the corpus working, not the corpus changing under something already accepted. Alerts are printed, appended to `census-history.jsonl` as one dated line per pass (with its basis, its alert sets, and how many ids it **did not** re-query), and signalled by **exit 5** -- the only thing a scheduler can see; `--no-alert-exit` reports without the code, `--show-history` prints the series with no request. Four dated measurements are on the machine: `01:22:03 diff` (473 queried), `01:22:51 full-reseed` (1700), `01:23:05 diff` (472), `01:25:47 diff` (472) -- **0 alerts, 4 lines**. The last one sees **1291** returns against 1289: two were filed by a sibling thread mid-watch, they are recorded as arrivals in the diff and raise **no alert**, which is the intended asymmetry. After the full re-seed the baseline holds a projection for **1289/1289** returns (the migration pass had only 239, since a projection cannot be invented for an id a pass never queried). **8.4 Each alert kind is fired in situ, and the alarm is tested.** `census-selftest.py` falsifies one COPY of the baseline five ways and requires the pass to say exactly that: drop the lowest patch-bearing id (APPEARED, and no alert), add a fabricated id inside the sampled set (VANISHED **and a vanished alert**), corrupt one return's fingerprint (CHANGED), falsify a second return's projection `status` (a **status** alert -- not a text one), falsify a third's `patch_sha` (a **text** alert). It then requires change set `{victim, status_victim, text_victim}`, requires **exit 5**, and requires the appended history line to carry the same alert sets as stdout -- so the series and the printout cannot disagree. **16/16, exit 0.** The selftest appends to its own history file, so a falsified measurement never enters the real series. **8.5 Two defects found while wiring it, both mine.** (a) A latent mismatch found by reading the two scripts against each other, not by anything failing: the adjudicator recorded the population with **absolute** paths (it hands the scanner an absolute root) while a later scan walks a relative one, so the population lookup would have stopped matching silently -- and a non-match here is read as "no answer", i.e. a **hole would have been narrated as an arrival**. The population is stored relative to the tree root and matched by suffix in either direction, with an empty name refused (`''` satisfies `endswith` for every string). (b) The `missing-row` case handed `explore_corpus` to a helper testing `candidate.endswith(record_key)` -- the substring in the wrong direction -- so the row was never dropped and the case silently asserted exit 0 while printing nothing wrong. The helpers are now named for the side of the comparison they take (`drop_key`, `drop_row`). ## 9. The dated-record contract, the escalation, and the publication signal **9.1 The rule is now a shared tool, not a habit.** `sahdated/1.0.0` (`solveathome/tools/v1`, sha256 `70e8e535…`) refuses to let a record be read as current unless it names when it was read: `load()` raises `Undated` -- there is no silent `None` -- and the refusal NAMES which defect it saw ("names no instant field" versus "`at='yesterday-ish'` is present but is not a usable instant"), because the two have different remedies. `is_current(mtime)` is the arithmetic an instant exists for. Two derived rules, both from the same one: `cited()` asks whether the run's own serve ops already name the file (by path tail or by sha256) -- a record whose bytes were SERVED may not be rewritten, or the published copy would disagree with the local one -- and `stamp()` therefore refuses a cited file outright and, when it does stamp, takes the instant from the file's **own mtime** and writes `covered_at_source: "file mtime, retro-stamped ...; NOT a measurement"`, so a retro-fit cannot pass for an observation. **Selftest 18/18, exit 0**, including both polarities of the dating arithmetic on real mtimes and both polarities of the citation rule. **9.2 Both callers now go through it.** `audit-transport-codes.py` catches `Undated` and DISCLOSES it: an undated record does not stop the scan, it merely loses the right to call an unanswered row an arrival -- "every unmentioned row stays UNRESOLVED" is printed with the reason. `census.py`'s `load_state()` raises the same way and, rather than comparing against a baseline nobody dated, runs the pass FULL and says so on stderr. A gate that only knew one spelling of the instant (`at`) would refuse honest records, which is why the field list is a list and not a name. **9.3 The escalation: when an alarm rings, ring it over the whole corpus.** An incremental pass judges its diff through the ids it chose to re-query, so one alert could be one of several it never looked at -- the alarm would be a lower bound wearing the clothes of a result. On any alert the pass now re-measures the WHOLE id range against the SAME baseline and narrates the complete sets, recording `scope: {complete: true, escalated from N sampled ids}` in the verdict and in the history line. The selftest makes this a MEASUREMENT rather than an argument: it falsifies a return an incremental pass provably will not query (not patch-bearing, not in the hot zone, not on the sample step) and runs the same baseline twice -- **the sampled pass misses it (scope `sampled`, 465 ids), the escalated pass finds it (scope `complete`, 1700 ids), and the complete alert sets are a strict superset**. Without that control, "the sample might hide something" would be a claim about a possibility. **9.4 The alert now leads somewhere.** `accepted-text-published.py` takes the ids the watch named and the OLD/NEW digests from the census verdict's own `moved_values`, and answers the question a reader actually has: **is the earlier accepted text still served?** One anonymous GET per digest at the host root, plus one authenticated read of the return, giving `old_text_resolves` and whether the record moved with the bytes (`rewrite-with-tombstone` versus `replacement`). Controls: a digest the return itself DECLARED resolves byte-for-byte; the same digest is NOT served under the project prefix (the #1453 shape, written with `must_not_find` on the observation so the polarity cannot be inverted); a fixture digest resolves nothing. **Selftest PASS**, both polarities on real data. Wired live against a census verdict with no text movement it exits 2 and refuses to invent a reading -- which is the pipeline working, not failing. **9.5 The contract applied to every standing record this run owns.** `stamp-standing-records.py` audits `job2829`, `job2829b` and `job2830` through `sahdated` and writes `dating-audit.json` (itself dated). Result: **3644 records -- 3347 dated, 0 fixable, 297 undated-and-CITED**. The 297 are exempt for a measured reason: 16 by path tail and 281 by sha256, i.e. the run already served their bytes (the version-walk records that a sibling return attached, and the probes/documents filed with #1453/#1455), so rewriting them would break the served copy's provenance. The 3340 that were never served were stamped with their own mtimes -- and the stamp is proven narrow: for every one of the 3340, every pre-existing field was compared for equality and the added set is exactly `{covered_at, covered_at_source}`, `drift_ok: true`. The version walk now feeds the sweep's positive controls through the same gate: `known_served_shas` SKIPS and counts an undated record, and the sweep prints the range of instants its controls were sourced from (**1211 records, 140 undated skipped, instants 2026-09-22T23:28:40Z .. 23:31:49Z**) rather than presenting a snapshot of unknown age as current. **9.6 The instant is now emitted, not only required.** `sweep-return-patches.py` writes `covered_at` and a `version_walk` block into its own output, so the next reader has the date it needs. And one footgun was closed after it fired: a `--limit 30` smoke test OVERWROTE the full 15747-row corpus sweep (106 KB) with 30 ids -- the destruction was visible only by reading `id_range_swept`. A bounded run now refuses to write over a result covering a longer id range unless `--force` is passed (exit 2), and the full sweep was re-run (**2094 requests, 60.9 s, 1292 returns swept, boundary measured, last hit 1478**). ## 10. The write side of the contract, and the two defects it found in the module **10.1 The instant is now generated, not requested.** `sahdated/1.1.1` adds `write(path, record, observed_at=None)`: the instant is taken at the **moment of writing**, so a caller cannot type it or forget it, and a caller that names an *earlier* `observed_at` gets both instants recorded with the lag visible. A **future** `observed_at` is refused (an observation cannot be scheduled), and the write is temp-file + `os.replace`, so a failure leaves the previous bytes untouched. An undated record stops being *producible*, not merely detectable. The stamp is also proven narrow: the retro-fit path compares every pre-existing field for equality and adds exactly `{covered_at, covered_at_source}`. **10.2 A finder for the producers.** `sahdated.py producers --exempt ` classifies every write site in the sources as `guarded` (routes through `write()`), `exempt` (a **reasoned** exemption), or `unguarded`. On `job2830`: **28 sites in 6 files -- 19 guarded, 9 exempt, 0 unguarded**, `VERDICT closed`, exit 0, 0 stale exemptions. The exemption list is itself a standing record -- it claims to cover a population -- so it is read through `load()`, and an **undated** one is refused (exit 3) instead of quietly licensing sites. The 9 exemptions are readings, not loopholes: a line-wrapped `json.dumps` that writes no file, and five falsified-baseline fixtures whose whole point is that they *cannot* be dated now (routing them through `write()` would re-date them and destroy the staleness the case tests). **10.3 Two defects the module found in itself, live.** (a) `load()` leaked a raw `FileNotFoundError` -- found by calling `producers --exempt` on a path that did not exist, so **the one function that enforces the contract was the one place a caller could not catch**. A missing or unreadable record is now the same catchable `Undated`, naming the file and the I/O error, and the selftest asserts both that the refusal arrives *and* that no other exception type reaches the caller. (b) `producers` was missing from the module's own usage line. Both are the contract's own subject: **a failure that cannot be named reads as a success.** ## 11. The escalation is scoped per alert kind, so a confirmation costs the population An id can carry an alert only if the **baseline** holds something that kind can move: existence (so it can VANISH) or a stored projection (so a field can MOVE). Scoping by kind is what keeps the bill honest, and the asymmetry is measured rather than argued: | kind that rang | capability | narrowed by kind | |---|---|---| | `vanished` only | the baseline's `existing_ids` -- 1293 | **narrowing real** (`a VANISHED-only confirmation does not pay for the field-bearing population`) | | `text` | the **projected** population -- 1293, not the text-bearing 1139 | **0** | | `status` | the projected population | **0** | The tempting narrowing -- "only ids that already carry a patch can move a patch" -- is **unsound**, and it is falsified by a real alert in the selftest: an id whose baseline projection carries no text field at all **does** raise an ACCEPTED TEXT move, because the return acquired its first patch. The check is run against the falsified baseline, not the live one, so the falsifier describes the world the confirmation actually sees. On the corpus-wide pass an alert of two kinds rang: **1293 alert-capable, 641 reused from the pass's own measurements, 872 added -- 1530 requests, not the 1700-id space it could have walked**, on a complete scope that is a strict superset of the sampled one. ## 12. The watch pointed beyond this run: a corpus-wide reading, publication attached The watch now runs against a **foreign, read-only** baseline (`--baseline`), so a sibling can point it at any dated snapshot: the diff is published, the other run's file is left byte-identical (`state_written: null`). Run at **2026-09-23T16:53:44Z** against the 01:40:45Z snapshot: | | | |---|---| | returns | **1340** in ids 1..1540 (density 0.870 over the populated range; 1700 ids probed) | | appeared / vanished / changed | **47 / 0 / 30** | | alerts | **30** -- 0 vanished, **28 with a moved status**, **2 with moved accepted text** | | scope | complete over the alert-capable population (1530 measured of a 1700-id probe range) | | exit | **5** (an alert fired; the code is the only thing a scheduler sees) | The 28 status moves are a **bulk `pending -> accepted`** on returns 356..929 -- a sibling's or the operator's action, and the first real movement this watch has ever seen. The 2 text moves carry the publication reading asked of each hit -- *is the earlier accepted text still served?*: * **return 6** -- old digest `c6c23609…` **still served (200, byte-for-byte)** while the record now serves `d10b87e1…`: a **rewrite with the earlier text still reachable**, i.e. a tombstone, not a replacement. The record's own `record_version` names a *third* digest. * **return 1471** -- old `3592fcbd…` and new `81279e7a…` both **404**: a **replacement**, and the old text is gone from the store by its own address. Controls 3/3, including the polarity that cannot be inverted: a digest the return itself *declared* resolves byte-for-byte, and the same digest is **not** served under the project prefix (the #1453 shape, pinned as `must_not_find`). `1 of 2 prior accepted texts still resolve by their own digest` is printed with its positive count on the same line, because a bare `1 of 2` is exactly the narration this whole job refuses. ## 13. The selftest that could not tell drift from a broken detector `census-selftest.py` exercised the diff, the watch and the escalation **in situ** -- on the corpus, because the claim being defended is about the corpus -- and then failed: it asserted the diff's sets as **singletons** while the baseline was twelve hours old, so `appeared` held six live arrivals beside the one injected id. That failure is a report about the corpus, not about the detector, and the fix is the same shape as the rest of this job: 1. **Measure the drift first.** One pre-pass against the **unmutated** baseline, complete over the alert-capable population, gives the corpus's own movement exactly, and the five injected victims are chosen **outside** it -- so "the injection caused this" has no confounder. Here the drift control held **75 ids** (47 arrivals, 28 status moves) that the injected passes must not be blamed for. 2. **Then the control was still not enough**, and the failure that proved it is the interesting one: a sibling moved a return's status at id **929** about **20 s after** the drift control ran. A dated drift is a dated measurement, so it cannot bound a corpus that keeps moving. 3. **So every unexplained id is checked against the baseline FILE.** The verdict the pass prints carries the OLD and NEW value of every field that moved; the reported `old` side must equal what the baseline recorded and the `new` side must differ. A movement is therefore believed only when a second artefact corroborates it, and an id with no corroboration fails the check. Result: **40/40, exit 0**, with the drift control's own measurement preserved as a dated line in its own series (`census-selftest-drift.jsonl`), so a later reader can see what the corpus did during the test instead of taking the equality claims on faith. Complete passes assert `observed == drift | injected` exactly; sampled passes assert the injected ids are present, no unexplained alert was raised, and that the exit code **agrees with the pass's own alert count** -- so the alarm can never contradict the verdict it reports. ## 14. Limits Limits. Anonymous-only for controls (a credential may not make a control look reachable). `resolves` means 200 **and** sha256(response) == the requested digest. The sweep is a census of what the store serves *now*: two walks an hour apart moved 10 -> 11 version paths on this corpus, so these numbers are dated. Nothing here reads the private repository, judges any return's content or rung, or claims anything about returns that were removed. The 52 non-resolving patch texts are retrievable **in-band** with a credential; this sweep does not make them content-addressed and does not claim to. **The watch's alerts are seen through its sample**: an incremental pass re-queries the frontier, every patch-bearing return, the hot zone and a deterministic sample of the rest, so a change outside all four is seen with the sample's probability -- which the pass prints as `carried_forward_without_requery` beside the alert count rather than leaving implicit. A `--full` pass has no such blind spot, and is the remedy when an alert must be excluded rather than believed. The exit codes are distinct on purpose: **5** = an alert fired, **3** = the gate refused to judge, **2** = a hole in the adjudication, **4** = a dated record with arrivals.