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

**Declared 2026-11-07T20:25:30Z, before any 023 run.** Its SHA-256 is recorded in HANDOFF, and everything under "What is frozen" is frozen before any 023 run.

Status: DECLARED 2026-11-07T20:25:30Z.          Date: 2026-10-29

## 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.
- **This revision** 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". While the workspace's `HANDOFF.md` is evicted by iCloud and cannot be read or written, HANDOFF in this spec means the dated, append-only `HANDOFF-023.txt` in the Mac's mirror of this work (`<home>/felisyn-local/p023/`); it is merged into `HANDOFF.md` when iCloud is healthy.
- **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`.

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

## 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.**

## 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 023 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 reserves.** The six slots are pynn_seed 7 to 12, with reserves 13 and 14, used in that order and only by the replacement rule (Integrity checks).
- **Excluded seeds: 5 and 6.** 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).
- **Never built.** 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.
- **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/`; every first seed passed the run rule at the first try):

| Instance | Role | 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 (%) |
| --- | --- | --- | --- | --- | --- |
| 7 | slot | 230700 | `7e35178db03d59efcea0d6f8a3ff211d4e14a791ba54af88ec6040c338e56a90` | 15.3 | 30.0 and 30.0 |
| 8 | slot | 230800 | `f185a2b3adc31de0fafd3420722f7b65783839c3c5784667aeb8b9bde28e104f` | 15.3 | 48.75 and 26.25 |
| 9 | slot | 230900 | `18c5b676e0163fb7f9279c7399fc5a3c7615f6bc680c3b7a123df33783cb5539` | 9.1 | 30.0 and 41.25 |
| 10 | slot | 231000 | `48fe6cb0c15aa336362019a312763f4f057aaca53e0929d0a5860f425d2863c1` | 15.9 | 45.0 and 18.75 |
| 11 | slot | 231100 | `27cfa9d9ee430a70aab246ca6029dd04597fe5b3330387a633b340e1b6db81d0` | 18.0 | 37.5 and 30.0 |
| 12 | slot | 231200 | `b94950656c690a6c706c9017fa239dc0d6fc41e80474c95ac9f16fc1d1401d5e` | 19.7 | 37.5 and 37.5 |
| 13 | reserve | 231300 | `5d252fab9e295996e51a0579ee8801dba3f420a06b460597f17f8c8405213483` | 8.1 | 33.75 and 30.0 |
| 14 | reserve | 231400 | `266f09e2e12a1c44e9de6f82e9c138d0a8399a32e81888a709607893a4b12050` | 11.6 | 22.5 and 26.25 |

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.

### 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 023 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 (Integrity checks);
   - fewer than six valid instances after the declared replacements;
   - 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', 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, or the server check and the local check of one export 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; that file is a calibration input and stays unchanged, 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 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."

**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 these words, and no calibration is rerun: they are fixed in `confirm_023.py`, a calibration input, and "never built" is defined by the records that exist (Instances). 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.

**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 each export twice, with the same frozen code: on the machine that ran the model right after its 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 since the Mac revision that machine is the Mac), and on the Mac after the fetch (**the local check**: `check_instance_023.py check`, from the frozen package). 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 check decides the early stop; the local check decides validity and the replacement rule.

**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.json.gz`, 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 seed's own regular file (`runs/sK.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.

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

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

**The early stop.** The instances run the same frozen files in the same engine and environment and share the LGN noise stream, so a fault that one export shows would, in the main, show in every export, and it should be found after one run, not after the whole window. So the queue runs the server check right after each run that exits 0, under timeout 1h and before the next attempt starts. Exit 0 means the check passed, and the queue marks the run done. Exit 3 means it refused the export: the first refusal stops the queue at once (`runs/early-stop.txt`, then `sK-status.txt` done, then the queue's exit 5), no further attempt or reserve runs, and the queue, `launch_023.sh resume` and `reserve` refuse from then on. Every refusal kind above is one that a fault shared by every instance would produce (the queue's command, the engine's records, the input stage, the engine itself), so the first refusal of the server check is taken as systematic: the protocol is NOT INTERPRETABLE with that refusal as its condition, once the local check of the same export, after the fetch, has refused it too. If the local check passes what the server check refused, the two checks of one file disagree, and the summary stops (a new declared revision decides). Any other exit of the server check means no check was made: the queue stops (exit 2) without marking the run done, and `resume` makes the check again before anything else (a check already recorded is read, not repeated). So a run's status done means that it finished with exit 0 and its server check was made, whatever that check found; whether the instance is valid comes from the checks, never from the status. The checker is blind, so the early stop unblinds nothing, and a new declared revision can follow it. A systematic fault then costs one run, not the window. The server check runs the same code as the local check; `test_check_instance_023.py` runs it under the server venv's versions (Python 3.9, numpy 1.22.3, scipy 1.8.0) on a synthetic export and compares its record with the local check's.

**The replacement rule:**
- A slot is invalid if its run failed twice (one rerun, `-a2`, is allowed; a run killed for memory is not rerun; an attempt that timed out or was ended by a host restart counts as failed; an attempt that never started is not counted), or if the local check refused its export.
- Each invalid slot gets the next unused reserve, 13 then 14. A reserve that is itself invalid (its run failed twice or was killed for memory, or the local check refused its export) is followed by the next unused reserve for the same slot. At most two replacements are made. A reserve is given only while it is unused, so no reserve takes two slots.
- **The one record.** The queue writes `runs/replacements.txt`, in time order, one line per decision: `reserve R for slot S: CAUSE`, or `no reserve left for slot S: CAUSE` once both reserves are used. CAUSE names what made the slot, or the reserve last given to it, invalid: `the run failed twice`, `the run killed for memory`, `refused by the blind checker (check record SHA-256 X)`, or the same with `reserve R'` for a reserve. The queue writes these lines for its own failures (after the six slots, slot by slot) and for refusals given to it by `launch_023.sh reserve` after the local checks; both take the next unused reserve, so the queue, the launcher and the summary follow one order.
- **The analysed instances** are the valid slots and, for each invalid slot, the valid reserve that filled it, by the record. The texts list them in pynn_seed order, so the outcome does not depend on which slot a reserve filled; the summary and the results keep which reserve filled which slot and why.
- As soon as more slots need a reserve than reserves are unused, there cannot be six valid instances: the protocol is NOT INTERPRETABLE at once, and no further reserve is run (the queue gives none, and before each `launch_023.sh reserve` the owner's agent runs the summary, which counts every refusal known; The Mac queue, "Reserves").
- Replacements are decided from the queue's receipts and the local check records only, before the analysis (`check_instance_023.py summary`). The summary reads the record and stops, writing nothing, unless every line is the rule's: the next unused reserve, for a slot whose own run, or whose last reserve, is invalid for the cause the line gives (with that check record's SHA-256 for a refusal), `no reserve left` only once both are used, and every reserve that ran in the record. It also stops unless every local and server check record was made by this frozen checker for this contract on the host's export (`data-sha256.txt`); every done attempt's receipts show exit 0, the same server-file hashes at its start and end and a server check that passed (or the one that stopped the queue); and the early stop is the server records' first and only refusal, with no attempt started after it. 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. 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 023 exports.
- Any exploratory reading of 023 data gets its own manifest, frozen before it reads any 023 export. It can never change, qualify or repeat 023's outcome.

### 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** (from 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.997 | 0.999 |
| **0.05 (τ_plan)** | **1.5** | **0.967** | **0.970** | **0.976** |
| **0.05 (τ_plan)** | **2** | **0.960** | **0.965** | **0.974** |
| **0.05 (τ_plan)** | **3** | **0.948** | **0.945** | **0.977** |
| 0.075 | 2 | 0.763 | 0.801 | 0.809 |
| 0.10 | 2 | 0.521 | 0.538 | 0.560 |

- **The sizing gate holds,** with a worst case of 0.945 (Dc at n = 3).
- **Sensitivity, reported only:**
  - five instances at τ = 0.05: 0.875, 0.896 and 0.906; eight instances (the six slots and both reserves' orders) at τ = 0.10: 0.771, 0.778 and 0.798;
  - one instance at μ − 3τ: 0.605, 0.629 and 0.662; t3-shaped spreads: 0.946, 0.954 and 0.970;
  - step noise 0.85, 1.15 and 1.5 times the pilot's: 0.968 to 0.980, 0.949 to 0.961, and 0.909 to 0.949;
  - all three measures real at 0.15, so that Holm's later steps are used: 0.980, 0.977 and 0.984 at τ = 0.05, and 0.675, 0.688 and 0.697 at τ = 0.10.
- **A larger spread costs power, not validity:** at τ = 0.10 a real mean of 0.15 is confirmed 0.52 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).
- **When and where.** On the Mac, 30 October 18:39:36 to 20:57:36 UTC, one process (8,286 s, maximum resident set 194 MB). It is the fourth full run and the only gate: the first (29 October, at a one-sided level of 0.05 and with the identical-instances contrast) is superseded, and the second and third stopped part-way (a session that ended, then a restart of the Mac); all three are kept unchanged under `work/controller-023/scratch/`. Records: `calibration-023.json` (SHA-256 `7636b500d522163192bf2bdb24e11cc5f0c3a2f52da6a30a7047c2a45e2846e0`) and `calibration-023.log` (`925ff9ea0fcba599c96285fcb2fad6814848889dae18897a93a7c0251f6f8fb2`). 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). 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.0097 (τ = 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.945 to 0.977.
  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.956 (0.935 to 0.960 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.014 to 0.027. Under the boundary nulls the null measure: 0.021 to 0.027.
  5. **G5:** XOS is NOT ESTIMABLE in at most 0.10 of protocols under the operating-point shifts: at most 0.013.
  6. **G6:** a true mean of half the margin (0.05, τ 0.05) is CONFIRMED in at most 0.05 of protocols: 0.012 to 0.013.
  - 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 are never gates.
- **At the margin** (a true mean of exactly 0.10), CONFIRMED in 0.43 to 0.52 of protocols at τ ≤ 0.05 (n = 2), 0.31 to 0.35 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.023 (the same rows, τ = 0), 0.021 (the same rows, τ = 0.05) and 0.026 (residuals correlated 0.44, τ = 0) of protocols, and power with the same rows is 0.961 to 0.979. With one order for all at a correlation of 0.44, a relay is rejected in 0.267 of protocols at τ = 0 (each measure 0.10 to 0.11 of the time) and 0.062 at τ = 0.05, and is CONFIRMED in 0 and 0.0003 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.019 to 0.026 of protocols, and power is 0.940 to 0.979.
- **Secondaries:**
  - the 95 % t interval of the mean covered the population mean in 0.933 to 0.963 of protocols (normal spreads);
  - the between-instance SD by moments averaged 0.044 to 0.045 at τ = 0.05 (an SD from five degrees of freedom runs low), and its interval covered τ in at least 0.938 of protocols;
  - under a relay the instance estimates' mean bias was −0.0018 (XOS), −0.0001 (Dc) and 0.0000 (ds) at n = 2, and −0.0025 (XOS) and −0.0009 (Dc) at n = 3: against the pilot's direction, so conservative for the one-sided test;
  - 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.

## The Mac queue, guards and cost
**Before the queue:**
- **Folder:** `<home>/felisyn-local/run-023`, 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 eight instance files 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:** `m23-s7-intact-a1`, then s8 to s12, each under memcap and timeout 12h, with `pynn_seed K` and `FELISYN_SEQUENCE` set to that instance's file. The command is `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.
- **The server check after each run:** right after an attempt exits 0 with the server and runtime files unchanged, `check/controller/check_instance_023.py server` checks its export, under memcap with a 1 h timeout, and writes `sK-server-check.json` once (Integrity checks, the early stop). The queue marks the run done only once its server check has been made: after a pass, or after a refusal, which also stops the queue (the early stop). Done means that the run finished and was checked; validity comes from the checks.
- **Reruns:** one `-a2` per instance under the identical contract, none after a kill for memory (memcap's exit 99). An interrupted attempt counts as failed; its exit receipt is written last, after its end receipts, so an attempt cut off before it (by a reboot or a power loss, say, risk 17) is interrupted, never done. Each instance ends with `sK-status.txt`: done, failed twice or killed for memory.
- **Reserves:** after the six slots, each slot that ended failed twice or killed for memory gets the next unused reserve, and a reserve that ends so is followed by the next unused one for the same slot. No reserve is given while more slots need one than reserves are unused: there cannot then be six valid instances (the replacement rule), so the queue records nothing more and exits 1, and `reserve` refuses the same way (exit 1). After the local checks, a refused export gets the next reserve from `launch_023.sh reserve MANIFEST SHA256 SLOT CHECK_RECORD`: 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 (SLOT itself, or the reserve last given to it; the queue checks which). The same command again continues an interrupted reserve and changes nothing else. Every decision is a line of `replacements.txt` (the replacement rule); with both reserves used the queue writes `no reserve left for slot S` and exits 1. Before any `launch_023.sh reserve`, the owner's agent makes the local check of every fetched export and then runs `check_instance_023.py summary` (into a new file each time: a summary is never overwritten); when the summary says fewer than six valid instances, no reserve is run. Reserve mode counts the queue's own failures and the one refusal it is given, so with two refusals known together and one reserve unused it would still run that reserve, about 2.00 h at G4's speed, although it cannot help.
- **Timeouts:** an attempt that timed out (exit 124 or 137) counts as failed, and the queue pauses so that its rerun does not start under the same fault (exit 4). The owner's agent reads the attempt's receipts first (heat, sleep or a hung run). `launch_023.sh resume` continues it.
- **The disk floor:** memcap stops a job when the free disk falls below the disk floor of 3 GiB (exit 98). The attempt counts as failed, and the queue pauses (exit 4) until space is freed, so each stop needs a resume by hand and a full disk cannot burn reruns and reserves unattended. Two such stops on one instance still end it as failed twice, and a reserve takes its slot. `launch_023.sh resume` continues it, and the guard refuses an attempt while the disk is below the floor, so a resume spends none.
- **Server or runtime files changed during an attempt:** that attempt is never done. It is kept as failed, and the queue stops (refused) until the files are restored and the queue resumed.
- **The early stop:** the first export the server check refuses stops the queue (exit 5) with `runs/early-stop.txt`; the queue, resume and reserve refuse from then on. There is no stop command: the queue stops itself.
- **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 and the server check, 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); the free disk must be at least the floor; 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/s7.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. So a check that cannot run is found before any run, not after the first.
- **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: the simulation is deterministic, 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`.
- **Fetch:** `server/fetch_023.sh`, once the queue has stopped (after the runs part, after an early stop, and again after any reserve run), copies the receipts (the server check records and `early-stop.txt` among them) and each done instance's export from the run folder into the working folder, checked against the run folder's SHA-256, and records those hashes in `data-sha256.txt`; it refuses while the queue is alive, iCloud placeholders and a data volume with less than 2 GiB free. "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 export, `check_instance_023.py summary`, and the analysis.

**Cost.** The hours are G4's, on this Mac. 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 instance run | 2.00 (G4_RUN_TIME) |
| The six slots, one at a time | 12.0 (6 x G4_RUN_TIME), plus each run's server check |
| Each rerun or replacement | 2.00 |
| A timed-out attempt (then a pause) | 12.2 (G4_TIMEOUT and its 10 min kill) |
| The server check after each run | about 0.02 on the server. G4 did not make one, because pynn_seed 5 has no slot; the frozen `analyze_plaids.py` read G4's export in 12.2 s, and the queue's receipts give the check's own time |
| Tier 2 | under 0.1 on the Mac, before the launch (86 s in the rehearsal) |

- With the early stop, a fault every instance shares costs one run and its server check, not the whole window.
- **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, with the changes under "Stated limits of the Mac run": G4_PEAK gives its peak, and G4_MEMORY_MARGIN its distance from the cap. Instances differ in structure and spike counts (A and B: 14,740,479 against 14,710,738 connections, 0.2 %), so each run should peak near G4_PEAK. A memory kill sends the slot to a reserve.
- **Disk on the Mac.** Each export should be about 26 MB (the pilot's was 25.6 MB): about 0.2 GB for eight. Each run also leaves its Mozaik result folder in `model-2mm/`: G4's held 88,903,819 bytes (85 MB), so about 0.7 GB for eight; the queue deletes nothing. The disk floor of 3 GiB holds through the queue only if the runs' folders fit above it: about 3.9 GiB free at the launch for all eight, and about 2 GiB more for the other work on this Mac, which moves the free disk by that much. The owner's agent checks that before the launch.

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

## What is frozen before any run (code and tests)
1. **The declared spec,** with its SHA-256 in HANDOFF.
2. **The sequences:** `make_plaid_sequence_023.py` with `make_plaid_sequence_r2.py` (byte-identical), the eight files in `sequences/` with the SHA-256s above, and `test_sequence_023.py` (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, argv, resolved entry, sequence file and draw (with SHA-256); the rule, categories, outcomes, texts and bands; the queue settings; the pins to 017 (`383e67ef…`, `72a58b2f…`) and 022 (spec, contract, manifest, results and the pilot export); 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.
4. **Analysis code:** `controller/plaid_stats.py`, `controller/analyze_plaids.py` and `controller/frozen017.py`, byte-identical to 022's; new `controller/confirm_023.py` (the rule, categories, secondaries and texts), `controller/analyze_confirm_023.py` (the driver) and `controller/check_instance_023.py` (the blind checker in its server and local modes, the early stop, the replacement rule with the queue's record, and the summary); `leadin-reference-023.json` with `make_leadin_reference_023.py`; 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`,** the details the spec does not state, inside the manifest; and **`seed_search_023.py`,** the read-only seed search whose results Instances records, with its Mac record, `seed-search-023-mac.txt`, and the research server's three last records, `seed-search-probe-494c3fb9.txt`, `seed-census-server.txt` and `window-census-server.txt`, which the declaration and the freeze check against the Instances items ("Declaring this spec"). Its record of the Mac's run folders, `seed-search-023-runs.txt`, is frozen with them; its Instances item gives its SHA-256.
6. **Tests,** each with deliberate breaks that must make it fail (`bite_023.py`): `test_confirm_023.py`, `test_sequence_023.py`, `test_check_instance_023.py` (the checker's refusals on planted faults, its stops, the server check, under the server venv's versions too, the early stop, the replacement rule with its record in every order of events, and the summary), `test_analyze_confirm_023.py` (the regression on the pilot's intact export, the driver's stops, its own refusals on planted exports with forged passing records, the code-fault stop, and a whole synthetic six-instance analysis with differing estimates), `test_contract_023.py`, `test_freeze_023.py` (with the package assembly and the real tests on a declared copy of the spec), `test_calibration_023.py` (the gates, from the calibration JSON made by the current code), `test_queue_guard_023.sh` (the server scripts with stand-ins, the server check and the early stop, every reserve path, and the queue's record checked with the checker's rule) and `test_seed_search_023.py` (the seed search on stand-ins for the server's folders and for a workspace).
7. **The calibration:** `calibrate_023.py`, `calibration-023.json` and `calibration-023.log`, whose SHA-256s are quoted above.
8. **The run folder's files:** byte-identical `run_controller.py`, `lgn_cache.py` and `controller_experiments.py` (version 3); new `run_controller_mem.py` (the memory wrapper), `run_queue_023.sh`, `launch_023.sh`, `fetch_023.sh`, `host_shell.sh` and `tier2_imagen_check_023.py`; `runtime-sha256.txt`, the hash list of the engine's native files, made from the final build at G4, and the two engine patches in `engine-patches/`; the tier 2 inputs; 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 with the code it imports, 017's files and the eight 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`: 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 (no draft marker: its title, banner and Status line are declared, no heading or sentence holds a choice open, and no line still carries, in any case, the marker that a step holds until it is recorded), the contract is a fresh build whose declared time is the declared spec's, the seed search's Mac record and the server's three last records are what the Instances items cite, the Mac's item earlier than the declared time ("Declaring this spec"), the tier 2 receipt passed on exactly these files and resolved the contract's seeds, the calibration is current and passes its gates, and every test passes with none skipped: a test file whose unittest summary reports a skipped test refuses the freeze, as a failure does. The server-version tests run with SERVER_PYTHON, the Mac venv's Python since the Mac revision, or else with the older stand-in of that venv at its scratch path, to which `testkit_023.py` and `test_seed_search_023.py` fall back; a test run that skips them makes the freeze refuse. 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: the launcher, the assembler, the checker and the driver refuse a manifest whose `tests_at_freeze` does not record a run in which every test passed. Every Python entry point sets `sys.dont_write_bytecode = True` before it imports frozen code.
10. **The package.** `outputs/felisyn-research/protocol-023/` is assembled by `assemble_023.py` (frozen with the rest; it refuses unless `manifest-023.json` has the SHA-256 given, recorded in HANDOFF, and every copy matches) right after the freeze, because the checks of the first exports run from it while the queue runs. It is never edited. Corrections are versioned follow-ups. The public copy of the package is redacted of private paths (such as the venv stand-in's scratch path in the test code), as protocol 022's public copy 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.76 to 0.81 at τ = 0.075 and 0.52 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.52 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. 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, decided blind, capped at two and reported. 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.** 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 refusal.** The first export the server check refuses is taken to show a fault shared by every instance. A fault of that one instance (an export damaged as it was written, say) would then end the protocol where the replacement rule could have replaced it; the rule accepts that cost for the server time it saves when the fault is shared.
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.** Each run writes Mozaik's data store and its export at its end, so a full disk would fail an attempt only at its end. memcap now enforces the disk floor of 3 GiB, and exit 98 pauses the queue, so a full disk cannot use up the reruns and reserves unattended, though each stop still spends an attempt. The queue deletes nothing, so the owner's agent checks the free disk against G4's folder before each launch.

## 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. A stop at the disk floor costs an attempt and a pause. A stop at the memory cap is more serious: that instance is settled as killed for memory with no rerun, a reserve takes its slot, and a third 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`).

## 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: the values G4 sets ("Values G4 sets"), the memory wrapper's hash (Stated limits of the Mac run), and the search of the Mac's run folders (Instances, "Never built"). 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: 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 023 run.** Its SHA-256 is recorded in HANDOFF, and everything under "What is frozen" is frozen before any 023 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-023.txt`, the record of the review's findings and how each was handled, 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.
- 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.
- `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`, where the workspace has one.

## Done when
- [ ] This draft reviewed, revised and declared, with its SHA-256 in HANDOFF, before any run
- [ ] The seed search on the Mac's workspace (every evicted file it reads downloaded first) shows that no run used seeds 7 to 14, with each item it lists by name judged unable to hold a model run's record; the server's last records stand in the server's place, with the stated limit; the Mac's run folders are searched too; each result is recorded under Instances before the declaration, with no phrase that the draft markers refuse, each earlier than the declared time, and the records are frozen with the rest
- [ ] All code written and tested; G4 passes and its values are filled in; the calibration passes its gates on the final code; the contract rebuilt from the declared spec; tier 2 passes on the Mac; `runtime-sha256.txt` remade from the final build; everything frozen with hashes; the package assembled from the manifest
- [ ] At launch, the server check's pre-flight reaches its declared stop on the Mac
- [ ] The runs complete, or their failures and replacements are recorded
- [ ] The analysis runs once; result package and journal note (an X draft only if the result is a serious achievement)

## 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 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.52 to 0.56 here; at τ_plan 0.975 to 0.986 against 0.945 to 0.977) 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.** 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. Considered: eight, which would raise the power at τ = 0.10 from 0.52 to 0.56 to 0.77 to 0.80 (the calibration used the reserves' orders for the extra two) 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.
