# Protocol 023 revision 2: does the plaids pilot's departure from a relay hold, on average, over six fresh network instances?

**Declared 2026-11-11T00:55:21Z, before any revision 2 run.** Its SHA-256 is recorded in HANDOFF, and everything under "What is frozen" is frozen before any revision 2 run.

Status: DECLARED 2026-11-11T00:55:21Z.          Date: 2026-11-08

## Changes from protocol 023
Protocol 023 was declared on 7 November 2026 and ended NOT INTERPRETABLE at its early stop after its first run (History). This revision keeps 023's question, design, measures, decision rule, intervals, sizing method, calibration gates, blind checks, fixed texts (one name aside) and Mac run path. It changes what the owner's decision of 8 November needs, what follows from seed 7 being built, and what 023's ending taught. Each change, with the section that states it:
1. **Instances.** Slots pynn_seed 8 to 13 and reserve 14 (023: slots 7 to 12, reserves 13 and 14). Seed 7 is built and is excluded with 5 and 6. The sequence files for 8 to 14 are 023's declared files, byte for byte (Instances; Stimulus sequence).
2. **The paired rule,** the owner's decision of 8 November: every instance runs twice with identical inputs and is analysed only when both runs agree on every spike train; a third and, if needed, a fourth run break a disagreement. A new frozen comparison tool, `controller/compare_runs_023.py`, decides agreement, and each export must carry its own attempt's run name (Integrity checks, "The paired rule").
3. **The early stop** fires when two runs of one instance agree and the server check refuses both with the same refusal kinds. A refusal of a run that disagrees with its instance's other runs is a one-off fault, recorded and never a stop (023: the first refusal stopped the queue). A new stop with no reading: the server check passes one and refuses the other of two agreeing runs, or refuses both with different refusal kinds (Integrity checks, "The early stop").
4. **Attempts and failures.** Run names m23-sK-intact-a1 to -a9; at most four completed runs per seed; two counted failures make a seed invalid, as 023's "failed twice", and an attempt that exits 0 without its export is one; a stop at the disk floor is no longer counted as a failed attempt, and the queue waits for free disk, and for another program's heavy job to end, before it pauses (Integrity checks, "Attempts"; The Mac queue).
5. **One reserve, and a stop as soon as six valid instances cannot be reached** (023 ran every slot before it judged the reserves) (Integrity checks, "The replacement rule").
6. **The fault rate,** a reported secondary measure (S15), never a decision input (Secondary measures).
7. **The cap and its cost,** sized by exact enumeration at the measured one-off fault rate (Paired runs: sizing at the measured fault rate).
8. **Disk: a lossless archive.** After each attempt is checked, its Mozaik result folder is packed into a verified compressed archive with a per-file SHA-256 list, and removed only after a record of the verified archive is written; every export, receipt and record is kept (The Mac queue, "Disk").
9. **Fetch** copies every receipt and only the export to analyse of each instance, and records the run folder's SHA-256 of every completed run's export (The Mac queue, "Fetch").
10. **The NOT INTERPRETABLE text** names "Protocol 023 revision 2"; the other fixed texts are 023's (Outcome texts).
11. **The calibration reruns** on the final code, because `confirm_023.py` and the slots' orders and draws change; its gates stay (The calibration).
12. **The seed search** adds one record: the Mac's run folders since 023's last record, for seeds 8 to 14 (Instances, "Never built").
13. **A rehearsal before the declaration,** 023's first lesson: one full pair on built seed 6 with slot 8's declared sequence, through the queue, the server check, the comparison, the archive, the fetch and the local check's content checks; the steps it cannot reach before the declaration are listed with what covers them (Rehearsal before the declaration).
14. **The fence** is restated for this revision's data, 023's second lesson (Fences).
15. **Records that survive a crash, and checks that repeat themselves.** Every write-once record of the checker, the comparison tool and the archive tool is written to a temporary file, flushed to disk and linked to its name, so a power loss leaves the whole record or none; each blind check computes its verdict twice and writes a record only when the two agree, so a one-off fault inside a check costs a resume, not the protocol; and the analysis computes its results twice and writes them only when both are the same (Integrity checks, "Before any check"; The replacement rule).
16. **Stated limits and risks:** limit 9 on the Mac's one-off faults and what the paired rule catches, 023's third lesson; limit 7 and risks 10, 12, 14 and 18 updated; risks 19 to 22 new.
17. **Names and paths:** the run folder `<home>/felisyn-local/run-023r2`, the working tree `<home>/felisyn-local/p023r2`, this spec's file, attempt-named exports and receipts (`sK-aN`), "before any revision 2 run", and HANDOFF, which means `<home>/felisyn-local/p023r2/HANDOFF-023r2.txt` (History).
18. **The analysis choices** (`analysis-choices-023.txt`) keep 023's text and add a dated revision 2 section, items 30 to 36 (What is frozen, item 5).

The review of 8 November (two readers, one on the rule and its statistics and one on feasibility) changed this draft; each finding and how it was handled is in `work/controller-023/FIX-NOTES-023r2.txt`. The declaration's preparation of 9 November recorded the rehearsal and its result, redid the sizing at the rehearsal's tally of 1 fault in 6, recorded this revision's seed search after the rehearsal, and recorded the owner's answers in place of the draft's open questions; HANDOFF lists each edit with its reason.

## History and sources
- **Protocol 022 revision 2**, the plaids pilot, was declared before its runs (`docs/specs/2026-10-26-protocol-022-plaids-r2.md`, SHA-256 `8f8878fc…`), run on network instance A (intact and plain lesion) and analysed once on 28 October. Outcome: GO by all three measures (`work/controller-022/plaids/results/results.json`, `f02a858e…`).
- **The 28 October draft** (`docs/specs/2026-10-28-protocol-023-confirm-draft.md`, `ec2a638c…`, kept unchanged) came from a design workflow: three surveys, three candidate designs and two judges (`work/controller-023/design-record.json`, `2cb40a34…`). It proposed three instances under an every-instance rule and asked the owner three questions.
- **The choice of design, as recorded.** The draft proposed (a), three instances under an every-instance rule (DRAFT:520, about 11.2 h with its exports), and offered (b), the mean over six fresh instances (DRAFT:521, about 18.9 h with exports). In the conversation on 28 October, when the owner was asked the draft's questions (09:02 UTC), the agent recommended (b): "I recommend the second: its test stays valid whatever the spread turns out to be, and it measures that spread for later protocols." On 29 October the owner wrote: "continue the protocol etc too so we have the neuron model done soon", and picked no option. So (b) was taken (HANDOFF:134): **the mean over six fresh instances** of the pilot's 97-step design, with a t-test over the instance estimates. It keeps the pilot's per-instance design and stimulus code unchanged and is valid whatever the spread between instances; it needs more run time than (a): 12.0 h plus each run's server check at G4's measured speed on the Mac (17.4 h without exports at the pilot's speed, when the choice was made). The declaration makes this choice final, with the others listed under "Choices made for this revision"; a change after it is a new declared revision. The connection exports are dropped to save server time.
- **023's declared text** states that design in full, after the adversarial review of 29 October and the re-checks of 31 October; their findings and how each was handled are in `work/controller-023/FIX-NOTES-023.txt`. Its code, tests and calibration are in `work/controller-023/`; the freeze's manifest will list every file with its SHA-256.
- **The Mac revision, 7 November 2026.** The rented research server is gone: no ping and no SSH since 3 November, and the owner has no access to its account (`docs/specs/2026-11-07-no-server-mac-run.md`). The queue moves to the owner's Mac, and each server-only step is replaced, as the audit of that day laid out (`<home>/felisyn-local/audit-server-dependence.md`). The design, the measures, the rule, the fixed texts, the calibration, the sequences, the analysis code and `run_controller.py` do not change. What the move costs is stated under "Stated limits of the Mac run", and what only the G4 run on the Mac can give is under "Values G4 sets". 023's HANDOFF was the dated, append-only `HANDOFF-023.txt` in the Mac's mirror of that work (`<home>/felisyn-local/p023/`); this revision's is named below.
- **Protocol 023's outcome.** Declared 2026-11-07T20:25:30Z (spec SHA-256 `1e20a4a90a474d2a2f4348f095133a820120f0a4e85dc1095e6b32ec00cffac3`), frozen (manifest `6020fe1b7aaed781f40b90eadd7bb35da4f0de89c7f516ab7b4234a7f8ba1429`) and launched on 8 November 2026 at 00:47:21 UTC in `<home>/felisyn-local/run-023`. Its first run, `m23-s7-intact-a1` (pynn_seed 7, its own sequence), exited 0 after 3,965 s with a peak footprint of 3.186 GiB, and its server check refused it on one kind: the LGN lead-in matched the pilot's reference in 3,599 of 3,600 trains (X_OFF cell 2738). The queue stopped (exit 5). The local check refused the same cell, and the declared analysis wrote NOT INTERPRETABLE (`results.json`, SHA-256 `7836cdb06942563f02e2bc42e909801cae058c8451fddc48f1d7d057d8879bc0`). That outcome is final: this revision does not change, qualify or repeat it. Seeds 8 to 14 were not built.
- **The diagnosis afterwards (exploratory).** `<home>/felisyn-local/diag-023/DIAGNOSIS.md` and `diag-023/rate/README.md`, reported in journal note 24. Measured: exact repeats of s7's inputs (d1 for 5 steps; d5 and rate-r1 at full length) agree with each other on every spike train and pass the lead-in check; against d5, cell 2738 is the only LGN cell of s7 that differs, until 14,344.6 ms. So s7 carried a one-off execution fault of that run on this Mac. Inferred and untested: a 16 KiB memory page that read back as zeros. Full-length runs with a spike-level check: 1 fault in 4 (G4 against the server pilot, s7, d5, rate-r1), with a 95 % interval of about 0.6 % to 81 % (since this revision's rehearsal, 1 in 6: Paired runs). Runs on this Mac are otherwise deterministic: identical inputs gave identical spike trains (d1, d5 and rate-r1; G4 against the server pilot). The diagnosis's skeptic (workflow wf_f0b57d41-0db) found that a rerun only after a lead-in refusal would pass runs from a run path that sometimes corrupts input unseen, because the lead-in check sees about 1 of 6 live input pages per LGN cell and none of the cortex. The diagnosis read 023's data without an exploratory manifest frozen first, which 023's fence required (Fences). Nothing in it is part of 023's outcome, and this revision uses it only as design input where a section cites it.
- **The owner's decision, 8 November 2026,** recorded by its content: the rerun runs every instance twice with identical inputs and analyses an instance only when both runs agree on every spike train; a third and, if needed, a fourth run break a disagreement. The diagnosis and note 24 letter this design "Option B"; the owner answered "A", the letter the agent's own message gave the same design. It is always named by its content. The owner also said that the X post waits for this rerun's result.
- **This revision, 8 November 2026,** is written in `<home>/felisyn-local/p023r2`, a copy of p023's `docs/` and `work/` trees without 023's run records, results and checks; `p023r2/COPY-SOURCE-SHA256.txt` gives every copied file's source SHA-256. 023's running record, `p023/HANDOFF-023.txt`, holds 023's history up to this design; HANDOFF in this spec means `<home>/felisyn-local/p023r2/HANDOFF-023r2.txt`, dated and append-only, which begins where HANDOFF-023.txt ends.
- **Short names:**
  - SPEC: protocol 022's spec above; CON: its frozen contract, `outputs/felisyn-research/protocol-022/contract.json` (`128b5bba…`);
  - PS: `controller/plaid_stats.py`, byte-identical to 022's (`7baf22fb…`); AP: `controller/analyze_plaids.py`, byte-identical to 022's (`aef970d6…`);
  - RES: the pilot's results, above; README: `outputs/felisyn-research/plaids-022/README.md` (`7489bffd…`);
  - DRAFT: the 28 October draft; PANEL: `work/controller-022/plaids/design-panel-r2.json`; DISP: `work/controller-022/plaids/disposition-r2.md`.
  - S023: protocol 023's declared spec, `docs/specs/2026-10-29-protocol-023-confirm.md` (`1e20a4a9…`), kept unchanged beside this one; DIAG: `<home>/felisyn-local/diag-023/DIAGNOSIS.md`; CMP: `diag-023/tools/compare_prefix.py`, the diagnosis's comparison of two exports, with its validation in `diag-023/tools/validate/`.

## Goal
**The question.** Over network instances of the same 2 mm reduction of LSV1M that have never been built, does the intact circuit, on average, combine two superimposed drifting gratings differently from a relay, in the direction instance A's pilot found? It is asked for each of the three measures that triggered the pilot's GO (XOS, Dc and ds), with the same definitions and the same margin of 0.10. A relay is SPEC:17's: the sum of the circuit's own above-blank responses to each grating alone.

**What a confirmation would add.** The pilot's result would no longer rest on one network instance. It would hold for the mean over new cell positions and new wiring on the model's one orientation map. It would still describe the whole circuit, input stage and cortex together (SPEC:22-25), and not the connections.

Neither outcome is a claim about cat visual cortex. Simulation only.

**What revision 2 changes in the question:** nothing. It changes how a run's export is accepted for analysis (the paired rule), because 023 showed that a run on this Mac can carry a one-off fault that a single run's checks see only in part.

## Non-goals
- **No claim about the intracortical connections.** There is no lesion run: the plain lesion is untuned (cross drive +0.625, README:111), and the routing below calls it insufficient for XOS and Dc.
- **No connection exports.** The draft's per-instance export job is dropped to save server time. The conductance follow-up declared in SPEC:235-251 can use only instance A's lists from 022.
- **No test of other orientation maps, plaid layouts or input-noise streams.** Fresh `pynn_seed` instances share all three (Instances).
- **No claim that every instance shows the effect.** The claim is about the mean over instances; the instance values, and for a measure estimable in all six instances the count with the pilot's sign, are reported beside it.
- **No change to protocol 022's outcome, readings or packages.**
- **No decision, executor, wallet or token.**
- **No change to protocol 023's outcome,** which stands as declared: NOT INTERPRETABLE.
- **No diagnosis of the one-off fault.** The paired rule finds a run that disagrees with an exact repeat; it does not find the cause. Reading a disagreeing run beyond what the declared procedure reads is an exploratory reading (Fences).

## What protocol 022 hands on
### The declared sentences
- **SPEC:201:** "What a GO hands on, declared now: the triggering measure exactly as defined here, its conditions, and δ = 0.10. The confirmatory sample size comes from the pilot's noise parameters only, never from its estimates."
- **SPEC:154,** the GO text's last sentence (also RES `text`): "A confirmatory protocol on fresh network instances follows, declared before its runs."
- **SPEC:170,** on the connection readings: "They choose the confirmatory design, never the outcome."
- **SPEC:136,** on the pilot's intervals: "These intervals cover the step-to-step noise of this one instance only." SPEC:285: "No confirmatory claim. One instance and one sequence; the intervals cover step-to-step noise only."

### What triggered
- **All three primaries triggered GO.** RES `go_measures` is XOS, Dc and ds, and `holm.rejected` holds all three (thresholds 0.0167, 0.025 and 0.05; every p was the bootstrap's floor, 2/10,001).
- **The pilot's estimates,** quoted for the record only: XOS +0.584 (95 % 0.552 to 0.614), Dc +0.713 (0.651 to 0.782), ds +0.342 (0.295 to 0.391). Nothing in this protocol is sized, set or tested on them.
- **The readings** (RES `connection_readings`): at the readout, SAME DIRECTION WITHOUT THE CONNECTIONS (ds_les +0.440); for the group measures, the fixed text, because the lesion's cross drive is +0.625.

### How 023 reads each declared part
| Declared phrase | Reading in 023 |
| --- | --- |
| "the triggering measure exactly as defined here" | All three, XOS, Dc and ds, by SPEC:67-89's definitions, computed by PS byte-identical. |
| "its conditions" | Both kinds, unchanged. The stimulus conditions: the 15 analysed conditions and the warm-up, 0.8 cpd and 2 Hz, steps of 30 + 21 frames of 7 ms, the 504 ms lead-in, one presentation, no LGN cache, both plaid components at phase 0, and the pilot's repeats (8 and 4). The validity conditions: the floors and the cross-drive gate (SPEC:77-89), in every instance. |
| "δ = 0.10" | Kept for all three, applied to the mean of the six instance estimates. |
| "the pilot's noise parameters only, never from its estimates" | The calibration's per-instance noise is the pilot intact run's noise model only: its NNLS variance functions and its 96 standardised whole-step residual vectors, rebuilt from RES `measures.intact.per_step` by PS's `Fit` (it reproduces RES's variance functions exactly). The truths it is applied to are 022's calibration model through 017's instance-A anchors. No pilot estimate enters. |
| "fresh network instances" | `pynn_seed` values never built before (Instances). |
| "declared before its runs" | The spec, the sequence files, the contract and the code are frozen and hashed before any revision 2 run. |

### What SPEC:201 does not cover, declared here as extensions
- **The spread between instances, τ.** It is not a pilot noise parameter, and nothing has measured it: no instance other than A has seen a plaid. This design plans with τ_plan = 0.05 and reports its sensitivity from 0 to 0.10. The t-test over instances is valid whatever τ is: a larger spread costs power, not validity.
- **The planning effect, 0.15.** That is 1.5 times δ, the multiple 022's calibration used (SPEC:189). It is a convention, not a prediction.
- **The test's sides and level.** SPEC:201 hands on no test. The pilot's GO used two-sided bootstrap p at family-wise 0.05 (SPEC:130, SPEC:139), so it spent 0.025 in each direction. 023 asks only about the pilot's direction, so it tests one-sided at a family-wise level of 0.025: the same level in that direction. A one-sided test at 0.05 would double the rate at which a measure with no departure is declared to depart in the pilot's direction, and the draft kept two-sided p because a one-sided one would raise the worst-case false confirmation (DRAFT:229). The power the draft quoted for option (b) was computed at this level. At this level, with the tie rule (Decision rule, "Rejected"), a CONFIRMED measure's 95 % t interval always excludes 0.
- **The pilot's operating point** (its single-grating means and contrast-response shape) is an estimate and sizes nothing.
- **The 30 % check** was declared "in the pilot" only (SPEC:203). 023 declares its own integrity checks.

### The routing from 022's readings to this design, declared here
022 left this routing open (DISP:115, finding M9; DISP:166, open item 3c). The panel's draft, quoted whole from PANEL `designs[0].decision_rule`:

> Comparison design:
> - GO by ds with CONNECTION-DEPENDENT: intact against the plain lesion on at least three fresh instances, plus the inhibition-only variant after its own declared stability probe.
> - GO by ds with PRESENT WITHOUT THE CONNECTIONS: intact instances only, with no claim about the connections.
> - GO by XOS or Dc: the plain lesion alone is declared insufficient. The confirmatory design needs a comparison that keeps tuning (the inhibition-only variant), or the afferent-conductance reconstruction from exported connection lists.

023 declares this routing as its own design choice, with two adjustments:
1. **The rename.** PRESENT WITHOUT THE CONNECTIONS was renamed SAME DIRECTION WITHOUT THE CONNECTIONS before 022's declaration, and its text no longer says that the feedforward path produces the effect (SPEC:177; DISP:23).
2. **Whole-circuit claims only for XOS and Dc.** The quoted rule says that a confirmatory design for XOS or Dc "needs a comparison that keeps tuning (the inhibition-only variant), or the afferent-conductance reconstruction from exported connection lists". 023 has neither, and drops the connection exports. So it confirms XOS and Dc as properties of the whole circuit only, and leaves both comparisons to their own declared protocols.

The pilot's readings then route as follows:
- **ds, SAME DIRECTION WITHOUT THE CONNECTIONS:** intact instances only, with no claim about the connections. 023 meets this in full.
- **XOS and Dc, the fixed group text:** the plain lesion is insufficient, so 023 runs none, and confirms XOS and Dc as whole-circuit properties only (adjustment 2). The CONFIRMED and what-follows texts make only that claim.

## Design
### Instances: what "fresh" means and how each is made
- **Definition.** A fresh instance is the 2 mm reduction built with a `pynn_seed` that no run of this project has used before 023's declaration, so that no output of it has been seen.
- **Slots and reserve.** The six slots are pynn_seed 8 to 13, with reserve 14, used only by the replacement rule (Integrity checks). In 023 the slots were 7 to 12 and the reserves 13 and 14; seed 7 is now built, and no seed is added, because a second reserve would need a new sequence file and a wider seed search (Choices).
- **Excluded seeds: 5, 6 and 7.** 5 is instance A (017's runs, 021's probes, the live loop and all of 022); 6 is instance B (017's intact-B, whose export the draft read for its noise and instance comparisons). 7 was 023's first slot: 023's queue built and ran it (`m23-s7-intact-a1`), and so did the diagnosis (d1, d5, rate-r1 and the partial rate-r2), and its output has been seen. Seeds 5, 6 and 7 may be used for rehearsals before the declaration (Rehearsal before the declaration), never for an analysed instance.
- **Never built.** For this revision the seeds that must never have been built are 8 to 14. 023's three records below searched for 7 to 14 and found none outside 023's design, and seed 7 was built after them, by 023's queue and its diagnosis. A fourth record, this revision's, covers the Mac's run folders since 023's last record (the last item). 023's text follows. Seeds 7, 8 and 9 were planned only in the withdrawn 022 revision 0 (`docs/specs/2026-10-25-protocol-022-hold.md:43`); no receipt the draft's survey could read names any seed but 5 and 6. That survey could not read 288 files that iCloud had evicted, and a preliminary search on 29 October, of the Mac's `work/` and `outputs/` only, could not read 197. So the seed search before the declaration (`work/controller-023/seed_search_023.py`, read-only; Done when) was to cover both places where the project's runs left records. Since the Mac revision it covers the Mac alone, because the server is gone; the server's last records stand in its place, and their item states the limit:
  - the research server, where the model runs up to protocol 022 ran and their run folders stayed: `/opt/felisyn` and `/opt/felisyn-live`, with the run folders, the Mozaik result folders (named after the run's modified parameters, which Mozaik also saves in each one's `parameters.json` and `modified_parameters.json`), receipts, logs and exports, read in place as felisyn on 3 November by round 3's script and two censuses, and no longer readable;
  - the Mac's workspace, `work/` and `outputs/`, which holds what was fetched from the server, with every evicted file the search reads downloaded first.

  It looks for a pynn_seed from 7 to 14 or a 023 run name (`m23`, a hyphen or an underscore, `s` and the seed, then anything but a letter or a digit: `m23-s<K>-intact`, `m23_s<K>_intact`, `m23-s<K>`; in any case) in the text it reads and in the names it meets: the name of every folder it walks, and of every file and archive member in the folders it enters. The name is found in any case: "pynn", then nothing, one or two underscores, dots or hyphens, a backslash and an underscore (`pynn\_seed`, as Markdown writes it), "'s" and up to 8 spaces or newlines (`PyNN's seed`), or up to 8 spaces or newlines (prose wrapped at a line's end), then "seed" or "seeds". The rule reads at most 60 characters after the name, and the one after them to see that a number ends there (its reach; the censuses of 3 November, `work/controller-023/FIX-NOTES-023.txt` section 1f, kept the same 60): first, in any order, spaces, newlines, escaped newlines, tabs and returns, backslashes, quotes, backticks, brackets, parentheses, an opening brace, the characters `:=,;|<>!$*_-` and the arrow U+2192, an object's key (`{"value": 7}`, `${S:-7}`), a cast (`int(7)`, `np.int64(7)`, `!!int 7`), the words is, was, were, are, of, to, set, from, equal(s), default, changed, text and value, and "in" before a bracket, a parenthesis or a brace; then a number, and every number of a list or range right after it, joined by commas, "and" or "or", arrows (`->` and U+2192) or spaces alone (with quotes or brackets around each), "to", "through", "thru", a hyphen, an en or em dash or "..", or, when the value starts on a new line after a hyphen, by the lines of a YAML list, its values quoted or not; a range gives each seed between its ends. So it reads `p["pynn_seed"] = 7` (and `p[\"pynn_seed\"] = 7` inside a JSON string), `` `pynn_seed` 7 ``, `| pynn_seed | 7 |`, `"pynn_seed": [5, 7, 9]` (5, 7 and 9), `pynn_seeds=[7]`, a YAML list, `PyNN seeds 7 to 14`, `PyNN seeds 7-12`, `pynn_seed from 7 to 14`, `pynn_seed := 7`, `pynn_seed is 7`, `PyNN seed of 7`, `pynn_seed set to 7`, `pynn_seed_7`, `pynn-seed-7`, `"pynn_seed": 7`, `\"pynn_seed\": 7`, `'pynn_seed' : 7`, `PYNN_SEED=7`, `pynn_seed:7` in a Mozaik result folder's name and, since the re-check of 3 November, round 6, `pynn\_seed 7`, `PyNN's seed 7`, `pynn_seeds 5 6 7` (5, 6 and 7), `pynn_seed 5 -> 7` (5 and 7), `pynn_seed (default 7)`, `pynn_seed changed to 7`, `pynn_seed in [7, 8]` and a YAML list of quoted values; a number the reach cuts (the text goes on with a digit) is never read. Its tests hold every form of both censuses of 3 November, each with the seed set to 7, and every census window outside this design that holds an integer from 7 to 14 without naming such a seed, none of which is a hit; FIX-NOTES sections 1f and 1h give the forms it does not read, and why (risk 16). Each name is read within its reach, with no unbounded backtracking (Python 3.9 has no atomic groups), so the time grows linearly with the text read. Measured on the Mac in the re-check of 3 November, round 6 (FIX-NOTES section 1h): `pynn_seed` followed by 100,000 spaces, or by 100,000 of any character or word that may stand before the value, took at most 0.002 s; files of 100,000 mentions each followed by a list of 29 numbers, by 29 numbers separated by spaces or by a chain of 14 arrows, the slowest inputs found, took 1.1 to 1.5 s under Python 3.14 and 1.3 to 1.8 s under the server venv's Python 3.9.6, and 300,000 and 1,000,000 such mentions took 4.0 and 13.7 s under 3.14 and 4.7 and 16.1 s under 3.9.6; the other files of 100,000 mentions took under 0.5 s. It reads the files with a text suffix (`.txt`, `.log`, `.json`, `.jsonl`, `.md`, `.sh`, `.py`, `.out`, `.err`, `.csv`, `.tsv`, `.yaml`, `.yml`, `.cfg`, `.ini`, `.toml`, `.conf`, `.service`), the files without a suffix whose first 4,096 bytes hold no NUL byte (such as Mozaik's own log), gzip files whole (the exports, their headers with the argv and the resolved seeds included), and the members of zip and tar archives one by one (text, gzip and tar members whole). It does not see the names inside the folders it does not enter, nor the members of a zip inside an archive, which it names only. On the server, by a read-only census of 31 October of the files outside the folders it skips by name, the Python install and the build trees (`work/controller-023/FIX-NOTES-023.txt`, section 1e), the files it does not read are Mozaik's `.pickle` data stores (3,594), numpy arrays (39), images (51), documentation and code in other languages (120), and 6 `.xml`, 4 `.sha256`, 3 `.TAG` and 1 `.lock` files, besides 15 files whose names start with a dot, the files inside the seven folders whose names start with a dot, which it does not enter and lists (by the owner's agent's list of 3 November, FIX-NOTES section 1f: the Mozaik repository's 21 workflow files in the three framework copies' `.github/` folders, pytest's cache files in their three `.pytest_cache/` folders, and an empty `matplotlib/` folder in `/opt/felisyn/.config/`), and the files without a suffix whose first 4,096 bytes hold a NUL byte; the server holds no `.stdout`, `.stderr` or rotated log. Each Mozaik result folder also holds `parameters.json` and `modified_parameters.json`, which it reads, and the folder's name carries the modified parameters. What it never opens or enters is decided from names and modes alone, before any file is opened, below each root and inside archives alike (inside an archive, since the re-check of 3 November, round 6, from the archive's whole list of entries before any member is opened, so that a folder's entry closes every member under it whatever the order of the entries; a member under a folder that has no entry of its own is judged by its own name and mode and by the names on its path): a folder named `ssh`, `.ssh`, `.gnupg`, `keys`, `secrets`, `credentials`, `wallets` or `devnet-keys`; a file named as a key, keystore, wallet, secret, credential or environment file (by its suffix, such as `.key` or `.pem`, or its name, such as `.env`, `environment`, `id_rsa`, `id.json`, `keypair` or `treasury`); a file or folder whose name starts with a dot (a home folder's configs, credentials and shell histories: `/opt/felisyn` is felisyn's home folder); and an owner-only folder, or an owner-only file that it would read, whose mode gives no access to group or others (0600 or 0700, the modes ssh, gpg and solana-keygen give keys). It never opens a symbolic link, a pipe or a device either, and does not enter the software trees (the venv and Node, and on the server the source trees, the Python install `python-3.9.20` and the build trees `build`, whose code carries example seeds; the Python install's test suite also holds CPython's crafted tar `recursion.tar`, which cannot be read, so the search entered it and failed until the re-check of 31 October, round 3) or the live executor's and shadow's folders (keys, ledgers and configs, no model run). A key kept under an ordinary name, readable by group or others, in an ordinary folder, would still be read; the report prints names, counts and seeds, never a file's text. A folder or file that it would read but cannot read, or a root that is not a folder, fails the search. The report lists by name (re-check of 3 November, rounds 4 and 6) every item it counts but never opens or enters: each owner-only folder, and each owner-only file it would read; each folder whose name starts with a dot, on disk or inside an archive (`archive!folder/`); each file whose name starts with a dot; each file named as a key, keystore, wallet, secret, credential or environment file; each folder it never enters, with its rule (its name, or a folder directly under a root named `felisyn` or `felisyn-live`); each symbolic link; each pipe, socket or device; and each archive member that a rule left unread, once, by the first place of its path that the rule closes, with its rule (a name that starts with a dot, a key's name, a folder never entered, a link or other special member, a zip inside an archive). It only counts, by kind, the binary files on disk (an owner-only one among them, never read in any case) and macOS's own files, Finder's `.DS_Store` files and the AppleDouble `._` files that hold another file's metadata, on disk or inside an archive; a binary archive member is named only. Its first line after the time, with the SHA-256 of its rules, and its "never entered" and "never opened or entered" lines are those its `rule_lines()` gives; the two rule lines say what it lists by name and what it only counts. The listed items do not change its exit: the item that records a search judges each one by its name and place, and one that could hold a model run's record means that the search has not shown "never built"; it is resolved with the owner and the search repeated, as for an unreadable file. Results:
  - on the Mac, 2026-11-03T08:30:09Z (`work/controller-023/seed-search-023-mac.txt`, SHA-256 `34cba58b2a1c35a5fc3a197677abf6b672bd7040fceea0837a0b488009274f31`, by the script with SHA-256 `2275985384521ada00f8655f78aa1bb2ec9c9bc6c32634d5864c6fd6ac0775dc`): PASS. It read 4,451 files and 3,647 zip and tar archive members and checked 13,237 names, with no file under the two folders evicted by iCloud; no placeholder and nothing unreadable was left. Nothing outside this design names a seed from 7 to 14, in any of the forms above; 34 files of this design and of 022 revision 0's review state them, as expected. It counted 169 files of macOS's own by kind, not opened: 12 Finder `.DS_Store` files (11 on disk, 1 inside an archive), and 157 AppleDouble `._` files, which hold another file's metadata (155 in `work/controller-022/plaids/scratch-archive-2026-10-27.tar.gz` and 2 in the `__MACOSX` folder of a published data pack in `work/open-data-016/`). None of the 47 items it lists by name holds a model run's record, judged by name, place and date, none opened: the three owner-only items, `work/cat-frontend/`, the frontend's working folder (its brief, plans, log, screenshots, recordings and a local HTTPS key; no file newer than 29 October 06:04 UTC), and two temporary folders of protocol 022's verification, `work/controller-022/plaids/scratch-archive-2026-10-27.tar.gz!verify022r2/tmp/cli-27t19jsy/` and `work/controller-022/plaids/scratch-archive-2026-10-27.tar.gz!verify022r2/tmp/d3-bv3jfgms/` (the 022 analysis code's test inputs and outputs, in an archive unchanged since 27 October, which the search of 06:57:15Z on 31 October read and found no seed in, with the narrower pattern of that search); the dot folder `outputs/felisyn-research/audit-001/mozaik-v040/.github/`, the GitHub workflow folder (one workflow file) of the Mozaik 0.4.0 source copied for the audit of 8 October; the four dot files, `outputs/felisyn-cat/.npmrc` (npm's settings for the cat frontend, 47 bytes), `outputs/felisyn-cat/.vercelignore` and `outputs/felisyn-site/.vercelignore` (the lists of files Vercel leaves out of an upload) and `outputs/felisyn-site/.gitignore` (git's list of files to ignore); since the re-check of 3 November, round 6, the four files named as keys, `outputs/felisyn-research/rehearsal-008/cloud-image/SHA256SUMS.gpg`, `outputs/felisyn-site/dist/research/rehearsal-008/cloud-image/SHA256SUMS.gpg`, `outputs/felisyn-site/public/research/rehearsal-008/cloud-image/SHA256SUMS.gpg` and `work/rehearsal-008/transfer/SHA256SUMS.gpg` (the signature, 833 bytes each, of the Ubuntu cloud image's list of checksums, kept for the rehearsal of 21 October); the 16 folders it never enters, by their names: the twelve Python bytecode caches `outputs/felisyn-research/benchmark-004/__pycache__/`, `outputs/felisyn-research/execution-002/__pycache__/`, `outputs/felisyn-research/protocol-006/__pycache__/`, `outputs/felisyn-research/validation-005/__pycache__/`, `work/controller-015/controller/__pycache__/`, `work/controller-021/__pycache__/`, `work/controller-021/controller/__pycache__/`, `work/controller-021/server/__pycache__/`, `work/live/__pycache__/`, `work/protocol-018/__pycache__/`, `work/source-audit-001/__pycache__/` and `work/source-audit-002/__pycache__/` (36 `.pyc` files of the scripts beside them), the cat frontend's and the site's npm packages `outputs/felisyn-cat/deps.nosync/` and `outputs/felisyn-site/node_modules/`, the site's Vercel link `outputs/felisyn-site/.vercel/` (the deployment's settings) and the live executor's folder `work/executor/` (keys, ledgers and configs, no model run); the two symbolic links, never followed, `outputs/felisyn-cat/node_modules` (to `deps.nosync/node_modules`, the cat frontend's npm packages) and `work/protocol-018/stage/run-011` (to `outputs/felisyn-research/run-011`, the run 011 package, which the search reads in its own place); and the 17 archive members a rule left unread: a zip inside an archive, named only, in three copies, `outputs/felisyn-research/protocol-018/protocol-evidence.zip!data/pcbi.1005543.s005.zip`, `outputs/felisyn-site/dist/research/protocol-018/protocol-evidence.zip!data/pcbi.1005543.s005.zip` and `outputs/felisyn-site/public/research/protocol-018/protocol-evidence.zip!data/pcbi.1005543.s005.zip` (Hahn and colleagues' published S5 Dataset of 2017, CC BY 4.0); a key's name, in three copies, `outputs/felisyn-research/rehearsal-008/rehearsal-evidence.zip!cloud-image/SHA256SUMS.gpg`, `outputs/felisyn-site/dist/research/rehearsal-008/rehearsal-evidence.zip!cloud-image/SHA256SUMS.gpg` and `outputs/felisyn-site/public/research/rehearsal-008/rehearsal-evidence.zip!cloud-image/SHA256SUMS.gpg` (the same signature of the Ubuntu cloud image's checksums); and eleven folders never entered, in protocol 022's two scratch archives: the ten Python bytecode caches `work/controller-022/plaids/scratch-archive-2026-10-27.tar.gz!design022p/code/__pycache__/`, `work/controller-022/plaids/scratch-archive-2026-10-27.tar.gz!review022p/__pycache__/`, `work/controller-022/plaids/scratch-archive-2026-10-27.tar.gz!review022p/meas/__pycache__/`, `work/controller-022/plaids/scratch-archive-2026-10-27.tar.gz!review022p/verif/__pycache__/`, `work/controller-022/plaids/scratch-archive-2026-10-27.tar.gz!review022r2/bytecode-copy/controller/__pycache__/`, `work/controller-022/plaids/scratch-archive-2026-10-27.tar.gz!review022r2/bytecode/felisyn-research/protocol-022r2/controller/__pycache__/`, `work/controller-022/plaids/scratch-archive-2026-10-27.tar.gz!review022r2/verify-stats/bc1/pkg/controller/__pycache__/`, `work/controller-022/plaids/scratch-archive-2026-10-27.tar.gz!understand/xos-mech/__pycache__/`, `work/controller-022/plaids/scratch-archive-2026-10-27.tar.gz!verify022r2/tmp/bc/protocol-022r2/controller/__pycache__/` and `work/controller-022/plaids/scratch-archive-design022p-2026-10-26.tar.gz!design022p/code/__pycache__/` (38 `.pyc` files), and `work/controller-022/plaids/scratch-archive-2026-10-27.tar.gz!review022r2/verifier-server/s7/t/venv/` (a stand-in venv of two shell files, a test input of 022's verifier). This search replaces the one of 02:29:22Z the same day (`work/controller-023/seed-search-023-mac.superseded-20261103T022922Z.txt`, SHA-256 `bd4ef12d54997656893ca25769677f486ae41d1c1c42e562c19c6401ca23d44c`, by the script with SHA-256 `32a2061a5ff804645b7472144d06d9f853e3330122da8527a55dc644ea30c09d`), also a PASS, because the script changed in the re-check of 3 November, round 6 (an archive's members judged from its whole list of entries, the items it counts on disk listed by name, and more forms of the seed and the run name); it read two files more (the record it replaces, under its own name and as its superseded copy, each a design file) and lists one folder fewer (`work/source-audit-002/ssh/`, which the owner's agent moved out of the workspace before it). That search replaced the one of 01:40:29Z the same day (`work/controller-023/seed-search-023-mac.superseded-20261103T014029Z.txt`, SHA-256 `69cf78f8a5075f430c1634374ebf5c748eb7550d501ef5e000588dae7c9c803a`, by the script with SHA-256 `9db318374311bcfd77b6f6702bda47098da249d2be84497527ee9836923c84b4`), also a PASS, with the same lists and the same rules SHA-256 and one file fewer, because a comment of the script was corrected after it. The search of 01:40:29Z replaced the one of 2026-10-31T20:18:27Z (`work/controller-023/seed-search-023-mac.superseded-20261031T201827Z.txt`, SHA-256 `2257654b83dd74c8f73d8bcbbff7fd8b7088899659bb02a78b1539c90fccaa03`, by the script with SHA-256 `494c3fb9c31e52ba82ede5a83f024c3307b3784bd099c352ddeaee6a3e281df8`), also a PASS, because the script changed in the re-check of 3 November, round 4 (the wider forms of the seed, its reach of 60 characters, and the lists of dot files and of archive members left unread). The search of 16:14:17Z on 31 October (`work/controller-023/seed-search-023-mac.superseded-20261031T161417Z.txt`, SHA-256 `e327d34b6b337263a9d98d4fe60048d72e3cb3e8a43a55bb99e45fb9fa8a6a5a`, by the script with SHA-256 `d174d833eedb60e81cd6b85a02ddd1a14cdf65ed8ede63615e7d9a7cbc308aa5`), also a PASS, was replaced in round 3 (the server's Python install and build trees not entered, wider forms of the seed, dot folders listed). The search of 06:57:15Z, by the script with SHA-256 `0f4ca9952c84f975ac4e59e7648d2903cc1df16a24bda37aa2ed238192af772e`, was replaced because its rules also opened the research server's SSH key in `work/source-audit-002/ssh/` (the re-check of 31 October, round 2); no text of the key reached its record, which prints names, counts and seeds only, and the record is kept as `work/controller-023/seed-search-023-mac.superseded-20261031T065715Z.txt` (SHA-256 `636380df3d4d67f9b6fbf9334aef95c076bb8f22210eeec537d31ab9d50f952f`);
  - the research server's last records, which cannot be repeated: the server has not answered ping or SSH since 3 November, and nothing on it can be read, rechecked or corrected. **The stated limit: the server half of the seed search ran with round 3's script on 3 November 2026 at 00:29:38Z, the final script ran only on the Mac, and the server's files can no longer be read.** The records are the probe of 2026-11-03T00:29:38Z (`work/controller-023/seed-search-probe-494c3fb9.txt`, SHA-256 `a5801a67a80550b362102aaf2d4b5a697be27a0069c1c67caa4b75243b9b950f`, by the script with SHA-256 `494c3fb9c31e52ba82ede5a83f024c3307b3784bd099c352ddeaee6a3e281df8`, round 3's), PASS, with 2,302 files, 392 zip and tar archive members and 8,909 names read, no hit and nothing unreadable; and two censuses of the same day, the seed census (`work/controller-023/seed-census-server.txt`, SHA-256 `bd14402cf14daf1f78f30101dd85219d9596f9d88c8a524910988e0718b36d15`; 2,076 text files and 2,060 archive members) and the window census (`work/controller-023/window-census-server.txt`, SHA-256 `82243c0e6e5b5c90e46fdf6b4821b2c39168ed832e3c13a1dd90942e6cf311c6`; 2,327 text files), each of which found 0 windows with a standalone integer from 7 to 14 within 60 characters of a seed name. For the 45 forms the server's records hold, that test is wider than the script's rules. At the last contact, 2026-11-03T07:33:14Z, the load average was 0.00, so no model was running, and a 023 run needs the files that tier 2 was to upload, which never happened there. What these records leave out: the forms added in rounds 4 and 6 (`pynn\_seed`, `PyNN's seed`, `m23_s7`, `m23-s7`) were not read there by a script; the censuses read only names written `pynn`, then nothing, a space, an underscore or a hyphen, then `seed` or `seeds`, and skipped protocol 021's folders and files over 300 MB; the table census never ran there (the server held 9 `.tsv`, 5 `.csv` and 8 `.md` files); and the probe counted 37 folders not entered and 12 unread archive members without naming them, and only part of its 19 dot items is named (FIX-NOTES section 6). For a record a model run writes by code this is enough, because those records use the machine-written forms the censuses cover. For a hand-written note on the server it is weaker.
  - the Mac's run folders since 7 November: every new run happens there, under the rule that forbids seeds 7 to 14 until the queue. The unchanged `seed_search_023.py` ran over run output only (`<home>/felisyn-local/runs`, the one folder of run output of the proof and G4 stages, never the logs that name these seeds) at 2026-11-07T08:47:12Z (`work/controller-023/seed-search-023-runs.txt`, SHA-256 `b5747490779125ca2bab48d42cbd2daf439bee303b3ffe0395daf5bab3eadd6c`, by the script with SHA-256 `2275985384521ada00f8655f78aa1bb2ec9c9bc6c32634d5864c6fd6ac0775dc`): PASS. It read 377 files and 0 zip and tar archive members and checked 1,188 names, with 0 hits, 0 design files, 0 placeholders and nothing unreadable, and it lists no item by name. It counted 747 binary files, not opened: 741 Mozaik `.pickle` data stores and 6 copies of the tiny model's orientation map, `or_map_new_6x6`. That pass covers the seed 6 run below; the pass of 2026-11-07T08:21:58Z, before that run (`work/controller-023/seed-search-023-runs.superseded-20261107T082158Z.txt`, SHA-256 `cc3ababce80411bf23acc435598caeb134d89f42adad4d519746b6f706f752e6`; 358 files, 1,140 names, 720 binary files), was also a PASS. A seed from 7 to 14 found there would have meant a revision with other seeds, not a declaration.
  - this revision's search of the Mac's run folders since 023's last record (2026-11-07T08:47:12Z). Every model run on this Mac since then wrote its output into one of four folders: `<home>/felisyn-local/runs` (searched again, whole), `<home>/felisyn-local/run-023` (023's queue: s7 only), `<home>/felisyn-local/diag-023` (the diagnosis: seed 7 only; its `tools/run1.sh` refuses any seed but 5, 6 and 7) and `<home>/felisyn-local/p023r2-test` (this revision's rehearsals: the TEST phase's two short runs of built seed 7 on 8 November, 5 steps each with the first 5 steps of slot 8's order, and the spec's rehearsal of seed 6 with slot 8's order on 8 and 9 November; its queue copy refuses any seed but 5, 6 and 7; Rehearsal before the declaration). No model can run in the workspace: since 7 November the engine and its run folders are in `<home>/felisyn-local`, so the workspace is not searched again. The search is `seed_search_023r2.py`, which runs the unchanged `seed_search_023.py` (SHA-256 `2275985384521ada00f8655f78aa1bb2ec9c9bc6c32634d5864c6fd6ac0775dc`) with the seeds 8 to 14 in place of 7 to 14 and counts apart, as design files, only the copies of a frozen package in those folders: 023's package in `run-023/check/`, `run-023/seq/`, `run-023/tier2/` and the run folder's server files and hash lists, and the same copies in the rehearsal folder. A Mozaik result folder, an export, a model log or an attempt's receipt is never a design file. Its rules' SHA-256 differs from 023's because its seeds differ. The tests of this revision keep their temporary files outside these four folders, so a synthetic export named after a slot is never in them. It ran again after the rehearsal, on 9 November 2026, and its item, the next one, is recorded in the form `  - in the Mac's run folders, ⟨UTC⟩ (`work/controller-023/seed-search-023r2-runs.txt`, SHA-256 `⟨the record's⟩`, by the script with SHA-256 `⟨seed_search_023r2.py's⟩`): PASS.`, then its counts and the judgment of every item it lists by name (its words differ from the Mac item's "on the Mac", which the checks find by its start). `make_contract_023.py --declared-utc` and the freeze apply to it the checks the Mac's item gets ("Declaring this spec"), with `seed_search_023r2.py` in place of `seed_search_023.py`, its record's first line `seed_search_023r2.py SHA-256 ⟨its SHA-256⟩ at ⟨UTC⟩` and its rule lines, and its roots line `roots: <home>/felisyn-local/runs, <home>/felisyn-local/run-023, <home>/felisyn-local/diag-023, <home>/felisyn-local/p023r2-test` (code review of 8 November: nothing checked this item before). A seed from 8 to 14 found in a run record means a revision with other seeds, not a declaration.
  - in the Mac's run folders, 2026-11-09T04:06:56Z (`work/controller-023/seed-search-023r2-runs.txt`, SHA-256 `b19ff06e846b75f7c9a448ac81a9561148b273ac4ff49a1c294ad239af7351d6`, by the script with SHA-256 `6f02307264156ab4dfb5f4ceaa83a5215f7926f7d451d3bf46e729c42945efa3`): PASS. It read 1,450 files and 0 zip and tar archive members and checked 2,543 names; no hit outside the design, 28 design files (023's frozen package in run-023 and the rehearsal's copies of the package in `p023r2-test/run`; the search it replaces counted 18, before `p023r2-test/run` existed), nothing unreadable. It counted 943 binary files, not opened; among them are the rehearsal's three Mozaik archives, `p023r2-test/run/archive/s6-a1-mozaik.tar.xz` to `s6-a3-mozaik.tar.xz`, xz-compressed tar files that the unchanged script does not open as archives (it opens `.zip`, `.tar`, `.tar.gz` and `.tgz`), with their file lists (`.sha256`, a suffix it does not read); by the rehearsal's records they hold only seed 6's Mozaik folders, and its queue copy refuses any pynn_seed but 5, 6 and 7. It lists one item by name, owner-only and not opened: `<home>/felisyn-local/p023r2-test/fetched/data-sha256.txt`, judged by its name, place and date: the hash list that the rehearsal's fetch copy wrote at 2026-11-09T03:52:57Z (180 bytes). `fetch_023.sh` copies that list from a `mktemp` file, which macOS creates owner-only, so every fetch's list has that mode; by the rehearsal's record (HANDOFF, 2026-11-09T03:55:24Z) it gives the run folder's SHA-256 and size of seed 6's two exports, and it holds no model run's record. This search replaces the one of 2026-11-08T21:59:22Z (`work/controller-023/seed-search-023r2-runs.superseded-20261108T215922Z.txt`, SHA-256 `f34faa1a96a7a118b2b5767d52f416f42d457e06efd5454fed74aa0e88f05b8d`, by the same script), also a PASS with 1,237 files, 0 archive members, 2,305 names, 18 design files and nothing listed by name, because the spec's rehearsal wrote `p023r2-test/run`, `p023r2-test/fetched` and `p023r2-test/local-check` after it; the last search is the one that counts.
- **How an instance is made.** The pilot's intact command with the 2 mm reduction overrides plus `pynn_seed K`, the way 017 made instance B (`outputs/felisyn-research/protocol-017/README.md:65`). Nothing on the model-run path changes: `run_controller.py` (`99d215f2…`), `lgn_cache.py` (`d0f570f3…`) and stimulus version 3 (`controller_experiments.py`, `4052bcdc…`) are byte-identical copies of 022's. The Mac revision puts one file in front of it: the run command becomes `python ../run_controller_mem.py` with the same arguments, a memory wrapper that runs `run_controller.py`, still byte-identical (`99d215f2…`), so the export records the same argv (Stated limits of the Mac run).
- **What is fresh** (`protocol-017/README.md:68`): every cell position, in the LGN and the cortex, drawn by `pynn_seed`; the cortical starting voltages; therefore the connections (Mozaik's connection seed is shared, but distances and map-assigned preferences change); and each layer 4 cell's preferred orientation, read from the map at its new position.
- **What is shared:** the orientation map, a fixed file; Mozaik's seed 513; NEST's kernel seed 42 (PyNN's default, because Mozaik calls `setup` without a seed, `outputs/felisyn-research/run-011/receipts/seed-source.txt:6-33`); therefore the LGN noise, node by node. In the 504 ms grey lead-in every LGN spike train is identical in 017's instance A, 017's instance B and the pilot: 1,800 of 1,800 X_ON cells and 1,750 of 1,750 X_OFF cells that fired; a control with node ids shifted by one matches 0 (`work/controller-023/scratch/lgn-leadin-identity-pilot.json.txt`). On the Mac the stream is the same only through the engine's noise-order patch (Stated limits of the Mac run). The trains diverge once a grating is shown, because the positions differ. `mpi_seed` 1023 is recorded but never forwarded. The CONFIRMED text names the map, the LGN noise stream and the plaid layout among what the instances share. Mozaik's seed 513, which also seeds each neuron's connection sampling and weight draws (`protocol-017/README.md:68`), is shared too: the result package's README and the journal note that report a CONFIRMED outcome say so.
- **Consequences:** a fresh instance is new in structure, not in its input noise; the plaid phase layout barely moves (block A's mean cosine +0.390 and −0.284 in A against +0.414 and −0.311 in B, `work/controller-023/noise-instances-017.json`); so 023 cannot test the fixed-phase layout or another map.
- **NEST's seed stays 42,** because it keeps the project's definition of an instance (`protocol-017/README.md:65-68`), and a per-instance seed would need a new `run_controller.py` and an identity run on the model-run path. The shared noise stream matters for the t-test, which needs the instances' errors to be independent. Each instance therefore gets its own stimulus order, so the same noise at the same time falls on different conditions in different instances. The calibration tests this with the same residual rows in every instance (correlation 1) and with residuals correlated 0.44 between instances (017's A and B under one order), both with own orders, and shows what one order for all would do at 0.44.

### Stimulus sequence: the pilot's design, each instance with its own order
**Unchanged:** stimulus version 3; the warm-up [45°, 30 %]; the 15 analysed conditions of SPEC:45-56 with their repeats (8 and 4: 96 analysed steps); 0.8 cpd and 2 Hz; 30 + 21 frames of 7 ms; the 504 ms lead-in with `FELISYN_WARMUP_MS=0`; one presentation, no chunking and no LGN cache; both plaid components at phase 0. Each run is 97 steps, 5,019 frames and 35.1 s of model time, as the pilot.

**Each instance gets its own order, by the pilot's declared rule (SPEC:57-61), with no new rule:** the warm-up first, then four quarters of 24 analysed steps; each condition's repeats spread evenly over the quarters (8 give 2 per quarter, 4 give 1); the quarters shuffled in turn with one `random.Random(seed)`; and the first seed whose analysed steps have no condition three times in a row, across quarter boundaries too, is kept. The only per-instance input is the first seed tried, 230000 + 100 K, and the seed used must lie below the next instance's first seed. The code is 022's (`make_plaid_sequence_r2.py`, byte-identical, `96a55541…`), called by `make_plaid_sequence_023.py`; with 022's first seed 231 and 022's scope it writes `sequence-r2.json` byte for byte (a test). No stimulus code changes.

**The declared files** (`work/controller-023/sequences/`; 023's files for seeds 8 to 14, byte for byte; every first seed passed the run rule at the first try):

| Instance | Role in revision 2 (in 023) | Seed used | SHA-256 of `sequence-023-sK.json` | Largest deviation of a primary condition's mean previous contrast (points) | Block B plaids' mean previous contrast (%) |
| --- | --- | --- | --- | --- | --- |
| 8 | slot (slot) | 230800 | `f185a2b3adc31de0fafd3420722f7b65783839c3c5784667aeb8b9bde28e104f` | 15.3 | 48.75 and 26.25 |
| 9 | slot (slot) | 230900 | `18c5b676e0163fb7f9279c7399fc5a3c7615f6bc680c3b7a123df33783cb5539` | 9.1 | 30.0 and 41.25 |
| 10 | slot (slot) | 231000 | `48fe6cb0c15aa336362019a312763f4f057aaca53e0929d0a5860f425d2863c1` | 15.9 | 45.0 and 18.75 |
| 11 | slot (slot) | 231100 | `27cfa9d9ee430a70aab246ca6029dd04597fe5b3330387a633b340e1b6db81d0` | 18.0 | 37.5 and 30.0 |
| 12 | slot (slot) | 231200 | `b94950656c690a6c706c9017fa239dc0d6fc41e80474c95ac9f16fc1d1401d5e` | 19.7 | 37.5 and 37.5 |
| 13 | slot (reserve) | 231300 | `5d252fab9e295996e51a0579ee8801dba3f420a06b460597f17f8c8405213483` | 8.1 | 33.75 and 30.0 |
| 14 | reserve (reserve) | 231400 | `266f09e2e12a1c44e9de6f82e9c138d0a8399a32e81888a709607893a4b12050` | 11.6 | 22.5 and 26.25 |

**The files are 023's, unchanged.** Two fields inside them record their origin in 023, not this revision: `design.spec` names 023's spec, and `design.instance.role` gives 023's role (seed 13's file says reserve). They are part of each file's bytes and stay; this revision's roles are the table's and the contract's. `make_plaid_sequence_023.py`, which rebuilds each file byte for byte, stays 023's (its own lists name 023's slots and reserves), and this revision's contract checks each instance's file with it. Seed 7's file (`7e35178d…`) stays in `sequences/` and in the package only because 023's unchanged generator test rebuilds all eight of 023's files; it is no instance of this revision, and the contract, the queue and tier 2 never read it.

The pilot's own order gives 15.5 points and 22.5 and 48.75 % by the same computation (block B plaids `135@30+90@15` and `135@15+90@30`, in that order). No order removes the history imbalance; with own orders it no longer falls on the same conditions in every instance, and S12 reports it per instance.

### Measures (exactly as in protocol 022)
**Definitions,** quoted from SPEC:67-70:
- "Y_g(k) is the mean count per cell of group g in G at step k. R_g(j) is its mean over condition j, B_g = R_g(blank), and D_g(j) = R_g(j) − B_g."
- "The readout z(k) = Σ_n c_n(k) w_n sums over all layer 4 excitatory cells: counts in D, with 017's balanced weights (`pipeline.decoder_weights`)."
- "ζ(j) is the mean z over condition j minus the mean over the blanks. Projections always use the complex conjugate."

**Windows and groups** (SPEC:63-66): G = [20, 230) ms and D = [40, 300) ms after onset, half-open; layer 4 excitatory cells whose `orientation_pref` lies within ±15° of 45°, 90° or 135°.

**P1 XOS, P2 Dc and P3 ds** are SPEC:73-88's, with their validity conditions, quoted there in full and applied unchanged; SPEC:89's undefined cases apply too ("Negative numerators are kept: XOS may exceed 1 and A may be negative. Only Dc uses A⁺."). What changes is only the consequence of a failed validity condition: the measure is not estimable in that instance, so it cannot be confirmed (Decision rule), instead of voiding the whole protocol.

**Per instance:** the groups and 017's balanced readout weights are rebuilt from that export's own `orientation_pref`, and every step's readout is checked against 017's `population_vector_weighted`, as AP does for instance A. The readout uses `decoder.json` (`c999c302…`); 45° of decoded orientation is 1 signal unit, and the decision threshold is 0.25. The measures are computed by PS's unchanged estimators on that instance's export.

**Direction and margin.** The direction to confirm is the pilot's, positive for all three: the signs of the GO sentences (SPEC:156-162) and of RES's estimates. It is part of the claim being confirmed, never a sizing input. δ = 0.10 for each measure (SPEC:140-143).

### Secondary measures (reported, no decision role)
**Per instance:**
- S1 to S3 and S5 to S12, as SPEC:91-113 declares them, without the lesion parts (there is no S4). S1 adds the relay-denominator form of XOS with its 95 % interval, which PS computes in `xos()` but `run_measures` leaves out of S1; the driver reads it from `xos()`, so PS stays byte-identical.
- The instance's pilot-style outcome: 022's rule applied to that instance alone (its name and triggering measures only).
- S14, structure and input: group sizes, S10's phase geometry, the LGN lead-in identity, the LGN band, and the layer 4 band (Integrity checks).

**Across instances, S13,** for each primary that is estimable in all six instances (for a measure that is not, the code computes no S13 and no count with the pilot's sign; its instance estimates, intervals, validity and reasons are reported):
- the mean, the SD and the 95 % t interval of the six instance estimates;
- the between-instance SD by moments: the variance of the estimates minus the mean within-instance bootstrap variance, floored at 0, with a 95 % interval from the chi-square interval (5 degrees of freedom) of the variance of the estimates less the same within-instance term. It is descriptive, and it assumes independent instance errors;
- the count of instances with the pilot's sign;
- a 90 % prediction interval for one further instance: mean ± t(0.95, 5) · SD · √(1 + 1/6).

Its purpose is to let later protocols be sized on a measured spread.

**Across all runs, S15, the paired-run record** (reported only; it decides nothing and sizes nothing in this revision):
- for every seed that ran: its attempts in order, each completed or failed with its kind; each completed run's server check verdict and refusal kinds; each comparison made, with its verdict and, for a disagreement, the differing fields, each sheet's number of differing trains and the first differing time; and the agreeing pair, if any;
- **the fault share:** the completed runs that disagree with their seed's agreeing pair, over the completed runs of the seeds that have an agreeing pair, with a 95 % Clopper-Pearson interval; beside it, how many of those runs the blind check refused (as s7 was refused) and how many it passed; and, counted apart, the completed runs of seeds that never reached an agreeing pair, which cannot be classified one by one. The share runs low as an estimate of the fault rate, because a seed stops at its second clean run and the seeds without a pair are left out: at a true rate of 0.25 with a cap of four its expected value is about 0.21, and the Clopper-Pearson interval assumes a fixed number of runs, which the paired rule does not have. So S15 also gives a bound that counts each seed that ended `no agreeing pair` as at least three faulty runs of four. For the seeds without a pair it gives each run's refusal kinds; when every completed run of those seeds was refused with one kind, or was unreadable, it says so, because a systematic fault whose details vary from run to run looks the same (risk 14), and the README and journal note then do not call those runs one-off faults;
- the failed attempts by kind (memory, counted failure, disk floor) and the queue's waits for free disk.
023's run, the diagnosis's runs and the rehearsal's runs are not in it.

### Intervals (per instance, as in 022)
- **The method is SPEC:115-131's,** applied to each instance alone: whole-step resampling; pooled, leverage-corrected residuals of the instance's 96 steps; NNLS variance functions; the readout split along and across its condition's mean direction where |mean z| ≥ 1,000; percentile intervals (95 % and 90 %); two-sided p with each count + 1; the misfit check reported only (022's `analysis-choices-r2.md`, items 1 to 8).
- **Draws:** 10,000 replicates per instance, from `numpy.random.default_rng(2300 + K).integers(0, 96, size=(10000, 96))` for instance K. Each draw's SHA-256 is in the contract. Separate seeds keep the instances' resampling independent.
- **Scope:** these intervals cover each instance's own step noise. They decide only the validity floors and REVERSED IN AN INSTANCE; the test over instances uses the six point estimates.

### Decision rule
Declared, frozen and hashed before any revision 2 run; applied once by code (`controller/confirm_023.py`, on top of PS).

**Per measure m** (XOS, Dc or ds), over the six analysed instances in pynn_seed order, with d_m the pilot's direction (+1):
- x_im is instance i's estimate, from PS on its own export with its own draw (the computation `run_measures` makes for 'primary'), with its 95 % and 90 % intervals and its validity;
- if m fails its validity condition in at least one instance, it is not estimable: its one-sided p is 1, and the failing quantities are recorded;
- otherwise, the one-sided one-sample t-test of the six estimates in the pilot's direction: t = d_m · mean / (SD / √6) and p_m = P(T₅ ≥ t), with the SD's divisor 5.

**Holm** over p_XOS, p_Dc and p_ds at a one-sided family-wise level of 0.025 (the pilot's two-sided 0.05 in its direction; extensions above): thresholds 0.0083, 0.0125 and 0.025, step-down, with ties in the order XOS, Dc, ds (PS's `holm` with alpha 0.025).

**Rejected:** m is rejected if Holm rejects it and its 95 % t interval lies wholly on the pilot's side of 0 (`confirm_023.rejected`). Holm's rejection gives a one-sided p of at most 0.025 and so a lower end of at least 0; the interval condition removes only the tie at p exactly 0.025, where the lower end is exactly 0. Such ties occur in floating point (the text test finds them by bisection), and without the condition a CONFIRMED text could print an interval that starts at 0.000.

**Category of each measure,** checked in this order:
1. NOT ESTIMABLE: m is not estimable in at least one instance.
2. CONFIRMED: m is rejected, and the mean of the six estimates in the pilot's direction is at least 0.10.
3. PRESENT BELOW THE MARGIN: m is rejected, and that mean is below 0.10.
4. RELAY-LIKE: the 90 % t interval of the mean lies inside (−0.10, +0.10).
5. REVERSED IN AN INSTANCE: some instance's 95 % bootstrap interval lies wholly on the side of 0 opposite the pilot's.
6. NOT REPLICATED: otherwise.

**Protocol outcome,** checked in this order:
1. **NOT INTERPRETABLE** if any of these holds:
   - a refusal on the contract or on a declared sequence file;
   - the early stop ended the protocol: two agreeing runs of one instance were both refused by the server check with the same refusal kinds, and the local check refused the earlier run's export too (Integrity checks, "The early stop");
   - fewer than six valid instances after the declared replacement (an instance is valid only with an agreeing pair whose export the server and local checks pass);
   - a refusal raised by the analysis on the content of an export the blind checker had passed (no replacement is made once the analysis has started);
   - all three measures NOT ESTIMABLE.
2. **CONFIRMED** if at least one measure is CONFIRMED.
3. **NOT CONFIRMED** otherwise.

The analysis stops and writes nothing (it is then not the declared analysis, and can be started again correctly) if the contract file is not `contract.json`, a results file exists, the running code or a listed file differs from the frozen manifest or the manifest does not record that every test passed at the freeze, 017's package or pins do not match, the checker's summary or any local or server check record in it (refused ones included) was made for another contract or by another checker than the frozen one, the summary is not settled or holds statuses, an early stop or a replacement rule that is not the rule's for the queue states, check records and queue records it holds, the exports given are not exactly the analysed instances' exports (for each, the earlier run of its agreeing pair), a given export is not a regular local file with the SHA-256 its check record holds (checked for all of them before any is read, so a mistyped or swapped path or a damaged local copy is a stop, never a refusal), an export changes while it is analysed, or a draw is not the contract's.

**No reading.** If the queue cannot be completed (the Mac is lost, or the owner stops the protocol), or the summary stops (the queue's records do not follow the declared procedure, the local check passes the export of an agreeing pair that the server check refused, or the server checks of two agreeing runs disagree), no `results.json` is written and no outcome is declared: the protocol ends without a reading. Its result package and the journal note say so, with every receipt and check record kept, and a rerun needs a new declared revision.

**Properties of the rule:**
- The test is about the mean over instances. Holm controls the family-wise error over the three measures under any dependence between them, and each t-test is exact for normal, independent instance estimates whatever the spread τ. The calibration checks both on this design's noise.
- Each rejected measure has a one-sided p of at most 0.025 (Holm's largest threshold) and, by the tie rule, a 95 % t interval that lies wholly above 0: a CONFIRMED text never prints an interval that includes 0. A test (`test_confirm_023.py`) reads back the numbers that each CONFIRMED sentence and each PRESENT BELOW THE MARGIN, RELAY-LIKE and REVERSED IN AN INSTANCE clause prints for the rule's comparisons (a mean against the margin, an interval end against 0 or ±0.10, a p against its Holm threshold) and checks them against the verdict, on random sets and on sets bisected float by float to each boundary of the rule (the margin, RELAY-LIKE's ends, a p at its Holm threshold, ties included, and a reversed interval's end at 0); a unit test checks the same for the p of a NOT REPLICATED clause. The same test fails on the rule as reviewed on 29 October (one-sided at family-wise 0.05).
- The details of a NOT ESTIMABLE clause are not read back: they quote plaid_stats' own reason strings at their own precision (3 decimals or whole numbers, as in 022), so a value within rounding of its floor can print as the floor (a D of 0.29996 prints "is 0.300 counts per cell, below 0.30"). `results.json` keeps every value unrounded. `confirm_023.py`'s docstring and the `numbers_in_texts` entry of its `declared()`, which the results record, claim more; revision 2 changes that file only in its instance lists, its docstring's spec path and the NOT INTERPRETABLE text's name, and leaves that wording as 023 declared it, so this narrower wording governs, and the contract states it.
- The margin applies to the mean of the point estimates. CONFIRMED therefore shows a mean departure at the margin's level of evidence; it does not establish a true mean of at least 0.10.
- RELAY-LIKE is about the mean, so a measure whose mean is relay-like is RELAY-LIKE even if one instance departs; REVERSED IN AN INSTANCE is checked only after the mean-based categories, and the count with the pilot's sign is reported for every measure estimable in all six instances (S13).

**Reported beside the outcome, never deciding it:** every instance's estimates, intervals and p; each instance's pilot-style outcome; S1 to S3, S5 to S12 and S14; and S13 for each measure estimable in all six instances.

### Outcome texts (fixed now; numbers filled in by the code)
Numbers are shown to 3 decimals, p to 4 decimals or as "below 0.0001", and instance values in pynn_seed order, the order of ⟨seeds⟩. A number the rule compares (a mean with the margin, an interval end with ±0.10 or 0, a p with its Holm threshold) gets as many more decimals as it needs to stay on its own side of that comparison, up to 12, so a mean of 0.099945, below the margin, is printed 0.0999, never 0.100. Where 12 decimals are not enough, the number is printed in Python's shortest exact form, which is true but can be long or in exponent form: a mean of 0.09999999999999999 is printed so, and at a near-tie the lower end of a CONFIRMED interval just above 0 can be printed 8.326672684688674e-17. The details of a NOT ESTIMABLE clause are plaid_stats' reason strings as they are (Properties of the rule).

**NOT INTERPRETABLE:** "Protocol 023 revision 2 cannot be read as declared: ⟨condition⟩. No confirmatory reading is made. The data and the failure are kept; a rerun needs a new declared revision." (023's text named "Protocol 023"; the rest is 023's.)

**CONFIRMED:** "On six network instances of the same 2 mm model that had never been built (pynn_seed ⟨seeds⟩: new cell positions and connections, each with its own stimulus order), the intact circuit combined two superimposed gratings differently from a relay of its own single-grating responses, on average over the instances, in the direction instance A's pilot found: ⟨sentences⟩. ⟨others⟩For each confirmed measure the one-sided t-test of the six instance estimates passed Holm over the three measures at a family-wise level of 0.025, and the mean of the six estimates is at least the declared margin of 0.10; that is a condition on the estimates, not an interval. The instances share the model's one orientation map, its LGN noise stream and its plaid layout, and these contrasts, this timing and this readout, so the result covers new positions and wiring on that map only. It describes the whole circuit, input stage and cortex together, and does not show that the intracortical connections compute it. Simulation only; no claim about cat visual cortex."

⟨others⟩ is empty when all three are confirmed, and otherwise "Not confirmed: ⟨clauses⟩. " with the other measures' clauses joined by "; ".

**Sentences for confirmed measures:**
- XOS: "an orthogonal grating lowered layer 4 cells' response to their preferred grating below the sum of their single-grating responses (cross-orientation suppression), mean XOS ⟨m⟩ (95 % t interval ⟨lo⟩ to ⟨hi⟩; one-sided p ⟨p⟩; instance values ⟨values⟩)"
- Dc: "at unequal contrasts the cells preferring the stronger grating kept more of their single-grating response than those preferring the weaker one (winner-take-more), mean Dc ⟨m⟩ (95 % t interval ⟨lo⟩ to ⟨hi⟩; one-sided p ⟨p⟩; instance values ⟨values⟩)"
- ds: "the controller's frozen readout of a plaid of gratings 45 degrees apart pointed further toward the stronger grating than the sum of its readouts of the two gratings, by a mean of ⟨m⟩ signal units (95 % t interval ⟨lo⟩ to ⟨hi⟩; one-sided p ⟨p⟩; instance values ⟨values⟩)"

**Clauses for the other categories** (⟨name⟩ is XOS, Dc or ds):
- PRESENT BELOW THE MARGIN: "⟨name⟩ departed from a relay in the pilot's direction on average (one-sided p ⟨p⟩, passing Holm), but the mean of its six instance estimates, ⟨m⟩, is below the declared margin of 0.10 (instance values ⟨values⟩)"
- RELAY-LIKE: "⟨name⟩ stayed within ±0.10 of a relay on average over the instances (mean ⟨m⟩, 90 % t interval ⟨lo⟩ to ⟨hi⟩), which does not rule out a smaller departure"
- REVERSED IN AN INSTANCE: "⟨name⟩ was not shown on average (mean ⟨m⟩, one-sided p ⟨p⟩), and in ⟨where⟩ it departed from a relay in the opposite direction (⟨details⟩)"
- NOT REPLICATED: "⟨name⟩ was not shown on average over the six instances (mean ⟨m⟩, one-sided p ⟨p⟩; instance values ⟨values⟩)"
- NOT ESTIMABLE: "⟨name⟩ was not estimable in ⟨where⟩ (⟨details⟩)"

**The p in a clause.** The p in a REVERSED IN AN INSTANCE or NOT REPLICATED clause is that measure's own one-sided p, printed so that it stays on its side of its own Holm threshold; it does not say that the measure missed that threshold. Holm's step-down can leave a measure unrejected with a p below 0.025, even below its own threshold, when a measure with a smaller p was not rejected first: one-sided p of 0.0090, 0.0100 and 0.0200 reject none, because 0.0090 is above the first threshold, 0.0083, so 0.0100 is never compared with its own 0.0125. At the tie, a p of exactly 0.025 whose 95 % t interval starts at 0 is not rejected either (Decision rule, "Rejected"). `results.json` records Holm in full: for each measure its one-sided p, its Holm threshold (by the rank of its p), whether Holm rejected it and whether the rule rejected it (`rule.measures`), and Holm's order, thresholds and rejected list (`rule.holm`). When a clause shows such a p, the result package's README and the journal note state the three thresholds, 0.0083, 0.0125 and 0.025, and Holm's order.

**NOT CONFIRMED:** "On six network instances that had never been built (pynn_seed ⟨seeds⟩), none of the measures that instance A's pilot handed on was confirmed as a mean over instances: ⟨clauses⟩. Instance A's GO stands as a result about one instance only. Any continuation is a new declared protocol, sized with the noise and the spread between instances measured here, never with these estimates." If all three measures are RELAY-LIKE, it adds: "On average over the instances, layer 4 and the readout combined the two gratings like a relay within ±0.10 (90 % t intervals); this does not show that no smaller departure exists."

**The limit beside "had never been built".** The CONFIRMED and NOT CONFIRMED texts keep 023's words: "never built" is defined by the records that exist (Instances), and a new wording would need its own review of the texts. Revision 2 reruns the calibration for its new slots, not for any text. The limit is stated beside them: the server half of the seed search ran with round 3's script on 3 November 2026 at 00:29:38Z, the final script ran only on the Mac, and the server's files can no longer be read. The result package's README and the journal note that report any outcome print that sentence next to the fixed text. This revision adds beside it its own search of the Mac's run folders for seeds 8 to 14 (Instances), and one sentence that the README and the journal note print beside any outcome: each analysed instance's export was one of two runs with identical inputs that agreed on every spike train, and S15 gives the share of completed runs that disagreed with their instance's agreeing pair, an estimate of the one-off fault rate that runs low (Secondary measures).

**What follows, declared now** (in the results as `what_follows`):
- CONFIRMED: "A confirmed XOS or Dc is a property of this model circuit as a whole, input stage and cortex together, as a mean over fresh instances of its map. Whether the cortex computes it stays open: that needs a comparison that keeps tuning (the inhibition-only variant) or the conductance follow-up declared in protocol 022, each in its own declared protocol. A confirmed ds changes no controller: a two-signal controller would still need its own declared encoder, with c1 + c2 at most 100 % and contrast independent of orientation."
- NOT CONFIRMED: "The plaid line pauses for the controller."
- NOT INTERPRETABLE: "A rerun needs a new declared revision."

### Integrity checks per instance (023's successor to the 30 % check)
A blind checker (`controller/check_instance_023.py`) checks exports with the same frozen code in two places: on the Mac that ran the model, right after each completed run (**the server check**: `check_instance_023.py server`, run by the queue from the run folder's copy of the frozen package in `check/`; the name stays from the server design), and on the Mac after the fetch (**the local check**: `check_instance_023.py check`, from the frozen package), for the export to analyse of each instance and for the earlier export of a pair that stopped the queue. It computes no plaid quantity: it reads only the 45@30 and 135@30 singles (the LGN and the 45° and 135° layer 4 groups, in G), the LGN lead-in and the export's own records. The server checks and the comparisons decide the paired rule and the early stop; the local check decides validity and the replacement rule, as in 023.

**Before any check, a stop (no record is written):** the local check stops unless its own code and the code it imports are the frozen manifest's, the manifest records that every test passed at the freeze, and the export is `FETCHED_DIR/exports/sK-aN.json.gz` (attempt N's), a regular local file (not an iCloud placeholder) whose SHA-256 is the host's, as `fetch_023.sh` recorded it in `data-sha256.txt`. The server check stops unless its running code is the code the contract was made from (the contract's `made_from`) and protocol 017's package matches its pins, and the export is the attempt's own regular file (`runs/sK-aN.json.gz`). Either stops if the file changes while it is checked. A read failure is never an integrity refusal: an export that cannot be parsed is read a second time, and refused as 'unreadable' only when it fails again while its bytes read without an error and still have the checked SHA-256, so that the fault lies in the export's content, not in reading it. A fault of the Mac's copy (a missing file, a placeholder that did not download, a damaged copy, a mistyped path, a read error of the disk) therefore spends no reserve: the file is fetched again and checked again. Only a check of the export's content writes a refusal. Every record holds the checker's and the contract's SHA-256, says where it was made (server or local), and is written once.

**Each check twice, and each record whole** (revision 2, for the one-off faults of this Mac, limit 9). Each check computes its verdict twice, one computation after the other, each from its own read of the export, the contract and the lead-in reference, and writes its record only when the two give the same verdict, refusals and kinds. Otherwise it writes nothing and stops, as a check that could not be made: the queue stops (exit 2) and `resume` makes the check again; a local check is made again. A one-off fault inside one check then costs a resume, not a reading or the reserve. Every write-once record of the checker, the comparison tool and the archive tool is written to a temporary file in the record's folder, flushed to disk, and linked to its final name, which fails if that name exists (so write-once holds); the folder is then flushed and the temporary file removed. A power loss therefore leaves the whole record or none, and a leftover temporary file is not a record: the tool that made it removes it when it runs again.

**Refusals,** each of which makes the instance invalid, each recorded with its kind:
1. **The export is not the declared run ('run'), or the host's bytes cannot be parsed ('unreadable').** It must be readable and complete, and:
   - its run name is m23-sK-intact-aN, with N from 1 to 9 (023: -a1 or -a2), for its pynn_seed K, and its argv the declared command: `nest 4 param_spont/defaults`, the three reduction overrides, `pynn_seed K` and the run name;
   - its resolved weights and seeds are 017's intact-A entry with `pynn_seed` K (`mpi_seed` 1023), and its NEST kernel records rng_seed 42 with 4 threads;
   - its steps are the instance's declared sequence file, with 30 + 21 frames of 7 ms, 72 lead frames, 0.8 cpd and 2 Hz;
   - it has one presentation with one sequence segment per sheet, the LGN cache recorded as disabled, and well-formed neuron tables and spike trains (AP's checks, reused unchanged).
2. **The LGN band ('lgn_band').** The X_ON and X_OFF mean counts per cell in G at 30 % (the 45° and 135° singles) must lie within 0.90 to 1.10 of 8.06 and 5.73 (SPEC:206; PS's `validation`, unchanged). LGN rates matched within 0.5 % between A and B, and the pilot's ratios were 0.996 and 0.998 (README:188-194).
3. **The LGN lead-in identity ('leadin_identity').** Every X_ON and X_OFF cell's spike times in the 504 ms lead-in must equal the pilot intact export's (`952b469b…`), with the same cells. The reference is `leadin-reference-023.json` (SHA-256 `126485e68db25f813f33f9c3a34c55f025c60bba3f2564f8cc64ac4c9a893645`; 1,800 X_ON and 1,800 X_OFF cells, 15,605 and 6,947 spikes), extracted from that export by `make_leadin_reference_023.py`. A, B and the pilot already match node by node, so any difference means the engine, a library or the environment differs from the pilot's. On the Mac this identity holds only through the engine's noise-order patch: the tiny regression on the patched build equals its reference in 30 of 30 X_ON and 30 of 30 X_OFF trains (old build 6 and 9), at 2 threads; G4 tested it at 4 threads on the 2 mm model: all 3,600 trains equal the pilot's over the whole 35,133 ms, so also in this lead-in (Stated limits of the Mac run, limit 8). The reference, the check and the band stay as they were. In 023 this check refused s7's export for a one-off fault of that run (History); under the paired rule a refusal of a run that disagrees with its instance's other runs is recorded as a one-off fault, not a stop.

**Reported only, never a refusal or a replacement:**
- the layer 4 band: the 30 % own singles of the 45° and 135° groups, within 0.80 to 1.25 of 2.97 and 2.18 counts (SPEC:204). Instances legitimately differ (B's preferred responses were 1.00 to 1.06 times A's), and refusing on a response level would select instances; engine integrity is covered by refusals 1 to 3;
- group sizes (915, 721 and 1,071 cells in A; 933, 745 and 1,107 in B) and the NEST kernel's other records.

**Attempts.** Each seed's attempts are numbered in the order they start, a1 to a9, and each has its own run name (m23-sK-intact-a1 to m23-sK-intact-a9), export (`runs/sK-aN.json.gz`), receipts (`runs/sK-aN-*`) and Mozaik result folder. Every attempt of a seed has identical inputs: the same frozen files, engine, environment, sequence file and argv but the run name. Each attempt ends in one of these ways, read from its receipts:
- **completed:** exit 0, its export a regular file at `runs/sK-aN.json.gz`, the server files unchanged during it, and its server check made (a pass or a refusal). Only completed runs are compared, and only they count toward the cap;
- **killed for memory** (memcap's exit 99): the seed is invalid at once and gets no further attempt, as in 023 (risk 10);
- **a counted failure:** any other non-zero exit (a crash), exit 0 with no regular export (`no export`), a timeout (exit 124) or a kill (exit 137: GNU timeout's own kill 10 min after its timeout, or a SIGKILL from outside, such as macOS's memory killer; GNU time passes either on as 137, so the receipts name it a kill, not a timeout; the queue then pauses after either), a change of the server files during the attempt (the queue then stops), or an interruption (no exit receipt, or one that is empty or not in its form: a reboot, a power loss, a queue that was killed). Two counted failures make the seed invalid (`failed twice`, as in 023), whatever its completed runs;
- **stopped at the disk floor** (memcap's exit 98): not counted (023 counted it); the queue waits for free disk and then goes on, and pauses (exit 4) only if the disk stays short (The Mac queue, "Failures and pauses"). Another program on this Mac moves the free disk by up to about 3 GiB (`diag-023/rate/README.md`), so counting these stops would let that program make an instance invalid; the stop depends on the free disk, not on the run's output, so not counting it selects nothing.
An attempt never started is not an attempt. **The cap:** at most four completed runs per seed (a1 and a2, then a third and, if needed, a fourth: the owner's decision). Failed attempts and disk-floor stops also take numbers, so a seed has at most nine attempts; a seed that would need a tenth is invalid (`attempts used up`), which takes at least five disk-floor stops on one seed (nine attempts with at most three completed runs and one counted failure). So the disk floor costs time, and an instance only after five such stops on one seed.

**The paired rule.** For each seed, after each of its completed runs R_j (in attempt order), once its server check is made:
1. If R_j is the seed's first completed run, the next attempt runs.
2. Otherwise R_j is compared with each earlier completed run R_i of the seed, in attempt order, by the frozen comparison tool, until one agrees. At most one can agree: agreement is equality, so two earlier runs that both agreed with R_j would have agreed with each other, and the seed would have stopped there.
3. If R_j agrees with R_i, (R_i, R_j) is the seed's **agreeing pair**, and no further attempt runs for the seed. By the two server checks:
   - both passed: the seed's status is `agreed aI aJ`, and the instance is valid once the local check passes the export of R_i, the earlier run, which is the export analysed;
   - both refused, with the same refusal kinds: the early stop (below);
   - one passed and one refused, or both refused with different refusal kinds: the stop with no reading (below).

   **The same refusal kinds** means that the two server check records' `kinds` lists are equal. The refusal texts are not compared: a 'run' refusal quotes the command line, run name included, so two agreeing runs refused for the same reason have different texts. The comparison tool applies this definition when two exports agree (its exit code, below), and the summary applies the same definition to the server records and stops if the tool's record says otherwise.
4. If R_j agrees with no earlier run and the seed has fewer than four completed runs, the next attempt runs. A refusal by the server check among these runs is recorded with its kinds as a one-off fault (023's s7 refusal was one) and stops nothing.
5. If R_j agrees with no earlier run and is the seed's fourth completed run, the seed is invalid: `no agreeing pair`.
Before each attempt the queue applies the failure rules first: killed for memory, failed twice and attempts used up end the seed as invalid. A seed's status file `runs/sK-status.txt` holds one of `agreed aI aJ`, `no agreeing pair`, `failed twice`, `killed for memory` or `attempts used up`. Whether the instance is valid comes from the checks, never from the status alone.

**What "agree" means.** `controller/compare_runs_023.py` (new, frozen; derived from CMP, whose validation becomes its tests) compares two exports of one seed. They agree when, read as JSON values, they are equal in every field but two: the run name (the last element of `argv`) and `run_seconds` (the wall-clock time of the run); and each export's run name must be its own attempt's, `m23-sK-intact-aN`, so that a fault in one run's name is a disagreement that costs one more run, never an agreeing pair whose server checks differ (code review of 8 November). So all 18,600 spike trains of the six sheets in the sequence segment, which spans [0, 35,133] ms, are equal spike for spike at the export's 0.01 ms precision, and so are the neuron tables (ids and positions), the trains of the end-of-simulation blank segment, the stimulus records, the resolved parameters and seeds, the NEST kernel's records and the rest of `argv`. This is stricter than CMP's window, [0, 35,133) ms, which leaves out spikes at exactly 35,133.0 ms; the exports hold such spikes (4 of the 6 sheets of d5). Measured before this draft, by a read of field equality only, with no plaid quantity: d5 and rate-r1, two diagnosis runs of seed 7, are equal in every field but those two, and so are the server pilot's intact export and G4's, made on two platforms. Each comparison writes `runs/sK-aI-aJ-compare.json` once, with both exports' SHA-256s, the tool's and the contract's SHA-256s, the verdict, and for a disagreement each differing field, a run name that is not its attempt's, and, per sheet, the number of differing trains, the first differing time and the differing cell ids (all of them in the LGN, the first 20 in a cortical sheet), with any NaN or infinity in them written as text so that the record stays strict JSON; for an agreement, both server checks' verdicts and kinds and whether they are the same (both passed, or both refused with the same refusal kinds). The tool first checks, as the server check does, that its running code is the code the contract was made from, and only then looks for the exports. It exits 0 when the exports agree and their server checks are the same, 4 when the exports agree and their server checks differ, and 3 when the exports do not agree; any other exit means no comparison was made, and the queue stops (exit 2) until `resume` makes it again (a record already written is read, never repeated). An export the tool cannot parse is read a second time; if it fails again while its bytes read cleanly with the SHA-256 its server check recorded, it agrees with no other export (exit 3, recorded as unreadable). It runs under memcap with a timeout of 30 min (about 3 s and 0.87 GiB for one pair, measured). It reads spike times and records only, and computes no plaid quantity.

**The early stop.** Revised for the paired rule. Two agreeing runs of one instance have equal exports but for the run name and the time, so the blind check gives them the same verdict and the same refusal kinds. When it refuses both with the same kinds, the refusal belongs to that instance's identical runs, not to a one-off fault: it is taken as systematic, as 023 took its first refusal. The server check runs right after each completed run, under timeout 1h and before the next attempt starts, as in 023. At an agreeing pair that both checks refused with the same refusal kinds (the comparison tool's exit 0 with both server checks refused), the queue writes `runs/early-stop.txt` (one line: `<UTC> early stop: pynn_seed K, runs aI and aJ agree and the server check refused both (record SHA-256 X and Y)`), then `sK-status.txt` (`agreed aI aJ`), and exits 5; no further attempt or reserve runs, and the queue, `launch_023.sh resume` and `reserve` refuse from then on. The protocol is NOT INTERPRETABLE with that refusal as its condition, once the local check of R_i's export has refused it too; if the local check passes it, the two checks of one file disagree and the summary stops (no reading), as in 023. A systematic fault that every run repeats exactly and that the checks catch now costs two runs, not one; one whose details vary from run to run never forms an agreeing pair and costs eight runs (risk 14). The checker is blind, so the early stop unblinds nothing.

**Every combination for one seed** (P a pass by the server check, R a refusal):

| The seed's completed runs | Server checks | What follows |
| --- | --- | --- |
| a pair agrees | P and P | valid once the local check passes the earlier export; the seed's other runs, if any, are one-off faults (S15) |
| a pair agrees | P and P, and the local check refuses the earlier export | the slot is invalid; the replacement rule (023's path) |
| a pair agrees | R and R, the same refusal kinds | the early stop: systematic; NOT INTERPRETABLE once the local check refuses too |
| a pair agrees | R and R, the same refusal kinds, and the local check passes the earlier export | the stop with no reading (the summary stops) |
| a pair agrees | one P and one R, or R and R with different refusal kinds | the stop with no reading (exit 6) |
| no pair agrees yet, fewer than four completed | any | the next attempt; each refusal is a one-off fault, recorded, never a stop |
| four completed, no pair agrees | any | the seed is invalid (`no agreeing pair`); the replacement rule |
| a refused run, then a pair that agrees and passes | R, then P and P | valid; the refused run is a one-off fault the check caught |
| a passed run that disagrees, then a pair that agrees and passes | P, then P and P | valid; the disagreeing run is a one-off fault the check missed |
| a passed run that disagrees, then a pair that agrees and is refused | P, then R and R | the early stop; the passed run is a one-off fault |

**The stop with no reading.** If the server check passes one run of an agreeing pair and refuses the other, or refuses both with different refusal kinds (the comparison tool's exit 4), the checker gave two verdicts on what is, but for the run name and the time, one export, although each check computed its verdict twice: a fault of the check, not of a run. The queue writes `runs/checks-disagree.txt` (one line: `<UTC> pynn_seed K: runs aI and aJ agree, but the server checks of them differ (record SHA-256 X and Y)`), then `sK-status.txt` (`agreed aI aJ`), and exits 6; the queue, `resume` and `reserve` refuse from then on, and the summary stops: the protocol ends without a reading (Decision rule, "No reading").

**The replacement rule:**
- A slot is invalid if its seed ends `no agreeing pair`, `failed twice`, `killed for memory` or `attempts used up`, or the local check refuses the export of its agreeing pair that the server checks passed (023's path for a local refusal, unchanged). This is the one disagreement between the server check and the local check that does not stop the summary: the local check decides validity, as in 023, and the two run under different Pythons and numpy versions (limit 4), so a refusal by the local check alone is taken as the instance's, not as a fault. The other direction, a local pass of an export the server check refused, stops the summary (Decision rule, "No reading").
- The one reserve, 14, takes the first invalid slot. If the reserve is itself invalid, for any of those causes, no reserve is left for that slot. At most one replacement is made.
- **The one record.** As in 023, the queue writes `runs/replacements.txt`, in time order, one line per decision: `reserve 14 for slot S: CAUSE`, or `no reserve left for slot S: CAUSE`. CAUSE is one of `the run failed twice`, `the run killed for memory`, `no agreeing pair in four runs`, `the attempts used up` and `refused by the blind checker (check record SHA-256 X)`, or the same with `reserve 14` for the reserve. The queue writes these lines for its own seeds' endings and for a local refusal given to it by `launch_023.sh reserve`, as in 023.
- **A stop as soon as six valid instances cannot be reached.** After each seed settles, the queue counts the slots that need a reserve (their own seed, or the reserve standing for them, invalid by its runs); as soon as that count is larger than the unused reserves (two invalid slots with one reserve), there cannot be six valid instances: the queue records nothing more and exits 1 at once, and no further slot or reserve runs. 023 ran all six slots first and judged the reserves after. The change saves up to four slots' runs when the protocol is already NOT INTERPRETABLE, and changes no outcome.
- **The analysed instances** are the valid slots and the valid reserve that filled an invalid slot, by the record, each represented by the export of the earlier run of its agreeing pair. The texts list them in pynn_seed order, so the outcome does not depend on which slot the reserve filled; the summary and the results keep which reserve filled which slot and why.
- `launch_023.sh reserve` and the summary work as in 023, with one reserve: before any `reserve`, the owner's agent makes the local check of every fetched export and runs the summary (into a new file each time); when it says fewer than six valid instances, no reserve runs.
- Replacements are decided from the queue's receipts, the comparison records and the local check records only, before the analysis (`check_instance_023.py summary`). The summary rebuilds each seed's state from its attempts' receipts, its server check records and its comparison records by the paired rule, and stops, writing nothing, unless the queue's statuses, `early-stop.txt`, `checks-disagree.txt` and `replacements.txt` are the rule's; unless every server check record and comparison record was made by this frozen code for this contract on the host's exports (`data-sha256.txt`); and unless every completed attempt's receipts show exit 0 and the same server-file hashes at its start and end. A disagreement means the runs did not follow the declared procedure; a new declared revision then decides. The analysis runs once, after all six are valid; it computes its results twice, one computation after the other, each from its own reads of the contract, the summary, the records and the exports, and writes `results.json` only when the two are the same, otherwise it writes nothing and stops and is run again (code review of 8 November: `results.json` is the one record that is final, so a one-off fault inside the analysis costs a rerun, not the outcome). With fewer than six, the protocol is NOT INTERPRETABLE.

### Fences
- `results.json` is opened with mode 'x', as AP does. Its SHA-256 is recorded in HANDOFF before any other reading of this revision's exports.
- Any exploratory reading of this revision's data (its exports, receipts, check and comparison records, archives and Mozaik folders) gets its own manifest, frozen before it reads any of them, as 023's fence said and as 023's diagnosis did not do (History). It can never change, qualify or repeat this revision's outcome. The declared procedure's own reads are not exploratory: the queue, the server checks, the comparisons, the archive's verification, the fetch, the local checks, the summary and the analysis. Looking at a disagreeing run beyond what its comparison record holds, during or after the queue, is exploratory and needs its manifest first.
- This revision's procedure reads none of 023's data and none of the diagnosis's, with two exceptions that are design inputs and read no plaid quantity: the comparison tool's validation on real exports (d5 against rate-r1, measured before this draft) and the seed search, which reads run records for seed numbers only. Any other reading of 023's data still needs its own manifest, under 023's fence.

### Sizing from the pilot's noise only
**Inputs:**
- **Noise:** the pilot intact run's noise model, rebuilt from RES `measures.intact.per_step` by PS's `Fit` (it reproduces RES's recorded variance functions to the last digit). Each synthetic instance draws the pilot's 96 standardised whole-step residual vectors with replacement, so a step's groups and readout keep their correlation.
- **Truths:** 022's calibration model through 017's instance-A anchors (`outputs/felisyn-research/protocol-022/test_plaid_stats.py:734-781`, copied unchanged): blank 0.47 counts, 2.83 at 30 % and 3.50 at 100 %, a Naka-Rushton curve at exponent n = 1.5, 2 or 3, and readout magnitudes 6,114 and 8,067. Each measure is set by its own calibration weight; the three weights act on different plaids and are separable. The weights range over each measure's monotone stretch (XOS −3 to 3, Dc −3 to 1, ds −10 to 3), wider than 022's 0 to 1, because 022's range cannot make ds larger than 0.218 at n = 3 or 0.319 at n = 2. A first run of this calibration used weights up to 0.95 (ds up to 0.207 and 0.302), clipped those targets silently, and was stopped; a test now requires every declared target (μ ± 4τ) to lie inside the range, and the record shows how many fell outside.
- **Instances:** instance i's true value of measure m is θ_im = μ_m + τ·z_im, with z_im standard normal.
- **Analysis:** the final code's per-instance analysis (PS's Fit, boot_means, primaries and primary_results, on each slot's declared order and the first 1,000 replicates of its declared draw), then `confirm_023.outcome` over the six.
- **Never used:** any pilot estimate of XOS, Dc or ds, the pilot's single-grating means and its S8 fits.

**The planning point:** μ = 0.15 for one measure at a time, the other two at μ = 0, all three spread by τ_plan = 0.05.

**The sizing rule (declared):** six instances of the pilot's 97-step design (the design taken, History), checked, not searched: P(CONFIRMED) for each measure alone at the planning point must be at least 0.80 at every n in {1.5, 2, 3}. If the calibration on the final code misses this gate, the design is revised before the declaration.

**Results** (this revision's calibration of 9 November 2026, on slots 8 to 13; The calibration, below): P(CONFIRMED) for each measure alone at a true mean of 0.15.

| τ | n | XOS | Dc | ds |
| --- | --- | --- | --- | --- |
| 0 | 2 | 1.000 | 1.000 | 1.000 |
| 0.03 | 2 | 0.999 | 0.998 | 0.999 |
| **0.05 (τ_plan)** | **1.5** | **0.967** | **0.969** | **0.979** |
| **0.05 (τ_plan)** | **2** | **0.956** | **0.958** | **0.967** |
| **0.05 (τ_plan)** | **3** | **0.950** | **0.941** | **0.977** |
| 0.075 | 2 | 0.779 | 0.787 | 0.795 |
| 0.10 | 2 | 0.527 | 0.543 | 0.557 |

- **The sizing gate holds,** with a worst case of 0.941 (Dc at n = 3).
- **Sensitivity, reported only:**
  - five instances at τ = 0.05: 0.889, 0.870 and 0.914; seven instances (023's cell held eight, the six slots and both reserves' orders; this revision's holds the six slots and the reserve's order) at τ = 0.10: 0.655, 0.687 and 0.693;
  - one instance at μ − 3τ: 0.597, 0.631 and 0.682; t3-shaped spreads: 0.947, 0.949 and 0.959;
  - step noise 0.85, 1.15 and 1.5 times the pilot's: 0.969 to 0.981, 0.941 to 0.970, and 0.905 to 0.956;
  - all three measures real at 0.15, so that Holm's later steps are used: 0.982, 0.981 and 0.985 at τ = 0.05, and 0.679, 0.695 and 0.707 at τ = 0.10.
- **A larger spread costs power, not validity:** at τ = 0.10 a real mean of 0.15 is confirmed 0.53 to 0.56 of the time, and the false rates below stay inside their gates.

### The calibration on the final code, and its gates
- **What was simulated.** Synthetic six-instance protocols of exactly this design (`calibrate_023.py`): each slot's declared order and the first 1,000 replicates of its declared draw, the pilot's noise model, 022's 017-anchored truths (Sizing), the final per-instance analysis (`confirm_023.instance_primary`) and `confirm_023.outcome`, with the one-sided family-wise level of 0.025 and the tie rule. 108 scenarios, with 3,000 protocols per relay, contrast, boundary or half-margin scenario and 1,500 per power, margin or sensitivity scenario (Monte Carlo SE about 0.003 at 0.025 and 0.010 at 0.80).
- **This revision's run.** The calibration reruns on the final code with `calibrate_023.py` unchanged, because two of its inputs change: `confirm_023.py` (the slots 8 to 13, the reserve 14, the excluded seeds and the NOT INTERPRETABLE text) and the slots' declared orders and draws (8 to 13 in place of 7 to 12). The calibration JSON records the SHA-256 of every file it depends on, and `test_calibration_023.py` refuses a calibration made on other files, so 023's records cannot stand for this revision. Its scenarios, Monte Carlo sizes and gates G1 to G6 are 023's; the sensitivity cell of eight instances becomes seven (the six slots and the reserve), and the cell of five stays. About 2.3 h in one process (023's run: 8,286 s, 194 MB). It depends only on `confirm_023.py`, `plaid_stats.py`, the two sequence generators, the sequence files and `calibrate_023.py`, so it can start as soon as `confirm_023.py` is final. It ran on 9 November 2026, after the rehearsal, as the one heavy job of this protocol; its records and their SHA-256s are below (When and where), and every figure quoted in this section and in Sizing is that run's; 023's records stay unchanged in p023.
- **When and where.** On the Mac, 9 November 04:00:47 to 06:22:43 UTC, one process (8,525 s, maximum resident set 161 MB by GNU time's 156,928 kB; memcap's sampled peak 0.151 GiB), exit 0, complete, all 108 scenarios; the start, end, exit and memory records are in `p023r2/testphase/t2-cal/`. It is this revision's first and only full run and the only gate; 023's four runs stay unchanged in p023, and the copies of 023's gate-run records that came with this working tree are kept, with their SHA-256s, in `p023r2/testphase/calibration-from-023/`. Records: `calibration-023.json` (SHA-256 `813b2383153824736980e4c30972fe727c9921a22159d61e25198451e726db46`) and `calibration-023.log` (`7f61c8da2f7f4b175c603d9c5fa738c2f7986336b6d18ec2ee8cee8f8388fb76`). The JSON records the SHA-256 of every file it depends on, and `test_calibration_023.py` refuses it if any of them has changed.
- **Scenarios:**
  - the task grid: spreads τ of 0, 0.03, 0.05, 0.075 and 0.10, at true means of 0 (a relay, all three measures), 0.10 (the margin) and 0.15 (each measure alone), at n = 2;
  - the gate cells at n = 1.5 and 3 (τ 0.05), and relays at n = 1.5 and 3 with τ of 0, 0.05 and 0.10;
  - the shared noise stream, with each instance's own order: the same residual rows in every instance (correlation 1), and residuals correlated 0.44 between instances (017's shared residual of A and B under one order); and, as a contrast that is never a gate, residuals correlated 0.44 with one order for all (τ of 0 and 0.05);
  - 022's four kinds of noise the analysis does not model (plaid noise 1.4 and blank noise 0.4 times the fitted function, t3 residuals, a ±5 % drift, a history gain of −0.07 per 100 %) and a history gain of −0.15 per 100 %;
  - t3-shaped and correlated (0.5) spreads, one instance at μ − 3τ, per-instance operating-point shifts (group gains SD 6 %, cross drives SD 0.04, readout gain SD 6 % and rotation SD 2°), step noise scaled by 0.85, 1.15 and 1.5;
  - Holm's boundary null (the tested measure at 0, the other two at 0.30), half the margin (0.05), five or eight instances (sensitivity only), and all three measures real at 0.15 (τ 0.05 and 0.10, reported only).
- **The gates** (asserted by `test_calibration_023.py`; they decide, not the figures quoted here). They are 023's gates, unchanged. All pass:
  1. **G1, false CONFIRMED** under a relay, family-wise, at most 0.025 (the declared level) in every relay scenario with own orders: at most 0.0093 (τ = 0.10, n = 3), and at most 0.0003 at τ ≤ 0.05. Under Holm's boundary nulls the null measure is never CONFIRMED.
  2. **G2, power** for each measure alone at 0.15 and τ_plan = 0.05, at least 0.80 at n = 1.5, 2 and 3: 0.941 to 0.979.
  3. **G3, per-instance coverage** of the 95 % intervals at least 0.93 in every scenario without noise the analysis does not model: 0.942 to 0.955 (0.930 to 0.959 with it, reported).
  4. **G4, the test's validity:** under every relay with own orders, the rule rejects some measure (CONFIRMED or PRESENT BELOW THE MARGIN) in at most 0.025 plus 3 Monte Carlo SE (0.034) of protocols: 0.018 to 0.028. Under the boundary nulls the null measure: 0.019 to 0.029.
  5. **G5:** XOS is NOT ESTIMABLE in at most 0.10 of protocols under the operating-point shifts: at most 0.012.
  6. **G6:** a true mean of half the margin (0.05, τ 0.05) is CONFIRMED in at most 0.05 of protocols: 0.010 to 0.014.
  - Also asserted: no more than 0.001 of the targets outside the truth tables (largest 0.0008, in the t3-spread cells only), and the one-order contrasts and the five- and eight-instance cells (five and seven in this revision) are never gates.
- **At the margin** (a true mean of exactly 0.10), CONFIRMED in 0.43 to 0.50 of protocols at τ ≤ 0.05 (n = 2), 0.32 to 0.34 at τ = 0.075 and 0.22 to 0.24 at τ = 0.10. The margin is a gate on the mean of point estimates, so about half of protocols at the margin confirm when the spread is small.
- **The shared noise stream:** with each instance's own order, a relay is rejected in 0.028 (the same rows, τ = 0), 0.023 (the same rows, τ = 0.05) and 0.025 (residuals correlated 0.44, τ = 0) of protocols, and power with the same rows is 0.963 to 0.975. With one order for all at a correlation of 0.44, a relay is rejected in 0.264 of protocols at τ = 0 (each measure 0.10 of the time) and 0.065 at τ = 0.05, and is CONFIRMED in 0 and 0.0007 of them only because of the margin. Own orders are what keep the t-test valid under the shared stream.
- **Noise the analysis does not model:** a relay is rejected in 0.021 to 0.025 of protocols, and power is 0.950 to 0.973.
- **Secondaries:**
  - the 95 % t interval of the mean covered the population mean in 0.932 to 0.965 of protocols (normal spreads with own orders, without outliers, shared rows, operating-point shifts or unmodelled noise; under shared rows the XOS coverage falls to 0.919 in the relay at τ = 0);
  - the between-instance SD by moments averaged 0.044 to 0.046 at τ = 0.05 (an SD from five degrees of freedom runs low), and its interval covered τ in at least 0.935 of protocols;
  - under a relay the instance estimates' mean bias was −0.0016 (XOS), +0.0002 (Dc) and +0.0001 (ds) at n = 2, and −0.0028 (XOS) and −0.0011 (Dc) at n = 3: the XOS bias is against the pilot's direction, so conservative for its one-sided test, and the Dc and ds biases at n = 2 are within about one Monte Carlo standard error of zero (0.0002);
  - one instance's estimate has an SD of 0.031 (XOS), 0.029 (Dc) and 0.023 (ds) at n = 2, and 0.037, 0.034 and 0.025 at n = 3.

## Paired runs: sizing at the measured fault rate
**The model.** Each completed run of a seed has a one-off fault with probability p, independently of every other run; a faulty export agrees with no other; two runs without a fault agree (measured: d5 and rate-r1; G4 against the server pilot; the rehearsal's s6-a2 and s6-a3). A seed then runs until its second fault-free run, up to the cap of completed runs. The queue runs the six slots in order, gives the reserve to the one invalid slot after them, and stops as soon as two slots are invalid. Failed attempts, systematic faults and the minutes of checks between runs are left out (Attempts; the early stop; Cost).

**The measured rate:** 1 fault in 6 full-length runs with a spike-level check (G4, s7, d5, rate-r1, and the rehearsal's s6-a2 and s6-a3, which agreed: Rehearsal before the declaration): p = 1/6 = 0.167, with a 95 % Clopper-Pearson interval of 0.0042 to 0.641. The planning value is 1/6; the sensitivity rows show the rest of the interval. The rehearsal's first attempt, s6-a1, stopped at the disk floor and is no completed run, so it does not count. **The re-sizing of 9 November.** This draft was sized at the earlier tally, 1 fault in 4 (G4, s7, d5, rate-r1: p = 0.25, interval 0.0063 to 0.806), until the rehearsal's two clean runs changed the measured rate; the rehearsal section requires the sizing to be redone then, before the declaration (the skeptic's note 1 on the rehearsal). The re-sizing changes no choice: the cap stays four and the reserve one. The earlier figures are kept below, beside the new ones.

**Exact results.** Every fault pattern is enumerated with exact fractions by `work/controller-023/sizing_paired_023r2.py` (SHA-256 `91795ddad3cf174f012ab6b6c29ba382ae5b0fb77a710371e36ff729c2bf1257`; output `sizing-paired-023r2.txt`, SHA-256 `9baca9f8e0302a50ca0f0d8c1fda271f71b45a348296fede782bff44b12229e8`; a design record, not frozen code; the review of 8 November added the 95th percentile and the two-reserve comparison, and the re-sizing of 9 November added the lines for p = 1/6 after the earlier ones, which are unchanged; the versions before it, `7d74d463…` and `4ab012d1…`, are kept in `p023r2/testphase/sizing-1in6/`). Hours take 1.05 to 2.0 h per run (Cost) and, beside them, the rehearsal's measured run times, 1.33 to 1.74 h per run (1:19:38 and 1:44:07). The runs counted are completed runs: failed attempts and disk-floor stops add to them (Cost).

At the measured rate, p = 1/6:

| Cap (completed runs per seed) | P(a seed is invalid) | P(fewer than six valid instances) | Expected runs | Median, 90th, 95th and 99th percentile of runs | Most completed runs | Expected hours | Hours of the 95th percentile | Hours of the most completed runs |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 3 | 0.07407 | 0.0898 | 14.30 | 14, 17, 18, 19 | 21 | 15.0 to 28.6 | 18.9 to 36.0 | 22.1 to 42.0 |
| **4 (chosen)** | **0.01620** | **0.00522** | **14.48** | **14, 17, 18, 20** | **28** | **15.2 to 29.0** | **18.9 to 36.0** | **29.4 to 56.0** |
| 5 | 0.003344 | 0.000232 | 14.42 | 14, 17, 18, 20 | 35 | 15.1 to 28.8 | 18.9 to 36.0 | 36.8 to 70.0 |

At the rehearsal's run times (1.33 to 1.74 h) the chosen cap's expected runs take 19.2 to 25.1 h, its 95th percentile 23.9 to 31.2 h and its most completed runs 37.2 to 48.6 h.

At the chosen cap the exact chance of ending with fewer than six valid instances is 2444346978451553/467988280328060928 = 0.005223. One seed needs 2 runs with probability 0.6944, 3 runs 0.2315, 4 runs and is valid 0.0579, 4 runs and is invalid 0.0162: 2.38 completed runs per seed on average. A third run is needed at least once in about 89 % of protocols (only 0.6944 to the sixth power, 0.112, need none). 58 % of protocols need at most 14 runs and 95 % at most 18 (at most 17: 92.6 %). The most completed runs, 28, is every seed at four runs, one slot invalid and the reserve run too; each seed can also carry one counted failure, and disk-floor stops, which this count leaves out (Cost).

The earlier tally, p = 1/4 (kept as it was):

| Cap (completed runs per seed) | P(a seed is invalid) | P(fewer than six valid instances) | Expected runs | Median, 90th and 99th percentile of runs | Most completed runs | Expected hours | Hours of the most completed runs |
| --- | --- | --- | --- | --- | --- | --- | --- |
| 3 | 0.15625 | 0.3009 | 14.67 | 15, 18, 19 | 21 | 15.4 to 29.3 | 22.1 to 42.0 |
| 4 | 0.05078 | 0.04566 | 16.05 | 16, 20, 22 | 28 | 16.8 to 32.1 | 29.4 to 56.0 |
| 5 | 0.015625 | 0.00487 | 16.08 | 16, 19, 23 | 35 | 16.9 to 32.2 | 36.8 to 70.0 |

At p = 1/4 and a cap of four, the exact chance of fewer than six valid instances was 1644977959157585/36028797018963968 = 0.045657; one seed needed 2 runs with probability 0.5625, 3 runs 0.28125, 4 runs and valid 0.10547, 4 runs and invalid 0.05078; a third run was needed at least once in about 97 % of protocols; 62 % of protocols needed at most 16 runs and 95 % at most 21 (22.1 to 42.0 h).

**Sensitivity at a cap of four:**

| p | P(a seed is invalid) | P(fewer than six valid instances) | Expected runs | Median and 90th percentile of runs |
| --- | --- | --- | --- | --- |
| 0 | 0 | 0 | 12.00 | 12, 12 |
| 0.0042 (the interval's lower end) | below 0.0001 | below 0.0001 | 12.05 | 12, 12 |
| 0.05 | 0.00048 | 0.0000049 | 12.63 | 12, 14 |
| 0.10 | 0.0037 | 0.00028 | 13.36 | 13, 15 |
| 1/6 = 0.167 (measured) | 0.0162 | 0.0052 | 14.48 | 14, 17 |
| 0.25 (the earlier tally) | 0.0508 | 0.0457 | 16.05 | 16, 20 |
| 0.40 | 0.1792 | 0.3654 | 17.69 | 18, 22 |
| 0.50 | 0.3125 | 0.6964 | 16.54 | 17, 23 |
| 0.60 | 0.4752 | 0.9195 | 13.94 | 13, 21 |
| 0.641 (the interval's upper end) | 0.5474 | 0.9632 | 12.77 | 12, 20 |

At a high rate the expected runs fall, because the queue stops as soon as two slots are invalid.

**The choice: a cap of four completed runs per seed and one reserve.** Four is the owner's decision ("a third and, if needed, a fourth run"). At the measured rate of 1 in 6 it ends with fewer than six valid instances in about 1 protocol in 190 (0.52 %; at the earlier tally of 1 in 4, about 1 in 22), for an expected 14.5 runs, about 15 to 29 h of queue (19 to 25 h at the rehearsal's run times), with no new server and one run at a time under the cap of half the Mac's memory. A cap of three would end so in 9.0 % of protocols (30 % at 1 in 4) and is not taken. A cap of five would lower that to 0.023 % (0.5 % at 1 in 4) at almost the same expected runs (14.42), but would raise the most completed runs from 28 to 35 (up to 70 h) and goes beyond the owner's decision. A second reserve under 023's reserve rule would lower it to 0.022 % (0.60 % at 1 in 4; expected 14.51 runs, at most 32 completed runs), about what a cap of five gives, but it needs a new seed, 15, which no record of the research server covers: the server's last records searched for 7 to 14 and can no longer be read, so "never built" for 15 would rest on the Mac alone; it also needs a new sequence file. So the cap of five, which uses only seeds the records cover, was this draft's alternative; it was not put to the owner, and the owner's decision of four stands (Choices made for this revision). Above a rate of about 0.4 the paired rule would likely end NOT INTERPRETABLE; then the fault, not the design, is the problem, and S15 shows it. Six runs measure the rate only loosely: at the upper end of its 95 % interval, 0.64, a protocol would end with fewer than six valid instances 96 % of the time.

## The Mac queue, guards and cost
**Before the queue:**
- **Folder:** `<home>/felisyn-local/run-023r2` (023's `run-023` is never written), outside iCloud, set up as `launch_023.sh tier2` does it. The 19 model files come from `<home>/felisyn-local/engine` and are checked against 017's frozen list. The launcher refuses if a runs folder already exists. Its commands run on the Mac through `server/host_shell.sh`, which stands where the SSH helper stood.
- **Tier 2,** on the Mac venv's Python without NEST, under memcap, run by `launch_023.sh tier2` after the declaration and before the freeze. `server/tier2_imagen_check_023.py` is 022's check with its fixed module registration (a module loaded from a file path is put in `sys.modules` before it runs; 022's first tier 2 run failed without it, `work/controller-022/plaids/tier2/tier2-harness-fix-2026-10-27.md`). It checks: the model constants; version 3's frames equal version 2's for every two-number step of the seven instance files (8 to 14) and of 017's, 021's and 022's sequence files; for each instance file, that `generate_stimuli` builds one presentation of the whole sequence with the declared timing, that every frame lies in [0, 2L] with the declared structure, and that each plaid's component amplitudes and mean fit within 1e-9; and that Mozaik's `load_parameters` with the reduction and `pynn_seed K` resolves each instance's seeds and base weights to the contract's entries (017's `check_overrides.py` pattern; it builds no network).

**The queue** (`server/run_queue_023.sh`, started by `launch_023.sh start` from the frozen manifest):
- **Runs, one at a time:** slot by slot, `m23-s8-intact-a1`, `m23-s8-intact-a2` and further attempts as the paired rule calls for them, then s9 to s13, each attempt under memcap and timeout 12h, with `pynn_seed K`, `FELISYN_SEQUENCE` set to that instance's file and `FELISYN_EXPORT` set to `runs/sK-aN.json.gz`. The command is 023's: `python ../run_controller_mem.py nest 4 param_spont/defaults`, the three reduction overrides, `pynn_seed K` and the run name: the pilot's arguments through the memory wrapper.
- **After each attempt that exits 0** with its export a regular file and the server and runtime files unchanged (an attempt that exits 0 without one is a counted failure, `no export`): its server check (`check/controller/check_instance_023.py server`, under memcap with a 1 h timeout, writing `sK-aN-server-check.json` once), then the comparisons the paired rule calls for (`check/controller/compare_runs_023.py`, under memcap with a 30 min timeout, writing `sK-aI-aJ-compare.json` once), then the seed's next step by the paired rule: on the comparison's exit 0 the seed is `agreed aI aJ` if both server checks passed (valid once the local check passes) and the early stop follows if both refused; on its exit 4, the stop with no reading; on its exit 3, the next comparison or attempt. A server check or a comparison that cannot be made stops the queue (exit 2) without a status, and `resume` makes it again before anything else.
- **After each attempt settles** (its checks and comparisons made, or its failure recorded), its Mozaik result folder is archived (Disk, below), before the next attempt starts. On `resume`, the queue first archives every settled attempt that has no `archive/sK-aN-archive-removed.txt`.
- **Failures and pauses,** as Attempts states them: a memory kill ends the seed; two counted failures end it; a timeout counts, and the queue pauses so that its rerun does not start under the same fault (exit 4), until the owner's agent has read the attempt's receipts (heat, sleep or a hung run) and `resume` continues; a change of the server files counts and stops the queue (exit 2) until they are restored; a disk-floor stop is not counted; an interrupted attempt counts. **Waiting for disk:** before every attempt the free disk must be at least 1 GiB above the floor (a run writes about 0.1 GiB and may add a 1 GiB swap file, so an attempt started just above the floor would likely stop there after an hour or more); below that, and after a disk-floor stop, the queue does not exit: it checks the free disk every 5 min and goes on once it is at least 1 GiB above the floor, writing each wait (its start, end and the free disk) to `runs/disk-waits.txt`. A server check, a comparison or an archive that memcap stops at the disk floor is made again after the same wait, at most five times in a row (code review of 8 November). Only a wait longer than 6 h pauses the queue (exit 4) for the owner's agent and `resume`. Another program's disk swing then costs the time it lasts, not a night until someone resumes. **Waiting for another heavy job:** when a model run or a memcap job that is not the queue's own is alive before an attempt (another agent's test under memcap, say), the queue checks every 5 min and goes on once none is, and pauses (exit 4) after 6 h; the waits are in `runs/queue.log`. At launch the guard still refuses while one is alive. An attempt's exit receipt is written last, after its end receipts, so an attempt cut off before it (a reboot or a power loss, risk 17) is interrupted, never completed.
- **The reserve:** after the six slots, the one invalid slot gets reserve 14, which runs by the same rule. As soon as more slots need a reserve than reserves are unused, the queue records nothing more and exits 1 at once (The replacement rule). After the local checks, a refused export gets the reserve from `launch_023.sh reserve MANIFEST SHA256 SLOT CHECK_RECORD`, as in 023: the record must be a local check record that is a refusal, made for the frozen contract by the frozen checker, of the seed that stands for SLOT now.
- **The early stop** (exit 5) and **the stop with no reading** (exit 6), as Integrity checks states them; the queue, `resume` and `reserve` refuse from then on. There is no stop command: the queue stops itself.
- **Each seed ends** with `sK-status.txt`; the queue's exit codes are 023's (0 done, 1 there cannot be six valid instances, 2 refused, 4 paused, 5 the early stop) and 6, the stop with no reading. The contract reads the queue's handling of the server check's and the comparison tool's exit codes from the queue's text, as it read 023's.
- 023's limits, guards, pre-flight, environment, receipts, heat, launch records and detached start follow, unchanged but for the attempt-named receipts (`sK-aN-*`) and the pre-flight's absent export, now `check/preflight/s8-a1.json.gz`.
- **Limits:** no attempt starts after 48 h of queue time; the queue then pauses and `launch_023.sh resume` continues it. Every job of the queue (the model run, the server check, each comparison and each archive) runs under `tools/memcap.py`, which sums the physical footprint of the job's whole process tree and stops it above the memory cap of 3.7 GiB (the owner's limit of 7 November: half of this 8 GB Mac, less 0.3 GiB for the agents). The cap is not raised. GNU `timeout` sits directly under memcap with GNU `time` inside it, because `timeout` moves itself into a process group of its own: with `time` above it, a stop at the cap reached `time` only and left the model running (measured on this Mac, 7 November). The server's unit limits and its MemAvailable floor are gone: a floor of that size cannot be met on an 8 GB Mac, memcap protects the job, and a busy Mac costs only time, with swap recorded.
- **Guards, at launch and before every attempt:** no other queue may be alive (`runs/queue.lock` holds the live queue's PID; a stale lock is cleared); no model run and no memcap job may be alive (`pgrep -f`: one heavy job at a time, the owner's rule; before an attempt the queue first waits for one to end, as "Failures and pauses" states); the free disk must be at least the floor (before an attempt, the queue waits for 1 GiB above it, as "Failures and pauses" states); every server file must match the frozen manifest (`sha256sum -c --strict`), the server check's copy in `check/` included; every runtime file must match `runtime-sha256.txt`; and macOS must be the build that file names, which stands for the system libraries that have no file to hash. A changed runtime file or macOS build therefore refuses the attempt before it starts. The `runs` and `reserve` modes also refuse unless `$INVOCATION_ID` is the token `launch_023.sh` wrote into `runs/invocation.txt`, so the script started by hand never runs a model or moves an attempt's receipts. The live loop ran on the server and is gone with it; its two scripts stay outside the package (the freeze's `OUTSIDE`), inert.
- **The pre-flight, at each launch:** after the hash check and before the queue starts, the launcher refuses if GNU time, GNU timeout or memcap is missing, because an attempt without them would fail and count. Then `launch_023.sh` runs the frozen server check once on the Mac venv's Python, with no export (`check/preflight/s8-a1.json.gz`, which does not exist). It must stop with "no export at", which it reaches only after importing its code (numpy, scipy, AP and 017's code) and checking that code against the contract; anything else refuses the launch. It then runs the frozen comparison tool the same way, from `check/`, with two absent exports (`check/preflight/s8-a1.json.gz` and `check/preflight/s8-a2.json.gz`): it must stop with "no export at", which it reaches only after checking its own code against the contract's `made_from`. So a check or a comparison that cannot run is found before any run, not after the first or second.
- **Environment, as in 022:** `FELISYN_STEP_FRAMES=30`, `FELISYN_GAP_FRAMES=21`, `FELISYN_WARMUP_MS=0`, `FELISYN_LEAD_MS=504`, `PYTHONDONTWRITEBYTECODE=1` and `MPLBACKEND=Agg`; `FELISYN_CHUNK_STEPS`, `FELISYN_LGN_CACHE` and `PYTHONOPTIMIZE` unset. New on the Mac: `OPENBLAS_NUM_THREADS=4` and `MallocNanoZone=0`. The second was in every proof run's environment, so it is part of what the proof covers. The first is there because OpenBLAS's default thread count on this busy Mac spent the LGN step in thread synchronisation (a small smoke run stuck for 9 min; a matrix-vector product took 16.47 ms against 0.174 ms under load 25, `tools/gemv_bench.py`). The proof below runs with it, so it is part of what the proof shows byte-identical.
- **Receipts per attempt, as in 022 on the Mac's tools:** the environment, the command, server and runtime file hashes at start and end, `time -v`, memcap's memory curve and summary, swap and free disk at start and end, and `pmset -g therm` and `uptime` at start and end; per done instance the server check's record and log. The attempt's own peak is memcap's footprint, which the cap reads, with time -v's maximum resident set size beside it, in its memory-end receipt and in the checker's summary.
- **Heat and other work** are recorded and never a refusal: a run's inputs fix its output, apart from the one-off faults that the paired rule catches (limit 9), so they change only the time, up to the 12 h timeout. The Mac is fanless, and sustained load slows it; a shared Mac is slower still. Beyond the timeout an attempt times out and the queue pauses (Timeouts). A rerun under the same fault would most likely time out too, cost another 12.2 h and leave the slot failed twice, so the pause lets the owner's agent read the receipts and resume once the cause has gone. An 18 h timeout was considered and not taken: a hung run would then cost 18 h instead of 12. G4 took 2.00 h, so 12 h stands (G4_TIMEOUT below).
- **At each launch** (start, resume and reserve) `runs/launch-environment-<UTC>.txt` records the time, the kernel, macOS's version and build, the hardware, power and heat (`pmset`), swap and free disk, the venv's Python version and packages, NEST's version and install folder, and the GNU tools' versions; it compares nothing and refuses nothing (the guards do that). Tier 2 runs without NEST; the lead-in identity, checked after every run, is the test of the engine itself.
- **Surviving an agent's death.** `launch_023.sh` starts the queue detached, in a session of its own, under `caffeinate -ims`, with its output in `runs/queue.out`, whose last line is `rc=N`. memcap runs each job in a session of its own too. If the queue dies and a model lives on, `resume` refuses until the model ends (the guard). A reboot or a power loss is an interrupted attempt. Owner's steps for the window: mains power, because `-s` holds off sleep only on mains; the lid open; no macOS update and no `brew upgrade`.
- **Disk: every export, receipt and record is kept, and each Mozaik folder is kept as a verified archive.** Measured on s7, 023's only run: its Mozaik result folder holds 34 files in 84,064 kB (82 MB: 24 `Segment*.pickle` data stores and the data store's indexes), its export 24.5 MB; xz at preset 6 packs the folder into 19.0 MB in 28 s with 99 MB of memory (gzip: 25.6 MB in 3.4 s). After each attempt settles, the queue runs `server/archive_mozaik_023.py` (new, frozen, the venv's Python, standard library only) under memcap with a 30 min timeout on that attempt's folder, `model-2mm/FelisynController_m23-sK-intact-aN_____*`, which must be exactly one folder of that run name. It:
  1. lists every file in the folder with its SHA-256 and size, and keeps the folder untouched if it holds anything but regular files and folders (a link, a pipe, a device);
  2. writes `archive/sK-aN-mozaik.tar.xz` (Python's `tarfile` with lzma preset 6; never macOS `tar`, which drops real `._` files) and `archive/sK-aN-mozaik.sha256` (one line per file: SHA-256, bytes, path), in the run folder's `archive/`, outside `runs/`, so the fetch never copies them;
  3. reads the archive back and checks that its members are exactly the listed files, each a regular file with the listed size and SHA-256;
  4. lists the folder again and checks that it is unchanged;
  5. writes `archive/sK-aN-archive.json` once: the archive's SHA-256 and size, the list's SHA-256, the file count and bytes, and each step's result, with the removal still to come;
  6. only then removes the folder, and writes `archive/sK-aN-archive-removed.txt` once.
  The archive and its list are written under temporary names and renamed into place once complete, and the records as every write-once record is (Integrity checks, "Each check twice, and each record whole"). A failure at steps 1 to 4 removes only this tool's own archive files, keeps the folder, records the failure in `archive/sK-aN-archive.log` and lets the queue go on; the disk floor protects the rest. **A later call goes by what it finds,** so an interruption at any point (memcap's stop at the disk floor, a reboot) loses nothing: no `archive.json` means the folder was never touched, so any archive file of this attempt is this tool's unverified output, and it is removed and the archive made again from step 1; `archive.json` without the removed marker means a verified archive exists, so the tool checks the archive against that record and finishes the removal, and never touches the archive; both records mean done; anything else (a record whose archive is missing or differs) stops and keeps everything. Nothing else is ever removed: no export, receipt, check record, comparison record or archive. A failed attempt's partial folder is archived the same way. An export is never put in an archive.
- **The disk it needs.** About 43.5 MB per settled attempt (export 24.5 MB and archive 19.0 MB) and its receipts, against 106.5 MB without the archive. The most completed runs, 28: about 1.22 GB, plus the running attempt's folder before its archive (0.11 GB), the fetched exports (at most seven, 0.17 GB) and one counted failure per seed (its archive and any partial export, at most about 44 MB each, 0.31 GB): about 1.8 GB (1.7 GiB). Each disk-floor stop adds up to about 44 MB more. Expected, at the measured rate of 1 in 6 (14.5 runs): about 0.9 GB (0.85 GiB); for 95 % of protocols (at most 18 runs): about 1.06 GB (0.99 GiB); at the earlier tally of 1 in 4 (16 runs): about 0.9 GiB (`sizing-paired-023r2.txt`). Without the archive the 28 runs alone would take about 3.2 GB. The rehearsal measured less per attempt than s7's figures used here: an archive of 18.2 MB (83,341,723 bytes into 18,244,324, s6-a2) and an export of 23.5 MB (23,484,364 bytes, s6-a2).
- **The free disk at the launch** must be at least the floor of 3 GiB, plus the 1.7 GiB above, plus one more macOS swap file of 1 GiB (swap files come from the same volume, and swap stood at 3 GiB with 1.7 GiB used on 8 November), plus the other program's swing of up to about 3 GiB (measured on 8 November): 8.7 GiB; or, if the owner keeps that program stopped for the window, 3 + 1.7 + 1 + 0.3 GiB of margin = 6.0 GiB. The owner's agent checks the free disk and `sysctl vm.swapusage` together against this figure right before each launch; `launch_023.sh` records both in `launch-environment-<UTC>.txt` and refuses only below the floor (its guard), so this figure is an operator check, not a launcher check (code review of 8 November). On 8 November the free disk moved between about 2.8 and 6 GiB. The owner then answered that the other task's test validator stays off for the window, the runs from the launch to the queue's end, and that the download caches may be cleared, and the caches were cleared (Choices made for this revision). So the figure is 6.0 GiB only when that validator is not running right before the launch and the owner keeps it stopped for the whole window, as answered; while it runs at the launch, or if the owner does not keep it stopped for the window, the figure is 8.7 GiB. The answer does not cover the time before the launch, and the validator was used then (Choices made for this revision, "What was seen after the answer, before the window"). Below the floor the queue waits for disk (above); a wait costs time, not an instance.
- **Fetch:** `server/fetch_023.sh`, once the queue has stopped (after the runs part, after a stop, and again after a reserve run), refuses while the queue is alive, as in 023. It copies every receipt from the run folder's `runs/` (the server check records, the comparison records, `early-stop.txt` and `checks-disagree.txt` among them; no export) into the working folder; records in `data-sha256.txt` the run folder's SHA-256 and size of every completed attempt's export (`sK-aN.json.gz`); and copies only the export to analyse of each seed with an agreeing pair (its earlier run's) and the earlier export of a pair that stopped the queue, each checked against that SHA-256. The other exports stay in the run folder, hashed. It refuses iCloud placeholders and a data volume with less than 2 GiB free, as in 023. "The host" in the checks means the run folder. Then, on the Mac, from the frozen package (`assemble_023.py`): `check_instance_023.py check` for each fetched export, `check_instance_023.py summary`, and the analysis.

**Cost.** One run took 1.04 to 1.53 h on this Mac on 8 November (s7 1.10 h, d5 1.04 h, rate-r1 1.53 h while the other program ran) and G4 2.00 h on 7 November; the rehearsal's two completed runs of seed 6 with slot 8's order took 1.74 h (s6-a2, 1:44:07) and 1.33 h (s6-a3, 1:19:38) on 9 November; the coordinator recorded that the other task's validator ran during the rehearsal (Rehearsal before the declaration). The hours below take 1.05 to 2.0 h per run, with the rehearsal's 1.33 to 1.74 h beside them. The pilot's server run took 2 h 54 min with 3.6 % CPU steal (README:56-60); that figure sizes nothing here.

| | Hours |
| --- | --- |
| One run | 1.05 to 2.0 (G4_RUN_TIME, 2.00 h, stays the planning value for the timeout); the rehearsal's runs 1.33 and 1.74 |
| The six slots, paired, at the measured rate of 1 in 6 | expected 14.48 runs: 15.2 to 29.0 (19.2 to 25.1 at the rehearsal's run times); 95 % of protocols need at most 18 runs: 18.9 to 36.0 (23.9 to 31.2); at the earlier tally of 1 in 4: expected 16.05 runs, 16.8 to 32.1, and 95 % within 21 runs, 22.1 to 42.0 |
| The most completed runs | 28 runs: 29.4 to 56.0 (37.2 to 48.6 at the rehearsal's run times), with a pause at the 48 h start limit |
| Counted failures on top | each seed can carry one without becoming invalid; a timeout costs 12.2 and pauses the queue, so 28 runs with one timeout per seed would take about 141 |
| A systematic fault that every run repeats exactly and the checks catch | two runs, 2.1 to 4.0, then the early stop |
| A systematic fault whose details vary from run to run, or an export that can never be parsed | no pair forms: two slots of four runs each, 8 runs, 8.4 to 16.0, then the stop with fewer than six valid instances |
| A timed-out attempt (then a pause) | 12.2 (G4_TIMEOUT and its 10 min kill) |
| A wait for free disk | as long as the other program holds the disk down, up to 6 h before a pause |
| Per completed run: the server check (twice), each comparison and the archive | about 8 s (s7's server check took 4 s; the rehearsal's, computed twice, 10.2 and 6.1 s), 3 s each (the rehearsal's comparison 4.1 s) and 30 s (the rehearsal's archives 75.7 and 34.4 s): at most about 1 h over 28 runs |
| Tier 2 | under 0.1 on the Mac, before the launch (180 s at 023's tier 2) |

- With the paired early stop, a fault every run repeats exactly costs two runs and their checks, not the whole window; one whose details vary costs eight runs.
- **Memory.** The pilot's intact run, this same design on instance A, peaked at 5.26 GiB on the server. On the Mac a run must stay under the memory cap of 3.7 GiB: G4 peaked at 3.208 GiB, s7 at 3.186 and d5 at 3.179, and the rehearsal's runs of seed 6 with slot 8's order at 3.171 (s6-a2) and 3.194 GiB (s6-a3). Instances differ in structure and spike counts, so each run should peak near G4_PEAK. A memory kill sends the slot to the reserve. The comparison peaks at about 0.87 GiB and the archive at about 0.1 GiB, each alone under memcap.
- **Disk on the Mac:** "Disk" and "The free disk at the launch", above.

### Values G4 sets
Only the G4 run on the Mac can give these four values. They stand here, and the sections above name them; the cost table gives them in hours. G4 ran on 7 November 2026 and passed (Stated limits of the Mac run, limit 8).
  - `G4_RUN_TIME`, G4's wall-clock time in hours, from memcap's summary: 2.00 h (7,216 s).
  - `G4_PEAK`, G4's peak footprint in GiB, from memcap's summary: 3.208 GiB.
  - `G4_TIMEOUT`, the run timeout. 12 h stays if G4_RUN_TIME is at most 6 h. Otherwise it is 2 x G4_RUN_TIME, set before the freeze in `RUN_TIMEOUT` in the queue, `run_timeout` in the contract's declared values and this spec's lines. Timing only: 12 h stays, because G4_RUN_TIME is 2.00 h.
  - `G4_MEMORY_MARGIN`, the distance of G4_PEAK below the cap, which must be at least 5 % of it (G4_PEAK at most 3.515 GiB), because a cap stop sends a slot to a reserve and could depend on firing rate (risk 10). A run that misses it gets no launch: the owner gets the options of the plan: 0.492 GiB, 13.3 % of the cap.

For planning only, measured since: three full-length runs of seed 7 on 8 November took 1.04 to 1.53 h and peaked at 3.179 and 3.186 GiB (d5, s7); the rehearsal's two completed runs of seed 6 with slot 8's order took 1.74 and 1.33 h and peaked at 3.171 and 3.194 GiB (s6-a2, s6-a3), 0.506 GiB or more below the cap. The four values above stay G4's.

### Rehearsal before the declaration (023's first lesson)
023 rehearsed its lead-in check on another seed (6) with the pilot's own sequence only; seed 7's first run was the first with its own sequence, and the check that ended 023 had never seen that variation. This revision rehearses every declared check, before the declaration, on real model output with the variation the instances will have: a seed other than 5 and a stimulus order other than the pilot's, on a seed that is already built.
- **What runs.** With the final code, after the review's fixes: one full-length pair at pynn_seed 6 (instance B, built, excluded) with slot 8's declared sequence (`sequence-023-s8.json`), through the queue's paired rule: a1 and a2, and a third or fourth run if the rule calls for them. The run folder is `<home>/felisyn-local/p023r2-test/run`, never `run-023r2`. The rehearsal's own files (its copies, its contract, its start script, `GATE.md` and the recorded diff) are in `<home>/felisyn-local/p023r2/rehearsal/`, so this revision's seed search, which reads `p023r2-test`, meets there only run output and the run folder's copies of the package. **What `p023r2-test` holds now** (9 November 2026): the spec's rehearsal of seed 6 (its run folder `run/`, with the attempts' receipts, records, exports and verified archives; `fetched/`, the fetch copy's receipts, hash list and the one export it copied; `local-check/`, the local content checks), and, from the TEST phase of 8 November, a short rehearsal of the checks on built seed 7 (`rh-a1`, `rh-a2`, `rh-a2-try1-stopped-disk-floor`, `pair` and `tools`, with its own `README.md`): two 5-step 2 mm runs, r2rh-s7-q5-a1 and -a2, with the first 5 steps of slot 8's order in seed 7's environment and process chain; each passed the lead-in check in 3,600 of 3,600 trains, and the comparison tool found them equal in 18,600 of 18,600 trains (exit 0). Their 5-step buffers are smaller than a 16 KiB page, so they rehearse the checks, not the fault rate, and they are not in the tally of full-length runs.
- **Its copies.** The queue and the fetch differ from the files to be frozen only in the lines that name the run folder, the slots (`SLOTS=(6)`) and the reserves (`RESERVES=()`), and the queue copy's `run_model` gains one line that refuses (exit 2) any pynn_seed but 5, 6 and 7, so the copy can never build a seed from 8 to 14. The frozen queue guards every expansion of its reserve list, so an empty list works under macOS's `/bin/bash` 3.2 with `set -u`, which the launcher uses (a guard-harness case runs it); with no reserve, an invalid slot 6 ends with "no reserve left" (exit 1). Its `seq/` holds only `sequence-023-s6.json`, a byte copy of slot 8's declared file under the name the queue reads for pynn_seed 6. The contract is the draft contract that `make_contract_023.py` builds from the final code, with instance 8's entry rewritten for pynn_seed 6 (its run names, argv and resolved seed; slot 8's sequence file and draw kept), because the contract generator checks each sequence file against its own seed. A rehearsal start script sets up the run folder as `launch_023.sh` does, but from the working files, with hash lists of them in place of the frozen manifest; it then runs the two pre-flights and starts the queue detached with its token. The checker, the comparison tool, the archive tool and the other server files run unchanged. The diff of every copy is recorded beside the rehearsal.
- **What it checks on real output:** the pre-flights of the server check and of the comparison tool; the server check of each run (the lead-in identity, the LGN band and the run's records, with a new order on a seed other than 5), computed twice; the comparison tool and its exit codes; the archive with its verification, its record and the removal; the fetch, which copies only the pair's earlier export and records every export's SHA-256; and the local check's content checks of that export under Python 3.14, by the checker's own functions.
- **What it does not exercise,** and what covers it instead: the freeze, the launcher's manifest checks and the local check's `check` mode, which need a frozen manifest that exists only after the declaration (their tests, and the freeze and launch themselves); tier 2 (at the declaration, as in 023); and the summary and the analysis driver, whose rule needs six instances (the six-instance end-to-end test on synthetic exports, and the driver's regression on the pilot's export).
- **Its gate,** written before the first run (`p023r2/rehearsal/GATE.md`): every step above runs as declared; a pair agrees and both its server checks pass; each run that disagrees with the pair is recorded as a one-off fault; each archive verifies before its folder is removed; the fetch copies the earlier export with the run folder's SHA-256; the local content checks pass. A pair that agrees and is refused stops the preparation: that is a systematic fault, and the design is revised before any declaration.
- **Its record and result (8 and 9 November 2026): PASS.** The kit is in `p023r2/rehearsal/` (`README.md` there); `GATE.md` (SHA-256 `e68f17f72bbaf6e6b1764620cf438648d9f83b63ad2d68352af5b7c884e97d55`) was written at 2026-11-08T22:22:23Z, before every other kit file and before anything ran, and the kit's 60 files (`kit-sha256.txt`, `b5f999f3…`) matched at the start and again after the gate. The gate passed G0 to G8 (`rehearsal/logs/gate-20261109T035256Z.txt`, SHA-256 `24002801db481824c52dc7e5d9451fe0b660747efe56fb203a3acf40fcc59416`); the run folder's record is `p023r2-test/run/README.md`, and HANDOFF holds the full record (2026-11-09T03:55:24Z).
  - The start, 2026-11-08T22:33:37Z: guard passed, 583 of 583 server and runtime files matched, both pre-flights reached "no export at", queue detached with its token. Only pynn_seed 6 ran, with slot 8's declared order; run names m23-s6-intact-a1 to -a3.
  - s6-a1: stopped by memcap at the disk floor (exit 98) after 7,320 s (22:33:44Z to 00:35:46Z, in its main 35,133 ms simulation), peak footprint 3.045 GiB; not counted. Its archive was stopped at the floor at once, then made after a 300 s wait (5 files, verified, then removed).
  - s6-a2: exit 0, 00:40:54Z to 02:25:05Z (GNU time 1:44:07), peak footprint 3.171 GiB, maximum resident 1,507,168 kB; export SHA-256 `d830d8a7af241a6bab98e9ee87c51c2983e3e7c12c001f6ea383e9dac593561d`. Server check passed, computed twice (10.2 s, 0.551 GiB). Archive of 34 files, 83,341,723 bytes into 18,244,324, verified, then removed (75.7 s, 0.108 GiB); then a 300 s wait for disk.
  - s6-a3: exit 0, 02:31:37Z to 03:51:18Z (GNU time 1:19:38), peak footprint 3.194 GiB, maximum resident 1,593,936 kB; export SHA-256 `1e1b9276a035a0b8aad6ad2ec0dd07769536a5fdc26ecc54a892474f0ed623e1`. Server check passed, computed twice (6.1 s). Comparison of a2 and a3: agree, server checks the same, exit 0 (4.1 s, 0.793 GiB; `s6-a2-a3-compare.json`); the two decompressed exports, 64,947,679 bytes each, differ only in `run_seconds` and the run name's attempt digit (the skeptic's own reading). Archive of 34 files, verified, then removed (34.4 s). The queue ended at 03:52:06Z with "s6 agreed a2 a3", rc=0.
  - Both server checks: lead-in identity X_ON 1,800 of 1,800 and X_OFF 1,800 of 1,800; LGN band ratios 1.0123 and 1.0298. The fetch copy (03:52:56Z to 03:52:57Z, rc=0, inside `after_rehearsal.sh`, which ran the fetch, the local content checks and the gate from 03:52:56Z to 03:53:07Z, exit 0) copied only `s6-a2.json.gz` and listed both exports' SHA-256 in `data-sha256.txt`; the local content checks under Python 3.14.3 found the export valid, computed twice; the checker's paired rule gave "agreed a2 a3". No one-off fault, no early stop, no stop with no reading; no agreeing pair was refused (G8).
  - Free disk, sampled every 120 s (`p023r2-test/run/disk-samples-rehearsal.txt`): 3.00 to 6.33 GiB, 24 of 160 samples under 4 GiB; swap grew from 3 to 5 GiB during a1 and fell back by about 01:30Z, and the free disk also fell from 00:23Z to 00:35Z with swap flat, so another program was writing. The coordinator recorded that the other task's test validator ran during the rehearsal (HANDOFF, 2026-11-09T04:00:40Z, its reading of these samples), and a process by that name was running at 03:59:51 UTC on 9 November, after the gate (HANDOFF, 2026-11-09T04:40:53Z). The owner's answer that it stays off covers the window, from the launch to the queue's end, not the rehearsal (Choices made for this revision). The disk floor cost 2 h 02 min (a1) and two waits of 5 min. Nothing was deleted.
  - **The skeptic's review** (workflow wf_f8eb7c91-f8f): "passes with notes", every gate condition checked again and `gate.sh` rerun read-only (PASS). Note 1 (low): the record read the re-sizing as conditional, while this section requires it once the rehearsal's runs change the measured rate; they did (1 in 6), and the sizing was redone on 9 November (Paired runs). Note 2 (low): the kit's `server/host_shell.sh`, a byte copy of the working file (`7f894e38…`), kept its source's file times (created and modified 2026-11-07 05:04 local; changed 2026-11-08T22:22:47Z, after `GATE.md`), so its creation time cannot show that `GATE.md` came first for that file; its content is the working file's, so it has no effect on the result.
- **Its cost:** 2.1 to 4.0 h for the pair, more if it disagrees. Its runs are design data, labelled so, and are not in S15. If they change the measured fault rate, the sizing above is redone with them before the declaration. They did: two more clean full-length runs made the tally 1 fault in 6, and the sizing was redone on 9 November (Paired runs).
- **The comparison tool on real exports:** its tests' real-data part compares d5 with rate-r1 and the server pilot's export with G4's (both agree, measured before this draft), under memcap.

## What is frozen before any run (code and tests)
1. **The declared spec,** with its SHA-256 in HANDOFF; 023's declared spec stays beside it, unchanged.
2. **The sequences:** `make_plaid_sequence_023.py` and `make_plaid_sequence_r2.py`, both byte-identical to 023's; the seven files `sequence-023-s8.json` to `sequence-023-s14.json` in `sequences/` with the SHA-256s above, and seed 7's file (`7e35178d…`), all byte-identical to 023's (seed 7's stays only for the unchanged generator test); and `test_sequence_023.py`, byte-identical to 023's (counts, quarters, the run rule, every refusal, fresh builds, the seed ranges, and the byte-for-byte rebuild of `sequence-r2.json`).
3. **The contract.** `make_contract_023.py` writes `contract-023.json` (in the package, `contract.json`): the engine; every instance's run names (`m23-sK-intact-a1` to `-a9`), argv, resolved entry, sequence file, its role in this revision and in 023, and draw (with SHA-256); the rule, categories, outcomes, texts and bands; the paired rule's values (the cap of four completed runs, two counted failures, nine attempts, the comparison's timeout, the exit codes of the checker and the comparison tool, the disk floor not counted); the archive's settings; the queue settings; the pins to 017 and 022; and the SHA-256 of every file it was made from. It reads every value from the code and refuses unless the spec states it; the queue's limits must also equal their declared values. It also writes `tier2/seed-overrides-expected.json` for the tier 2 check (seeds 8 to 14).
4. **Analysis code:** `controller/plaid_stats.py`, `controller/analyze_plaids.py` and `controller/frozen017.py`, byte-identical to 022's; `controller/confirm_023.py` (023's, with the slots 8 to 13, the reserve 14, the excluded seeds 5, 6 and 7 and the NOT INTERPRETABLE text's name), `controller/analyze_confirm_023.py` (the driver, reading the paired summary, with S15 in the results) and `controller/check_instance_023.py` (the blind checker, unchanged in its refusals, with the paired rule, the early stop, the stop with no reading, the replacement rule with one reserve, the summary and S15); new `controller/compare_runs_023.py` (the comparison tool); `leadin-reference-023.json` with `make_leadin_reference_023.py`, byte-identical to 023's; byte-identical copies of 017's contract, decoder, manifest, model-file list and frozen controller code in `protocol-017/`, checked against 017's manifest at every use.
5. **`analysis-choices-023.txt`,** 023's text unchanged, with a dated revision 2 section added (its items 30 to 36), inside the manifest; **`seed_search_023.py`,** byte-identical, with its Mac record, the research server's three last records and its record of the Mac's run folders, all as 023 froze them; and new **`seed_search_023r2.py`** with its record `seed-search-023r2-runs.txt` (Instances), which the contract's declaration and the freeze check as they check the Mac's record.
6. **Tests,** each with deliberate breaks that must make it fail (`bite_023.py`): 023's test files, changed only where a declared rule changes (each change recorded with its reason in `FIX-NOTES-023r2.txt`), and new `test_compare_runs_023.py` (the comparison tool on synthetic exports and its real-data validation), `test_archive_mozaik_023.py` (the archive, its verification, and every case in which the folder must stay) and `test_seed_search_023r2.py` (the r2 search's seeds and design copies). `test_queue_guard_023.sh` covers the paired rule in every row of the combinations table, the failure kinds and their counting (an exit 0 without an export among them), the cap, the attempts used up, the early stop and the stop with no reading, one reserve, the stop as soon as six cannot be reached, the archive step, the wait for free disk and an interruption at every new step.
7. **The calibration:** `calibrate_023.py`, byte-identical to 023's, and this revision's `calibration-023.json` and `calibration-023.log`, whose SHA-256s are recorded under The calibration.
8. **The run folder's files:** byte-identical `run_controller.py`, `lgn_cache.py`, `controller_experiments.py` (version 3), `run_controller_mem.py`, `host_shell.sh` and `tier2_imagen_check_023.py`; `run_queue_023.sh`, `launch_023.sh` and `fetch_023.sh` for this revision; new `archive_mozaik_023.py`; `runtime-sha256.txt`, the two engine patches and the tier 2 inputs, byte-identical to 023's (the macOS build it names, 25C56, is checked again at the launch); the tier 2 receipt and log; and the server check's copy of the frozen package in `check/` (the contract, the lead-in reference, the checker and the comparison tool with the code they import, 017's files and the eight files of `sequences/`), copied at tier 2 and checked against the manifest at every launch and before every attempt.
9. **The freeze.** `freeze_023.py` and `test_freeze_023.py`, as in 023: the manifest lists every frozen file with its SHA-256 and refuses unless every file exists and none is an iCloud placeholder, no `__pycache__` sits in the folder, the spec is declared, the contract is a fresh build whose declared time is the declared spec's, the seed search's records are what the Instances items cite and each item is earlier than the declared time, the tier 2 receipt passed on exactly these files, the calibration is current and passes its gates, and every test passes with none skipped. It writes `manifest-023.json`, whose SHA-256 goes into HANDOFF before the queue starts. A manifest made with `--skip-tests` is for tests only, as in 023. The freeze runs every test file and `bite_023.py` in full, as in 023 (about 3.5 h with the new breaks).
10. **The package.** `<home>/felisyn-local/p023r2/outputs/felisyn-research/protocol-023r2/` is assembled by `assemble_023.py` right after the freeze, as in 023, never edited, with corrections as versioned follow-ups; the public copy is redacted of private paths, as 023's was.

## Risks and limitations
1. **The spread between instances is unmeasured.** The planning value τ_plan = 0.05 is an assumption. A larger spread costs power, not validity: power at 0.15 falls to 0.78 to 0.79 at τ = 0.075 and 0.53 to 0.56 at τ = 0.10, and a real but variable effect then ends NOT REPLICATED or PRESENT BELOW THE MARGIN, not falsely confirmed. S13 reports the spread for later protocols, for each measure estimable in all six instances.
2. **The instances are fresh in structure only.** They share one map, Mozaik's seed 513, NEST's seed 42 (so the LGN noise stream) and one plaid layout. A confirmation covers positions and wiring on that map, not other maps, layouts or noise streams.
3. **The t-test needs independent instance errors.** The shared noise stream would correlate them if every instance saw the same order; own orders put the same noise on different conditions. The calibration's stresses with own orders (the same residual rows in every instance, and residuals correlated 0.44) show the rule stays valid, and its one-order contrast at 0.44 shows what own orders avoid.
4. **A confirmation describes the whole circuit.** There is no lesion, and the input stage is inside every measure. CONFIRMED does not show that the connections compute anything.
5. **The margin is a gate on the mean of point estimates.** At a true mean of exactly 0.10 a measure is confirmed in 0.43 to 0.50 of protocols at τ ≤ 0.05 (calibration). The planning effect of 0.15 is a convention.
6. **Instance A's constants apply to every instance.** The absolute floors (0.30 counts; |ζ| of 1,500 and 750) and the XOS cross-drive gate are instance A values. B's orthogonal cross drive near 100 % was +0.037, against A's −0.002. A measure not estimable in one instance cannot be confirmed; the calibration reports how often that happens under per-instance cross-drive shifts.
7. **Six instances say little about single instances.** The claim is about the mean; with 5 degrees of freedom the t interval is wide, and the prediction interval for one further instance wider still.
8. **Each order has its own history imbalance,** 8.1 to 19.7 points against the pilot's 15.5. S12 is reported per instance.
9. **New code sits on the decision path:** the rule, the driver, the checker and the sequence wrapper; in this revision also the paired rule in the checker and the queue, the comparison tool, and the archive step, the only code that removes anything (a Mozaik folder, after its verified archive). They are guarded by the regression on the pilot's export, the planted-fault tests, the deliberate breaks and the calibration. A bug found after the freeze needs a new revision.
10. **Replacement could select instances.** It is limited to integrity failures and runs that never agree, decided blind, capped at one (023: two) and reported (risk 21). A memory kill could still depend on firing rate, and on the Mac the cap is close: G4_MEMORY_MARGIN keeps the pilot's own peak at least 5 % under it.
11. **Limits carried over from 022** (SPEC:281-294; README:220-231): the onset-dominated window G; layer 4 only; a reduced model whose LGN saturates less than a cat's and has no pooled suppressive field; contrasts of 15 to 60 %; one timing and one readout; plaids that move at the intersection-of-constraints velocity; a π-periodic readout.
12. **Heat and other work change only the time, up to the 12 h timeout,** one-off faults aside (limit 9). The Mac is fanless and shared, so the window is G4's, not the pilot's. Beyond the timeout an attempt times out and the queue pauses before its rerun; two timeouts make a slot invalid.
13. **A correction outside 023.** `outputs/felisyn-research/decisions-020/README.md:62` attributes the 0.44 shared residual of 017's A and B to "the stimulus sequence, the decoder and the model's fixed structure", and says their LGN input "differed completely". The grey lead-in shows that the LGN noise stream is shared node by node. That needs a versioned correction of decisions-020, not an edit.
14. **The early stop ends the protocol on one agreeing pair's refusal.** Two runs of one instance that agree and are both refused are taken to show a fault shared by every instance. A fault of that one instance's own structure, refused the same way in both runs, would then end the protocol where the replacement rule could have replaced it; the rule accepts that cost, as 023 did for its single refusal. A one-off fault no longer ends the protocol, and a systematic fault that every run repeats exactly now costs two runs before the stop, not one. A systematic fault whose details vary from run to run (a race that corrupts different cells in each run, say), or an exporter that writes bytes that can never be parsed, never forms an agreeing pair: each slot it reaches ends `no agreeing pair` after four runs, and two such slots end the protocol NOT INTERPRETABLE with "fewer than six valid instances" after 8 runs (8.4 to 16.0 h), not by the early stop. S15 then shows every run of those seeds refused, and its fault share is not read as a one-off rate (Secondary measures).
15. **The server check runs on the Mac.** It is the same code as the local check, and the pre-flight runs it before every launch; a check that cannot be made stops the queue without a status, and resume makes it again. The second machine and second Python it used to give are lost (Stated limits of the Mac run).
16. **"Never built" rests on the records that exist.** The limit first: the server half of the seed search ran with round 3's script on 3 November 2026 at 00:29:38Z, the final script ran only on the Mac, and the server's files can no longer be read (Instances, the server's last records). The seed search reads the project's text records, its gzip exports and the members of its zip and tar archives, on the Mac by the final script and on the research server by round 3's, and searches every name in the folders it enters (Instances, "Never built", says which files). On the server, by the census of 31 October, outside the folders it skips it leaves unread Mozaik's `.pickle` data stores, numpy arrays, images, documentation and code in other languages, `.xml`, `.sha256`, `.TAG` and `.lock` files, the files whose names start with a dot and the binary files without a suffix; there is no `.stdout`, `.stderr` or rotated log; and each Mozaik result folder's parameters are read from its `parameters.json` and `modified_parameters.json`, besides its name, which carries them. A run whose every such record had been deleted in both places could not be found. It does not enter the software trees (the venv and Node, and on the server the source trees, the Python install and the build trees), the live executor's and shadow's folders, or what its rules take for a key, a credential or a secret (by its name, a leading dot or an owner-only mode), which hold no model run, and it does not see the names inside them. A run's record that was owner-only, or inside a folder whose name starts with a dot, on disk or inside an archive, or whose name starts with a dot, or named as a key, or inside a folder never entered, or a symbolic link, a pipe or a device, or an archive member that a rule left unread, would be listed by name and judged, not read (macOS's `.DS_Store` and AppleDouble `._` files and binary files are counted by kind). The seed's rule reads the forms Instances lists, within 60 characters of the name. It does not read a seed written further from its name, such as a value in another row of a Markdown, CSV or TSV table under a header cell that names the seed: a census of such tables (`table_census.py`, FIX-NOTES section 1h, item S4) found none on the Mac's `work/`, `outputs/` and `docs/` that holds a value from 7 to 14 outside this design, and it never ran on the server, which is gone. Nor does it read the five forms of FIX-NOTES section 1f (a hexadecimal number, a plus sign, a full-width colon, a placeholder name, an index), or the forms of round 5's checker 2 that section 1h names, each with why: another word or sign between the name and the value (at, now, number, #, no., a tilde, U+2248, U+2261, a full-width equals sign, a zero-width space, a strike-through, a type annotation, an HTML entity or tag, a URL, JSON or Python escape of the equals sign, a placeholder letter, a word or letter before the number, a call other than an integer cast, YAML's `!!python/int` tag, a positional parameter's default); a list joined by slashes, an ampersand or "then", or ended by a comment (its first numbers are read); "in" before a bare number or a call; a number of more than 9 digits; and run names that no writer of the project makes (`m023-s7-intact`, `m23s7intact`, `m23-K7-intact`). A run name that ends at the seed is read whatever follows it but a letter or a digit (`m23-s7-lesion` gives 7), which can make the search fail but never hides a seed. No record on the Mac holds one of those forms after a name near a seed from 7 to 14, by round 5's checker 2's wider census (any "pynn", up to 12 characters that are not letters or digits, or 's, then "seed", with the 80 characters after it), and the server census of 3 November found no integer from 7 to 14 within 60 characters of any name it read. No script on the model-run path gives its records an owner-only mode or sets a umask for them: the owner-only modes the project's scripts give are the live executor's devnet keys and folders (`work/live/deploy_live.sh`), the LGN cache's files (binary, so never read) and a temporary file of the tier 2 check, made and removed outside the searched folders.
17. **Engine drift since the pilot, and during the queue.** The lead-in reference comes from the pilot intact run of 27 October on the server. On the Mac the engine is pinned: `runtime-sha256.txt` lists its native files by SHA-256, the queue rechecks them before every attempt and at each attempt's end, and it refuses an attempt if any changed. macOS's own libraries, libc++ and libm among them, live in the dyld shared cache and have no file to hash, so the macOS build number that file names stands for them, and a changed build refuses too. A `brew upgrade` cannot reach the engine, because libomp, libltdl and GSL are private copies. That list holds the native files, the stand-ins and the Python source of mozaik, PyNN, imagen and pynest, so all of them are rechecked with it. A reboot or a power loss ends the attempt; the queue counts it as interrupted, and a rerun loads the libraries as they are then, under the same checks. So the owner holds macOS updates and `brew upgrade` for the window.
18. **The Mac's disk is nearly full, and another program moves it.** Each run writes Mozaik's data store and its export at its end, so a full disk would stop an attempt only at its end. memcap enforces the disk floor of 3 GiB; a stop there is no longer counted as a failed attempt, and the queue waits for free disk before it goes on, so a full disk costs time, and an instance only after five such stops on one seed (Attempts). macOS adds 1 GiB swap files on the same volume when memory is short, so a model run near its peak can itself take a gigabyte of the disk; the launch figure counts one such file. The archive keeps every run's data in about 41 % of its size, losslessly, and the owner's agent checks the free disk at the launch against the worst case and the other program's swing (The Mac queue, "Disk").

19. **One-off faults.** Runs on this Mac fail now and then in a way that only an exact repeat shows (limit 9). The paired rule catches such a fault anywhere in the export, at the cost of more runs: 2.4 completed runs per instance on average at the measured rate of 1 in 6 (2.6 at the earlier tally of 1 in 4). If the rate is much higher than measured (0.4 or more), the protocol is likely to end with fewer than six valid instances (Paired runs, sensitivity).
20. **Identical faults in both runs of a pair would pass,** and so would a deterministic fault the blind checks do not see (limit 9 gives the argument and what still catches them).
21. **Selection by fault-proneness.** If one instance's runs were more prone to faults than another's (a larger memory footprint, more paging), the replacement rule could drop it, and the footprint could go with its firing. The comparisons and checks read no plaid quantity, the replacement is capped at one and reported, and S15 records every seed's runs, so such a selection would be visible.
22. **Time on a shared laptop.** The queue is expected to take 15 to 29 h at the measured rate of 1 in 6 (17 to 32 h at the earlier tally of 1 in 4); 28 completed runs, the most the rule allows, take up to 56 h, and counted failures (up to one per seed, a timeout costing 12.2 h) and waits for free disk come on top. The Mac is shared with another task, whose disk swing can make the queue wait.

## Stated limits of the Mac run
The research server is gone, so the six runs happen on another platform than the pilot. These limits stand beside every result of this protocol; the result package's README and the journal note repeat them.
1. **A new platform.** The pilot ran on x86-64 Linux under GCC 11.5.0, libstdc++, glibc and Python 3.9.20. The six runs run on arm64 macOS: an Apple M2 with 8 cores, macOS 26.2 build 25C56, Apple clang 17.0.0 with `-O3 -ffp-contract=off`, libc++, macOS libm, libomp in place of libgomp, Python 3.9.6, and one rank with a single-rank `mpi4py` stand-in in place of Open MPI. numpy, scipy and the other wheels are the same versions in arm64 builds. GSL is 2.7.1 built from source with `-O2 -ffp-contract=off`; its stepper has no fused instruction, and its 6 left in libgsl are clang's `fmod` expansion in four `gsl_sf_` functions off this model's path. Every difference from the published recipe is in `<home>/felisyn-local/logs/deviations.md`, and the result package carries this platform label. Cortical voltages differ from the server's reference in the low bits (up to 6.34e-09 mV on the tiny regression, against 4.26e-14 mV for the server's own run of it), so a cortical spike train of the Mac could part from the server's over a long run; in G4's 35,133 ms none did (limit 8). A fresh instance has no server twin to differ from, so this limits the link to the pilot, not the instances' validity.
2. **Two engine patches, the only changes to pinned sources.** (1) The noise-order patch, `engine-patches/0001-lgn-noise-pair-order.patch`, on a copy of the step current module: libc++ and libstdc++ return each pair of `std::normal_distribution` in opposite order, so without it every LGN cell's noise differs from the first time step; the wrapper in `iaf_cond_exp_sc_nc` changes only the order, and the polar method and the draws stay. (2) `block_size_shift` from 10 to 6 in NEST's `libnestutil/block_vector.h`, `engine-patches/0002-block-size-shift.patch`, which shrinks each neuron's one-connection recorder list and changes how elements are stored, not their order. Model parameters and any other simulator behaviour are untouched.
3. **The memory wrapper.** `server/run_controller_mem.py` runs `run_controller.py` byte-identical, with the same arguments, and adds only the memory changes the proof shows byte-identical on spikes, connections and LGN arrays on a short run of this Mac (`logs/proof-bytes.txt`), because 3.7 GiB is 1.56 GiB below the pilot's server peak. memcap's sum of the process tree overstates a job's use while its connectors fork, so its stop is stricter than the real use. Its SHA-256 is `c7c19469b8bb87cf83866da04c2d207ff34388433957640d942f01ca2a248c3e`. It holds R0, R1, R3, R4 and R10; R2 (NEST's block size) is engine patch 0002.
4. **The server's second-machine check is lost.** The server check and the local check were two runs of one code on two machines and two Pythons. Now both run on the Mac: the server check under the venv's Python 3.9.6 and numpy 1.22.3, the local check and the analysis under Python 3.14 and numpy 2.4. Two Pythons remain, on one machine. The early stop keeps its meaning and its write-once record. A fault of this machine would show in both, and the disagreement stop can no longer catch it. The name stays; "server" there means the machine that ran the model.
5. **The server's half of the seed search.** The limit is stated in the Instances item and risk 16: the server half of the seed search ran with round 3's script on 3 November 2026 at 00:29:38Z, the final script ran only on the Mac, and the server's files can no longer be read.
6. **What the Mac's identity with the pilot rests on.** On the tiny regression, at 2 threads and 1.275 s, every spike train of every sheet equals the reference, 1,656 of 1,656, and two 4-thread runs on the Mac are equal in content, 48 of 48 segments. 4-thread identity with the server rests on G4 (limit 8). The match of the tiny regression does not promise a cortical match over 35 s; G4 shows one for its one instance and one sequence.
7. **One shared laptop.** The owner's 8 GB Mac runs other work beside the queue, on a disk that is 98 % full. That costs time. Another task on this Mac moved the free disk between about 2.8 and 6 GiB on 8 November (`diag-023/rate/README.md`): a stop at the disk floor pauses the queue and, in this revision, costs time, not an instance. A stop at the memory cap is more serious: that instance is settled as killed for memory with no rerun, the reserve takes its slot, and a second such stop leaves fewer than six valid instances, so the protocol ends NOT INTERPRETABLE.
8. **What G4 shows, and what it does not.** G4 reran protocol 022's intact pilot on this Mac with the pilot's arguments and run name: pynn_seed 5, the pilot's sequence and 4 threads, on the final build with `run_controller_mem.py`, against a gate fixed before the run. It exited 0 in 7,216 s (2.00 h), with a peak footprint of 3.208 GiB at 1.93 h, a peak resident size of 1.906 GiB and at most 423 MiB of swap. All 18,600 neurons' spike trains equal the server pilot's export at its 0.01 ms precision over the whole 35,133 ms: X_ON 1,800 of 1,800, X_OFF 1,800 of 1,800, V1_Exc_L4 6,000 of 6,000, V1_Inh_L4 1,500 of 1,500, V1_Exc_L2/3 6,000 of 6,000 and V1_Inh_L2/3 1,500 of 1,500, with no first differing time. The frozen `analyze_plaids.py` accepted the export with lesion=FAILED, and XOS 0.584392, Dc 0.712882 and ds 0.342481 equal the pilot's values with difference 0.0 at 6 decimals. So one instance on one sequence was reproduced exactly, and the limit of limit 1 becomes narrower: for that run, the new platform changed no spike at the export's precision. It does not show that a fresh seed behaves. No run of a fresh seed exists, a fresh instance has other positions, connections and spike counts, the two platforms still differ in the low bits (limit 1), and each fresh instance's memory and rates are known only once it has run. One further check on a second seed: a short 2 mm run on the same build at pynn_seed 6, which is instance B and not a fresh seed, on the first 5 steps of the pilot's sequence, gave the reference's lead-in in 3,600 of 3,600 trains (X_ON 1,800, X_OFF 1,800, the same cells, by the frozen checker's `leadin_trains` and `leadin_identity`), 14,710,738 connections, the count of 017's instance B, and a peak footprint of 2.732 GiB in 1,404 s. So a change of seed alone does not move the lead-in on this Mac at 2 mm, as far as one seed can show. The evidence is in `work/controller-023/g4-evidence/`: `g4-gate.md` (SHA-256 `edf92f8cbef6b88b73cc0ba5eedf3589ef570fdddb287bb95d47aef26672ca61`), `g4-verdict.json` (`f03167e42d9ddea4d622b94d9a279123a26121862dbee0488431a8733b43f674`), `compare.json` (`4bf34140fe466ac059c778d88d02906412fd9de6254f79f4b89c1268fc8f9d4a`) and `g4.mem.json` (`4ef5a5a6989f01c64c1ae2d7062de6993f2081b902e0af92c5d7608062fa0eef`), and for the seed 6 run `seed6-leadin-check.json` (`0713c2f1dd2bcbb94fc6bed08474780ec3a7209c20ad918ab7da969dc0fe24b2`) and `seed6.mem.json` (`616bd3614c3eee6f76846c9a70e993dea76a225e3e741b96ec5858ceb3325f7e`).
9. **One-off faults on this Mac, and what the paired rule catches.** Runs on this Mac have a one-off execution fault at a low, poorly known rate: s7's run changed one LGN cell's spikes for 14 s and, from 75 ms on, every cortical sheet's, and two exact repeats did not (History). Measured over full-length runs with a spike-level check: 1 in 6 since the rehearsal, with a 95 % interval of 0.4 % to 64 % (before it, 1 in 4, 0.6 % to 81 %). Its cause is untested. The paired rule analyses an instance only when two runs with identical inputs agree on every spike train and on every field of the export but the run name and the time, so it catches a one-off fault anywhere in the output, not only in the LGN lead-in that 023's check could see. What it does not catch:
   - **the same fault in both runs of a pair.** Two independent one-off faults would have to change the same cells at the same times in the same way. Under the leading, untested candidate (a 16 KiB page of one cell's input buffer read back as zeros), a fault is set by which page of which buffer is lost and when; the LGN alone holds 3,600 cells with about 6 live input pages each, and s7's fault acted for 14 s of 35. Both runs of a pair are faulty with a chance of 1 in 36 at the measured rate of 1 in 6 (1 in 16 at the earlier 1 in 4); if faults were spread evenly over the LGN's input pages and two faults on the same page matched exactly, the chance of an identical pair would be below 1 in 700,000 (1/36 times 1/21,600; below 1 in 300,000 at 1 in 4). This is an argument, not a measurement: a fault that always strikes the same place at the same time in a given instance would act as a deterministic fault;
   - **a deterministic fault,** which every run of an instance repeats, so that two runs agree on it. What still catches one: the blind check's refusals (the lead-in identity against the pilot's reference, the LGN band and the run's records), which then refuse both runs of the pair and give the early stop after two runs; the engine's pinning (`runtime-sha256.txt`, the macOS build, the server files' hashes before and after every attempt); and G4, which reproduced the server pilot's export on this Mac in every field but the wall-clock time (all 12 segments, the neuron tables, the resolved parameters and the NEST records; read again for this draft). A deterministic difference of this platform that changes only cortical spikes of a fresh seed or order, and leaves the LGN lead-in and band as they were, would pass, as in 023 (limits 1 and 8).
   - **a fault inside a check, a comparison or the analysis.** Each blind check computes its verdict twice and writes a record only when both agree, so a one-off fault in one computation costs a resume; the analysis computes its results twice and writes `results.json` only when both are the same, so a one-off fault there costs a rerun; a fault that struck both computations in the same way would pass unseen, like the same fault in both runs of a pair. A fault in a comparison that made two equal exports differ costs one more run.
   - **a systematic fault that varies from run to run** looks like a run of one-off faults: no pair forms, and the seeds end `no agreeing pair` (risk 14).
   The share of completed runs that disagreed with their seed's agreeing pair is reported (S15), as a low estimate of the one-off fault rate.

## Declaring this spec
First, the declaring agent makes the steps this spec leaves to be made before the declaration, and records each in its place: this revision's calibration (Sizing; The calibration), the rehearsal and its record (Rehearsal before the declaration), and this revision's search of the Mac's run folders (Instances, "Never built"); every answer to the Open questions is recorded under "Choices made for this revision", and that section is removed. 023's values G4 sets, its memory wrapper's hash and its three seed search items stay as 023 recorded them. The research server's search can no longer be made: its item records the server's last records, each with its SHA-256, and `make_contract_023.server_evidence_problems` and the freeze refuse unless each file is a regular file with that SHA-256. The Mac's item keeps the form it has: two spaces, a hyphen and a space, then `` on the Mac, ⟨UTC⟩ (`work/controller-023/seed-search-023-mac.txt`, SHA-256 `⟨the record's SHA-256⟩`, by the script with SHA-256 `⟨the SHA-256 of seed_search_023.py⟩`): PASS. ``, then the report's counts and the judgment of every item it lists by name. `make_contract_023.py --declared-utc` and the freeze read that item (`make_contract_023.seed_search_problems`) and refuse unless its record exists as a regular file, not a symbolic link; it has the SHA-256 its item gives; its last `result:` line begins `result: PASS`; the script SHA-256 the item gives is that of the `seed_search_023.py` being frozen; the record's first line names that SHA-256; its `roots:` line names `work, outputs`; and (re-check of 3 November, round 4) each item's UTC is the time on its record's first line, which gives it in the form `YYYY-MM-DDTHH:MM:SSZ` (a first line that does not is refused, since the re-check of 3 November, round 5); each record's first line after its time, and its "never entered:" and "never opened or entered" lines, are those the frozen script prints, as its `rule_lines()` computes them: the first line carries the SHA-256 of the script's rules, the text of its patterns (not their flags), its sets of names and suffixes, and its numbers (the seeds, the reach and its longest reading, the chunk and its overlap), so that a record made by a version with another pattern, set or number, or with other words in those lines, is refused; a PASS record shows `hits outside the 023 design: 0`, `iCloud placeholders not read: 0` and `unreadable: 0`, each once, and lists no hit, placeholder or unreadable file; each item begins, after `PASS.`, with its record's counts and names in backticks every item its record lists; (re-check of 3 November, round 6) each listing count a record states equals the number of its listed lines of that kind, and its `result:` line is its last line; a count that is not a number, in an item or in a record, is refused with its reason; and each item's UTC is earlier than the declared UTC. The Mac's record and the server's three last records are frozen and packaged with the rest. The item, and every judgment in it, avoids the phrases that the draft markers refuse (`make_contract_023.draft_markers`), written here with a plus sign between their words so that this section does not hold them: may+still, still+open, open+for+review and open+for+the+review, open+until+the+declaration, pending+before+the+declaration in any case, DRAFT,+not+declared and Not+to+be+run, and a heading whose first word is Open. That record is the last edit of the draft. The declaration is then one edit of three lines, then a rebuild of the contract:
1. the title loses "(draft)": `# Protocol 023 revision 2: does the plaids pilot's departure from a relay hold, on average, over six fresh network instances?`;
2. line 3, the draft banner, becomes `**Declared ⟨UTC⟩, before any revision 2 run.** Its SHA-256 is recorded in HANDOFF, and everything under "What is frozen" is frozen before any revision 2 run.`, the only line that begins with the declared banner;
3. the Status line becomes `Status: DECLARED ⟨UTC⟩.`, with the spaces and the date after it kept (`make_contract_023.status_of` reads the Status as the text after `Status: ` up to the first run of two or more spaces, and it must be exactly `DECLARED ⟨UTC⟩.`).

Then `python3 -B make_contract_023.py --declared-utc ⟨UTC⟩ --force`, with the UTC that the edit wrote into the banner and the Status line, in the form `YYYY-MM-DDTHH:MM:SSZ` (for example `2026-11-20T09:00:00Z`; any other form is refused), later than the searches' times. The contract generator and the freeze refuse a declared contract while the title, the banner or the Status line still reads as a draft, while a heading or sentence holds a choice open (the choices are recorded under "Choices made for this revision"), or while a line still carries, in any case, the marker that a step holds until it is recorded (`make_contract_023.draft_markers`); they refuse a contract whose declared time is not the UTC of the Status line and the banner (`make_contract_023.declared_time_problems`), and seed search records that are not what the Instances items cite or a Mac item that is not earlier than that time (`make_contract_023.seed_search_problems`, `make_contract_023.server_evidence_problems`). The spec's SHA-256 goes into HANDOFF together with that of `work/controller-023/FIX-NOTES-023r2.txt`, the record of this revision's review findings and how each was handled (023's `FIX-NOTES-023.txt` stays as it is), to which the History points: the notes are not in the frozen manifest, so HANDOFF fixes the version the declaration rests on. Nothing else changes at the declaration, and no test depends on the spec's status: `test_freeze_023.py` runs the contract and freeze tests on a declared copy.

## Test plan
- The unit tests listed under "What is frozen", run with `PYTHONDONTWRITEBYTECODE=1` and `-B`, never importing code from `outputs/`; `bite_023.py` shows each test fails when its target is deliberately broken.
- The driver's regression on the pilot's intact export: with 022's sequence and draw it reproduces RES's `per_step` and `primary` exactly.
- The checker on the pilot-derived synthetic exports and on planted faults (a changed lead-in train, cells other than the reference's, a wrong seed, a wrong sequence, a cached run, two presentations, a wrong duration or grating frequency, an LGN rate out of band, an unreadable host file), and its stops (no host file, a copy that is not the host's, a symbolic link, a placeholder, a read error here, code that is not frozen). The server check: its exit codes, its record written once and read again, its stops, and the same checks under Python 3.9 with numpy 1.22.3 and scipy 1.8.0 as the local check's.
- The driver's refusals on planted exports with forged passing check records (a wrong command line, an LGN rate out of band, a changed lead-in), a recount that differs, the code-fault stop at 1e-12, and a whole six-instance analysis with differing instance estimates.
- The summary: provenance of every local and server record, a done attempt's receipts, the early stop, the replacement rule and the queue's record in every order of events, refused reserves, both reserves used and no reserve left included (in this revision: the one reserve used, and no reserve left).
- The calibration in full, with its gates.
- `test_queue_guard_023.sh` (the server check after every run, the early stop for a slot and a reserve, a check that could not be made, refused slots and reserves in every order with the record cross-checked by the checker's rule, no reserve while more slots need one than are unused, timeouts, changed server files, the pre-flight, since the re-check of 3 November, round 6, an interruption in the middle of an attempt, of its rerun, of its end receipts, of its server check and of a reserve's attempt, and since the Mac revision memcap's exit 99 and 98, a second queue and a stale lock, a resume while a model lives, the token, a changed runtime file or macOS build, the real memcap on a small job and a queue that outlives its parent; a watchdog ends any queue run that loops, so a deliberate break fails instead of hanging), then tier 2 on the Mac.
- **New for revision 2** (each written first and seen to fail, then the code):
  - `test_compare_runs_023.py`: an export against itself and against a copy that differs only in the run name or `run_seconds` agrees; for two agreeing exports, exit 0 when both server records passed or both refused with the same kinds (a 'run' refusal shared by both, whose texts differ by the run name, among them), and exit 4 when one passed and one refused or the kinds differ, with a deliberate break that compares the refusal texts; a copy with one spike moved by 0.1 ms in one LGN cell, one spike at exactly 35,133.0 ms removed, one cortical cell's train changed, one neuron table value changed, a cell missing or added, an extra or missing segment, another `resolved` value or NEST record, or another sequence disagrees, each with the differing field, sheet, cell and first time in its record; an unparseable export read twice; the record written once and whole (a power loss mimicked after the temporary file and before the link leaves no record) and read again; the exit codes; the running code checked against the contract before the exports are looked for (the pre-flight's stop); Python 3.9 syntax and the standard library only; and, under memcap, d5 against rate-r1 and the pilot against G4 (both agree);
  - `test_archive_mozaik_023.py`: a folder archived, verified, recorded and removed; real `._` files kept; a link, a pipe or a device in the folder, a member missing, added, truncated or changed in the archive, a folder changed between the lists, a write that fails (the disk full) and a second folder of the same run name: each keeps the folder, removes only its own archive files and records why; a stop by SIGTERM at each step, then a second call, which redoes an unverified archive, finishes a removal after a verified record without touching the archive, and stops on a record whose archive is missing or differs;
  - `test_check_instance_023.py`: the paired rule's state machine in every row of the combinations table and every order of completed and failed attempts (with the cap, failed twice, killed for memory, attempts used up, a disk-floor stop not counted, an exit 0 without an export counted, and an empty exit receipt read as interrupted); the early stop with a 'run' refusal shared by both runs (texts that differ by the run name), and the stop with no reading; the local refusal of a server-passed export sent to the replacement rule, and a local pass of a server-refused one stopping the summary; the replacement rule with one reserve and its record; the summary's rebuild of each seed's state from receipts, server records and comparison records, and its stop on every disagreement, a comparison record whose server-check verdict is not the summary's own among them; each check computed twice, with no record when the two computations differ; every record written whole; S15, its interval, its bound and its note on seeds refused with one kind;
  - `test_analyze_confirm_023.py`: the driver's reading of the paired summary, the exports of the agreeing pairs' earlier runs, and S15 in the results;
  - `test_queue_guard_023.sh`: as listed under "What is frozen", item 6, with the stand-in model's exports made equal or different on demand;
  - `test_seed_search_023r2.py`: seeds 8 to 14 found and 7 not; the design copies counted apart and a run record never; the unchanged script underneath;
  - `test_end_to_end_023.py`: six synthetic instances, one of them with a disagreeing run and a third run, from the queue to the results.
- `test_seed_search_023.py`: roots outside the workspace; the script read from stdin in / under Python 3.9, as on the server; Mozaik result folders found by their names; records without a suffix; the forms of the seed that read-only censuses of the server's text records met (JSON, Python reprs, keyword arguments, argv and `PyNN seed 7`), and escaped JSON inside a JSON string, `PYNN_SEED=7` and `"pynn_seed": [7]`, each found, and 70, 513 and seeds outside 7 to 14 not; since the re-check of 3 November, round 4: every form Instances lists, in upper and lower case, and in folder and file names the run name in upper case and the seed joined to the name; every form of the cut-off checker's list that a run or a design could write, and the five that neither could, not read; each form of both censuses of 3 November (digits as N; each read only names written `pynn`, then nothing, a space, an underscore or a hyphen, then `seed` or `seeds`, in any case, and skipped protocol 021's folders and any file over 300 MB, so they hold the forms found where they looked, not every form the records hold) with the N in the seed's place set to 7 and every other N to 5, giving exactly {7}, with the forms whose N is not a seed named, and why; each census window outside this design that holds an integer from 7 to 14 within 60 characters of the name, giving no hit; the reach of 60 characters, a number cut by it never read; the time, in a child process under both Pythons, stopped after 120 s (a regression fails instead of hanging): `pynn_seed` followed by 100,000 spaces or by 100,000 of each character and word that may stand before the value, `pynn` followed by 100,000 spaces, and files of 100,000 mentions, each under 3 s, measured by the instructions the child retires (macOS's count, at 16 billion a second, a little under the rate of the Mac's fast cores at full speed), so that the Mac's other load, which slows its cores and lengthens both the clock's time and the child's CPU time, does not count (the slowest, files of 100,000 mentions each followed by 29 numbers or a chain of 14 arrows, took 1.1 to 1.8 s by the clock on the Mac in round 6, and 1.43 to 1.60 s by that count, idle or loaded; the rest well under a second); the overlap of the chunks at least the longest reach, and each form read whole with a chunk boundary at every offset inside it; the report's first line and rule lines as `rule_lines()` gives them, which change with one pattern, set or number of the script and not with a comment, a pattern's flags or the code that applies the rules (re-check of 3 November, round 5); dot files listed by name and macOS's own files counted by kind; since round 6: an archive's members judged from its whole list of entries whatever their order, in a zip, a tar, a tar.gz and a tar.gz inside a zip; key-named files, folders never entered with their rule, symbolic links and pipes listed by name, nothing but the run records opened; the forms of item S3 read in any case and at every chunk boundary, their near misses not, the forms of round 5's checker 2 that are still not read named with why; the list's "or", the dashes, "..", "through", "thru" and the words was, were, are and equal(s) each pinned; archive members a rule left unread listed once by name and rule, with dot folders and owner-only folders inside archives; exports, zip members and tar members read whole, a tar member's hit its own; the software trees and the executor never entered, the server's Python install and build trees included (CPython's crafted test tar `recursion.tar` in the Python install passes, and the same tar in a run folder fails the search as unreadable); folders whose name starts with a dot listed by name; under an audit hook that records every file the search opens, with stand-in keys readable by all: key, keystore and environment files, a key in a folder named `ssh` (round 2's blocker), folders named `keys`, `secrets`, `credentials` and `wallets`, a home folder's dot files, and owner-only files and folders never opened, on disk and in archives, the owner-only ones listed by name; a root searched even when owner-only; an unreadable folder or file, a damaged gzip file and a missing root failing the search; links not followed; numbers cut at a chunk boundary, in the wider forms too.
- The declaration guard (`test_contract_023.py`, `test_freeze_023.py`): a heading or sentence that holds a choice open, a line that still carries a step's marker in any case, or a contract whose declared time is not the spec's is refused at the declaration; so are seed search records that are not what the Instances items cite (a missing record or a symbolic link, another SHA-256, a record whose last result is not a PASS, another script, other roots, an item not in its form, deleted or given twice, and a superseded record cited in the item's place; since the re-check of 3 November, round 4: an item whose time is not its record's, a record made by a version of the script with other rules (another reach, other skip rules, other words in a rule line), its first line, "never entered" or "never opened" line other than the frozen script's, a PASS record that shows or lists a hit, a placeholder or an unreadable file, an item without its record's counts or with others, an item that does not name each item its record lists, and an item not earlier than the declared time; since round 5: a record whose first line gives no time in the form `YYYY-MM-DDTHH:MM:SSZ`; since round 6: an item that does not name each key-named file, folder not entered, symbolic link and special file its record lists, a record whose listing counts are not its listed lines or with a line after its result, a count that is not a number (a refusal, never a traceback), a record made over other roots, an item's time one second off and an item's archive members count not its record's), at the declaration and at the freeze, which lists and packages the records, while a correct declaration passes; since the Mac revision, the server's last records: a missing item, a file not its SHA-256, or not a regular file; the check reads the script's own server report; the freeze refuses a test file that reports a skipped test.
- `scripts/agent-verify.sh` is not run for this revision: it needs about 5.5 GiB of temporary space, more than this disk has to spare (HANDOFF-023.txt, 7 November). The tests above run directly.

## Done when
- [ ] This draft reviewed, revised and declared, with its SHA-256 in HANDOFF, before any revision 2 run; every Open question answered and recorded under "Choices made"
- [ ] All code written test-first and tested; the calibration passes its gates on the final code; the rehearsal passes its gate; this revision's seed search of the Mac's run folders passes and is recorded under Instances, earlier than the declared time; the contract rebuilt from the declared spec; tier 2 passes on the Mac; everything frozen with hashes, every test and every deliberate break run at the freeze; the package assembled from the manifest
- [ ] At the launch, the free disk meets "The free disk at the launch", and the server check's pre-flight reaches its declared stop on the Mac
- [ ] The runs complete, or their failures, disagreements and replacement are recorded
- [ ] The analysis runs once; result package and journal note, and the X post the owner holds for this result

## Choices made for this revision, with the alternatives considered
These choices were made in the design of 28 October, the adversarial review of 29 October and the fixes after it. The owner was asked the draft's questions on 28 October and, on 29 October, asked for the protocol to continue without picking an option (History). The declaration makes every choice below final; a change after it is a new declared revision.

**The owner's answers, 8 November 2026, in the owner's words** (HANDOFF; for the first, 023's running record `p023/HANDOFF-023.txt`):
- **The paired design and its tie-break.** After journal note 24 the owner wrote "A" and "i will wait on rerun result for x post". "A" answers the agent's message of about 07:45 UTC that day, in which A was: every network instance run twice with identical inputs, analysed only if both runs agree on every spike train, with a third and if needed a fourth run to break a disagreement. The diagnosis and note 24 letter that design "Option B"; it is recorded by its content (History). So the paired rule and its cap of four completed runs per seed are the owner's decision, and the X post waits for this revision's result.
- **The disk during the preparation and the window.** The agent asked whether the other task's test validator stays off during the window and whether the npm, pnpm, pip and Homebrew download caches may be cleared. The owner first wrote "no u can launch", which was read at first as no to both, and then, at about 22:20 UTC, corrected it: "no i mean yes u can launch". So: yes, the other task's test validator stays off during the protocol window; yes, the caches may be cleared; and the launch goes ahead when ready. The correction replaces the first reading (HANDOFF, both entries of 8 November). The caches were cleared at about 22:20 UTC: npm's 736 MB (`npm cache clean --force`), pnpm's 323 MB, pip's 172 MB and Homebrew's downloads, 113 MB (no `brew cleanup`); `~/.npm/_npx` was left as it was.
- **What was seen after the answer, before the window.** The answer covers the window, the runs from the launch to the queue's end: the agent's question was "Will you keep the validator off during the runs?", and its next message asked the owner to keep it off "from the launch until the runs finish" (HANDOFF, 2026-11-09T04:40:53Z). Before the window the other task still used the validator. The coordinator recorded that it ran during the rehearsal, its reading of the rehearsal's disk samples, which show another program writing without naming it (HANDOFF, 2026-11-09T04:00:40Z); and its check at 03:59:51 UTC on 9 November, after the rehearsal's gate and before the calibration, found a process by that name (HANDOFF, 2026-11-09T04:40:53Z). At 04:12:46 UTC no process named solana-test-validator was listed, and the other task's `cargo test` was compiling, one rustc process at 1.47 GB resident; at 04:37:11 UTC none was listed. The coordinator asked the owner again at 04:01 UTC on 9 November to switch it off before the launch and keep it off until the runs finish. So the figure that the owner's agent checks right before the launch is 6.0 GiB only when the validator is not running then and the owner keeps it stopped for the whole window, and 8.7 GiB otherwise (The Mac queue, "The free disk at the launch").

**The draft's open questions, each resolved** (the section that asked them is removed, as "Declaring this spec" requires):
1. **The cap: four completed runs per seed.** The owner's decision of 8 November: "A" chose the design of the agent's message, which included "a third and if needed a fourth run" (above). This draft's question on the cap, with five as the alternative (0.5 % of protocols ending unread at the earlier tally of 1 in 4, against 4.6 % for four), was not put to the owner: on 8 November the owner was asked to choose the revision's design, about the validator and the caches, and about the X post, never about the cap (HANDOFF, 2026-11-09T04:40:53Z; `p023/HANDOFF-023.txt`). At the measured rate of 1 in 6, four ends unread in 0.52 % of protocols and five in 0.023 % (Paired runs). The cap of four was kept at the re-sizing of 9 November by the declaration's coordinator, as the owner's decision.
2. **The disk during the preparation and the window:** the owner's answer above (the validator off for the window, the runs from the launch to the queue's end; the caches cleared; the launch when ready), given before the calibration started. The question put to the owner asked about the runs only, not about the preparation before the launch, so the answer does not cover the preparation.
3. **The calibration beside other work.** Not put to the owner. The coordinator of the declaration workflow started this revision's calibration at 2026-11-09T04:00:37Z, after the rehearsal had ended, as the one heavy job of this protocol, with only light work of the declaration beside it: spec edits and fast tests, each under memcap or well under 0.5 GiB. No other heavy job of this protocol ran beside it.
4. **The review.** Done before the calibration, the rehearsal and the declaration, as the plan's order after the build set it (build workflow wf_fed2dedc-05a): the design review of 8 November (two readers, findings R1 to R10 and F1 to F7) and three independent reviews of the built code that day (readers A, B and C; 14 findings, 13 applied and 1 in part; HANDOFF 2026-11-08T19:10:01Z; `FIX-NOTES-023r2.txt`, section "Code review of 8 November 2026"). Three readers in place of the two that this question proposed. Decided by the build workflow; the owner was not asked.

**Revision 2's choices, 8 November 2026** (they replace 023's choices where they name one; 023's choices below stand otherwise):
- **The paired rule with a cap of four completed runs per seed,** the owner's decision. Considered in the diagnosis: one rerun only after a lead-in refusal (it would pass runs from a run path that sometimes corrupts input unseen, the skeptic's finding 1), checking every LGN input array against an offline computation (more engineering, a change on the run path, and the cortex unseen), tolerating a few differing lead-in cells (it would analyse runs known to be faulty), and finding the cause first (no bound on time). Considered for the cap: three (9.0 % chance of ending unread at the measured rate of 1 in 6, 30 % at the earlier 1 in 4) and five (0.023 %, 0.5 % at 1 in 4, about the same expected runs, a worst case of 35 runs), this draft's alternative, which was not put to the owner; the owner's decision of four stands (the owner's answers, above).
- **Agreement as equality of the whole export but the run name and the time,** stricter than the owner's "every spike train". Considered: CMP's window [0, 35,133) ms over the sequence segment's trains, which leaves out spikes at exactly 35,133.0 ms, and the end-of-simulation segment. The stricter rule also makes two agreeing runs' blind-check verdicts necessarily equal, which the early stop needs.
- **The early stop on an agreeing pair that the checks refuse with the same refusal kinds.** Considered: keeping 023's stop at the first refusal (it would have ended this revision on a one-off fault, as it ended 023), and a stop after two refusals of one kind in one seed (two one-off faults of one kind would stop it falsely). "The same" compares kinds, not texts, because a 'run' refusal quotes the run name (review of 8 November).
- **Each check computes its verdict twice, and every record is written whole.** Considered (review of 8 November): repeating a check only when two checks of an agreeing pair differ, into new records (more states in the queue and the summary for the same protection), and leaving one computation (a one-off fault inside a check, a few seconds long, could then end the protocol or spend the reserve).
- **A local refusal of an export the server checks passed spends the reserve, as in 023.** Considered: a stop with no reading (the local check decides validity in 023's design, and it runs under another Python and numpy than the server check, limit 4).
- **The analysed export is the earlier run of the pair.** The two are equal but for the run name and the time; a fixed choice keeps the rule blind.
- **One reserve, 14, and a stop as soon as six valid instances cannot be reached.** Considered: two reserves (14 and a new 15: 0.022 % against 0.52 % at the measured rate of 1 in 6, and 0.60 % against 4.6 % at the earlier 1 in 4, about what a cap of five gives, but seed 15 has no record on the research server, which is gone, and needs a new sequence file), and 023's order, all slots before the reserve (more hours on a protocol already unread).
- **A disk-floor stop is not counted as a failed attempt, and the queue waits for free disk.** Considered: 023's count (another program's disk swing could then make an instance invalid); an exit at each stop until someone resumes (a night idle for a swing of minutes); and giving disk-floor stops no attempt number (their receipts and Mozaik folders would then have to be moved aside, which this revision dropped), so five such stops on one seed still make it invalid (Attempts).
- **A lossless archive of each Mozaik folder.** Considered: keeping every folder (about 3.2 GB for 28 completed runs, more than this disk can hold above the floor with the other program's swing), and removing the duplicate runs' folders (not lossless).
- **The calibration reruns.** Considered: keeping 023's calibration (its records hash `confirm_023.py` and the slots' orders, which change, and its test refuses it; weakening that test is not allowed).
- **The deliberate breaks run once, at the freeze, as in 023.** Considered: a bite receipt from the test phase that the freeze would accept in place of running the breaks again. It was dropped in the review of 8 November: the breaks would still run once, so it saves no time, and it needs new code, tests and breaks on the freeze's path.
- **The run names keep 023's form,** m23-sK-intact-aN: seeds 8 to 14 were never run, so no name repeats one of 023's, and the checks, the contract and the seed search already read that form. The run folder and the working tree are this revision's own.
- **The rehearsal on seed 6 with slot 8's order,** through the steps that real output can reach before the declaration. Considered: seed 7 with slot 8's order (seed 7's full-length runs are known; seed 6 has never run at full length on this Mac, so it adds a second seed); and a rehearsal through the freeze, the summary and the driver (it would need copies of the freeze, the contract generator and the rule code that differ from the files to be frozen in more than their paths, so it would test other code; review of 8 November).

023's choices, which stand unless a choice above replaces them:
- **The design: the mean over six fresh instances,** option (b), with a one-sided t-test over the six instance estimates (History). Considered: (a), three instances under an every-instance rule, which the draft proposed (about 11.2 h with its exports, against 18.9 h for (b)). (b) was taken on the agent's recommendation of 28 October: its test stays valid whatever the spread between instances turns out to be, and it measures that spread for later protocols.
- **The level of the test: one-sided at family-wise 0.025,** protocol 022's level in the pilot's direction (the review's finding statistics[0], fix (a)). Considered: one-sided at 0.05, which would raise the power at τ = 0.10 (0.68 to 0.72 in the superseded calibration of 29 October, against 0.53 to 0.56 here; at τ_plan 0.975 to 0.986 against 0.941 to 0.979) but double the rate at which a measure with no departure ends PRESENT BELOW THE MARGIN.
- **The early stop on the first refusal of the server check, of any kind** (replaced in revision 2 by the early stop on an agreeing pair that the checks refuse). Considered: stopping only on the LGN lead-in identity and the NEST kernel, and leaving the other refusals to the replacement rule. The wider stop was taken because every refusal kind is one that a fault shared by every instance would produce (Integrity checks); risk 14 states its cost.
- **The lead-in identity as a refusal** (judge 2's alarm in the draft). Considered: reporting it only (judge 1). It refuses because a difference in the lead-in means the engine, a library or the environment differs from the pilot's (Integrity checks, refusal 3).
- **NOT ESTIMABLE in one instance voids the measure.** Considered: testing the remaining instances, which would select instances on a response level. The calibration reports the cost (G5).
- **RELAY-LIKE is decided on the mean before REVERSED IN AN INSTANCE is checked.** Considered: the other order, which would let one reversed instance override a relay-like mean.
- **S13's interval method: moments with a chi-square interval on 5 degrees of freedom,** descriptive only. Considered: a parametric bootstrap.
- **τ_plan = 0.05,** the robust candidate's planning value. Considered: 0.03, the draft's.
- **Six instances,** which meet the declared gate and keep both reserves (revision 2 keeps six instances and has one reserve). Considered: eight, which in 023's calibration raised the power at τ = 0.10 from 0.52 to 0.56 to 0.77 to 0.80 (that run's sensitivity cell used the reserves' orders for the extra two; this revision's cell holds seven instances and gives 0.66 to 0.69, against 0.53 to 0.56 at six) for about 5.8 h more at the pilot's speed; a real eight-instance design would need two new reserve seeds.
- **The 12 h run timeout.** Considered: 18 h (The Mac queue, "Heat and other work"). G4 took 2.00 h, so 12 h stands (G4_TIMEOUT).
- **The Mac run (revision of 7 November 2026).** The owner's decision: find a way without the rented research server, with at most half of the Mac's RAM. Considered in the plan: GitHub's free runners, which would send the run kit to GitHub, and a smaller sheet, which would no longer confirm the 2 mm pilot.
- **The pilot's lead-in reference and the exact identity stay** (the audit's option B). The noise-order patch restores the server's pair order, and the tiny regression shows every LGN train equal to the reference. Considered: re-basing the reference on G4's export with a short seed 6 gate (option A), which would lose the exact link to the pilot.
- **The fixed texts keep "had never been built", with the limit stated beside them.** Considered: rewording them, which would need a calibration rerun of about 2.3 h and a review, because the texts are calibration inputs.
- **The queue script adapted, not rewritten.** About 250 of its lines survived six review rounds, and the contract parses its text. Considered: a new driver, which would repeat that logic and need a new review.
- **The disk floor of 3 GiB in the queue,** the figure of the approved plan and of memcap's default, under which G4 ran. Considered: 5 GiB, which was the agent's rule, not the owner's. The free disk moves by about 2 GiB with the other work on this Mac, and a false stop at the floor costs an attempt and a pause.
