# PREREG · the Strata bench on the laptop (2026-10-02) **Registered 2026-10-02T19:26:17Z** (UTC, read from `date -u` at the moment this file was written), by the strata-harness lane, under ledger row D-20261002-044. No speed row, quality row or engine log of this bench existed when this file was written: the harness folder held no code yet, no engine had been built by this lane, and no model had been launched. Source of every registered line below: `/workshop/bench-archive/plans-2026-09-29/strata-recon/RECON-v1.md` (sha256 `96e4a739267cc85c250300d714faa51cc135f25ce69f61cb19fd6c286f826df0`), section "The one bench proposal". The three blocks are copied byte for byte by a script (lines 444-450, 461-492 and 494-499); the harness re-reads RECON-v1.md at every start and refuses to run if block 2 below no longer matches those lines byte for byte. ## 1 · The five registered arms (RECON-v1.md lines 444-450, verbatim) | Order | Arm | Engine at commit | File | Key settings | Contexts | |---:|---|---|---|---|---| | 1 | L-IQ3 | llama.cpp at 3cf03257 | ISTA IQ3_S | `-ngl 99`, `--n-cpu-moe` fitted in the dry run then frozen, `-lm mmap --lazy-mode on`, `-fa on`, 8-bit KV | 4K, 32K, 128K | | 2 | S-IQ3 | Strata at 8fc40dde | ISTA IQ3_S | The arguments setup writes; images, MCP and the projection off | 4K, 32K, 128K | | 3 | S-IQ3-noMTP | Strata at 8fc40dde | ISTA IQ3_S | `--spec 4` without `--mtp` | 4K, 32K | | 4 | S-Q2 | Strata at 8fc40dde | ISTA Q2_0 | As S-IQ3 | 4K, 32K, 128K | | 5 | L-Q2 | llama.cpp at 3cf03257 | ISTA Q2_0 | As L-IQ3 | 4K, 32K, 128K | An optional sixth arm, **S-HEAD** (Strata at a second commit, the same files and settings as S-IQ3), is NOT registered: it has no prediction band and no gate of its own, it runs only if the lead's delta security read of `8fc40dde..HEAD` holds (D-20261002-044), and any S-HEAD figure is labelled exploratory wherever it appears. ## 2 · Gates and prediction bands (RECON-v1.md lines 461-492, verbatim) **Gates, registered before any speed row is read:** | Gate | Threshold | Consequence | |---|---|---| | G0, runnable | `/health` answers; the log shows the native AVX2 line and no control-vector line | Otherwise the arm is recorded as refused, with its reason, not as a result | | G1, fidelity | Strata and llama.cpp on the same file give the same strict outcome on at least 105 of 108 six-way items and 47 of 48 doorman items | A miss is disclosed and the two engines' rows stand separately | | G2, value | Six-way at least 93 of 108 (qwen3.8:27b on this laptop) and doorman at least 36 of 48 (the seat's bytes on this laptop) | A rung that fails G2 keeps its speed rows but gets no value table | | "Better" | An exact McNemar test against qwen3.5:27b's laptop rows, p < 0.05 | The only win anyone may claim | | Block | Minutes | Arithmetic | |---|---:|---| | Staging, no GPU | 50-80 | CUDA toolkit 10-20 (a sudo paste, the first thing handed over on the go) + Strata build 20-40 + llama.cpp build 10-15; the 126 GB download at 50-110 MB/s (19-42 minutes) overlaps the builds; hashes and packing about 10 | | Dry run | 15 | Every stage and writer, one probe each | | Speed | about 85 | Arm estimates 20 + 13 + 8 + 10 + 22 = 73, plus slack | | Quality | about 39 | 4 arms x 156 items x 2-3.5 s, plus 4 starts x 2 minutes | | GPU total | about 140 | The first arm (L-IQ3) is on the card within the first hour of the go | Registered prediction bands. A reading outside its band gets opened before anyone trusts it: | Arm | Decode at 4K, low (tok/s) | Decode at 4K, high (tok/s) | |---|---:|---:| | S-Q2 | 60 | 130 | | S-IQ3 | 40 | 90 | | S-IQ3-noMTP | 25 | 55 | | L-IQ3 | 20 | 55 | | L-Q2 | 10 | 45 | The S-Q2 band comes from the paper's round breakdown, rescaled [inferred]: - A 24 GB card holds about 12,900 experts, from (24 - 5.6) x 700 per GB. - Cache misses therefore fall from 0.28 to about 0.08-0.15. - The AVX2 path costs 1-2x more CPU time than the AVX-512 one. - A round comes to 24.8-41.6 ms for 2.4-3.2 tokens. ## 3 · Stop conditions (RECON-v1.md lines 494-499, verbatim) **Stop conditions:** - The engine refuses the CPU at the dry run (#142). - Memory pressure. Each server runs in its own `systemd-run --user` unit with `MemoryMax`, the other lanes are parked, `scribe-embed.timer` is paused and the system ollama's embedder is evicted. - The SSD runs above 80 C, or the GPU passes its temperature guard. A watcher restores the laptop's services when the bench ends. IQ3_S at 128K may be refused for RAM; the KV cache then stays in VRAM (`setup.py:1822`). That is a legitimate row. The results describe commit 8fc40dde only. ## 4 · Addenda registered with this file - **G0 addendum (the band rule as a gate).** A decode reading at 4K that falls outside its arm's registered band above is OPENED before anyone trusts it: the summary table prints it with the flag `OUT-OF-BAND (opened: no)` and no sentence, table or page may quote it as a result until the lead has read that run's engine log, its record row and the box's state at the time (loadavg, the running claude processes, temperatures, MemAvailable), and written in HARNESS-NOTES.md or the bench report what was found. Opening a reading never deletes or edits it; a reading that cannot be explained stays in the table with its flag. - **How G1 is counted (no threshold changed; superseded by A1 below).** "The same strict outcome" means the kit's strict scorer gives the same pass/fail on the same item id for the Strata arm and the llama.cpp arm on the same file (S-IQ3 against L-IQ3, S-Q2 against L-Q2). Items are matched by id; an item that one engine failed to answer (a transport error or a timeout) counts as a different outcome, never as skipped. - **How G2 is counted (no threshold changed).** The strict-correct count over the frozen six-way 108 and doorman 48 sets as scored by the same kit scorer that produced LAPTOP-READING-0's 93 and 36, against the thresholds in the G2 row above. - **"Better".** The exact two-sided McNemar test is computed on the item-by-item discordant pairs against qwen3.5:27b's laptop rows on the same 156 items. Only if p < 0.05 AND the arm has more strict-correct items may a win be claimed. - **Speed figure of record (superseded by A1 below).** For each arm and context, the decode tok/s of record is the median of the 3 repeats, each run cold (the server restarted between repeats is NOT required; the prompt cache is defeated by a fresh nonce first). Every repeat stays in the record file; the summary shows all three beside the median. ## 5 · Amendment A1 (registered 2026-10-02T20:10:29Z, before any speed or quality row of this bench existed) Written by the strata-harness lane after reading the house definitions; no threshold, band or arm changes. The records folder `strata-bench/records/` did not exist when this was written (the only rows anywhere were the dry run's stub rows under `harness/dryrun-receipts/`, which no figure of this bench may cite). - **A1-1, G1's counting rule (replaces the section-4 bullet).** "The same strict outcome" is the house's bridge rule (PREREG-S0 section 2.5, method S-7; `laptop-reading-0/tables_laptop.py` `agreement`): the same STRICT CHOICE on the same item, joined by `prompt_sha256`, where two non-clean replies (strict choice None on both) count as the same. A row missing on either side counts as a difference. The thresholds stay 105 of 108 and 47 of 48. - **A1-2, the clock of record (replaces the section-4 speed bullet).** Decode tok/s of record is the kit's one timing rule on the client's clock: (completion_tokens - 1) / (t_finish - t_first_token), from the streamed /v1/chat/completions frames (`seatlib.RULES["engine_timing"]`, `engine.decode_chat_sse` + `finish_record`). Each engine's own figure (`timings.predicted_per_second`) prints beside it, never in its place. Per arm and context the figure of record is the median of the 3 repeats; all three print. - **A1-3, "cold".** Every run opens with a fresh nonce (the kit's seeded "Ticket NNNNNNNN.", keyed by context and repeat, never by engine), so no prompt or conversation cache can serve it (llama.cpp's `--cache-ram 0`; Strata's `cached_tokens` is recorded per run and a value past the nonce is flagged). The harness DEFAULT is one server start per arm and phase, with `requests_since_start` on every row; Strata's adaptive expert cache therefore carries over between runs, as it does for any user. Whether "cold" instead means a fresh server per run is a lead decision to be made before the first Strata speed row; if taken, it is recorded here as A2 before that row. - **A1-4, out-of-band handling (restates the section-4 G0 addendum).** The summary prints every 4K decode reading outside its band with `OUT-OF-BAND (opened: no)` until the lead writes what was found. ## 6 · Addendum AUD: the local-auditing arms (registered 2026-10-02T21:14:07Z, when only L-IQ3's fit attempts a1-a9 (STOPPED/REFUSED a1-a5 under the pre-fix PSI guard and verbosity; a6-a9 the fit of record), FROZEN-NCMOE-L-IQ3.json (N=34) and L-IQ3's speed attempt a1 (running since 20:53:28Z; its rows are speed rows only, no G1 reading exists because no quality row exists) [records read: L-IQ3: fit/a1/ fit/a2/ fit/a3/ fit/a4/ fit/a5/ fit/a6/ fit/a7/ fit/a8/ fit/a9/ speed/a1/ ;] existed; no AUD row of this bench existed) Written by the strata-aud-design lane under an operator's words, verbatim, 2026-10-02 ~20:0xZ: "love it! it sounds like this model + strata could be pretty promising for local auditing, etc, let's be sure we tie those two together and add that to the bench" (ledger D-20261002-047). Nothing in sections 1-5 changes: no arm, gate, band, threshold or stop condition above moves, and no AUD figure feeds G0, G1, G2 or "Better". AUD-S at HEAD inherits section 1's rule for S-HEAD: it is not a registered engine line, and every figure it gives is labelled exploratory wherever it appears (section 3: "the results describe commit 8fc40dde only"). The AUD arms answer one question: **how does Flash-Next on this laptop behave under the local-auditing bench's real audit calls** (format, call sizes against the window, think length, wall time and decode speed per call), with llama.cpp on the same bytes as the control. **AUD-0 · What an AUD run is.** One DRY RUN of the la-r1 kit's screen pass (PLAN-v2 §3.1) on development episode E3 (KD's kit-format cut E3/pre, MANIFEST `788fb80fb88e1fc50dfe3063d0dc43ef75b03385a797e7597cb25373ea02dc79`), with the kit's stand-in prompt bundle (`standin-v0`, `5bdf385a4ca9b347a6b28d2793a5dc881deee966b30288f2c831a40337e6c6a6`). A DRY RUN carries no reading (la-r1 PREREG R1.8.1, R1.14). An AUD run is never `collect`ed: its findings folder is renamed out of `dev_tune_serve.py`'s path when the run ends, and its rows carry AUD's label and run id, never R1a's (AUD-4, AUD-6). Its findings never reach the prompt author or a triage, and no AUD figure is a headline. **AUD-1 · The arms.** | Arm | Engine at commit | File | Engine line | Status | |---|---|---|---|---| | AUD-S | Strata at `36fa455e579b23a9c909c2c6fe1bddd9e51cb8ca` (v0.1.36) by rule C1, else `8fc40dde` as **AUD-S-PIN** by rule C2 | the AUD file (rule F) | the line the S arm on that file ran at that commit, unchanged (S-HEAD's at HEAD; S-IQ3's or S-Q2's at the pin) | registered as an AUD arm; at HEAD every figure is **exploratory (HEAD; PREREG §1)** | | AUD-L | llama.cpp at `3cf03257f219afbe7334045ff7c6a06ac68c627d` | the AUD file | the L arm's frozen line on that file (its frozen `--n-cpu-moe`), plus only the kit's own `--reasoning-format deepseek`, `--offline` and `--no-agent`, each where `llama-server --help` at `3cf03257` lists it (recorded either way) | registered | | AUD-C | Strata at AUD-S's commit | ISTA's Coder, `ISTA-DASLab/Qwen3.8-Flash-Next-GSQ-RCO-Coder-GGUF` at `5348543e0147355ac9cbcb031184a3546350988e`: shard 1 `IQ1_M/…-IQ1_M-00001-of-00002.gguf` 29,608,446,496 B, sha256 `e11083ba855e7666b48ea3f2db6a9c3a20c18751a012cc24f948de91b7087fad`; shard 2 = the ISTA file's shard 2 (`316b46f3…`, the same LFS sha256 at both revisions), hard-linked | AUD-S's line with the Coder's pack, `--expert-profile /data/expert-profile-coder.bin` (its sha256 is recorded nowhere yet: it is pinned from AUD-S's commit at staging, written into the spec's `serve` and the marker, and a mismatch at start is PREFLIGHT-REFUSED), and setup's rule at 131,072 (`--kv int8 --kv-resident 32768`: 61.23 ≥ 32 + 1.70 + 1) | **exploratory**: no G1 pair, no band; runs only by rule C3, after its own smoke boot | **Strata's interpreter.** Without `jsonschema`, Strata HEAD's `serve/structured.py` checks only that an answer is one JSON object (`structured.py:6-8, 35-51`), and HEAD's `requirements.txt` does not list it. So the interpreter that runs Strata's server is part of the engine line: AUD-S and AUD-C run Strata's server on the interpreter that the S arm whose line they take ran with (that arm's marker, `--strata-python`), named by path and version in the spec's `serve` and the marker. Before boot, the harness runs that interpreter **inside the aud phase's own sandbox with the server's own environment** (AUD-4) and reads `importlib.util.find_spec("jsonschema")` and `find_spec("referencing")`, importing neither. Every AUD-S and AUD-C row, and C-a's mechanism line, carry `structured_validation: schema` (both found) or `object-only` (either missing). The reading is recorded, not a gate. Every AUD engine runs at the 131,072-token context its speed arm ran. The kit's own window, 65,536 tokens (`screen.json` `window_tokens`), is enforced by the kit's CONTEXT-FULL test in the client (AUD-4), so no AUD engine refuses a call the kit would send and no new engine configuration is introduced. **AUD-2 · The selection rules, fixed now.** - **The AUD file (rule F)**, read from this bench's own records after the quality block. Rule F holds only as registered before any quality row existed (the timing paragraph at the head of Part A): - F1: **IQ3_S** if S-IQ3 and L-IQ3 each ran to RESULT (G0 passed) and the IQ3 pair passed G1 (A1-1's counting). - F2: else **Q2_0** if S-Q2 and L-Q2 each passed G0 and the Q2 pair passed G1. - F3: else **IQ3_S** if both IQ3 arms passed G0. Every AUD table then carries "G1 MISSED on this file (n of 108, m of 48)", and the agreement section (AUD-7 C-f) prints under the words "the engines disagreed at G1; agreement here is not fidelity". - F4: else Q2_0 under F3's words, if both Q2 arms passed G0. - F5: else no AUD-S or AUD-L run. Both are recorded PREFLIGHT-REFUSED with the reason. - IQ3_S is preferred at every rung because it is the fair engine-against-engine pair (both engines on ggml's AVX2 i-quant kernels; llama.cpp's x86 Q2_0 path is generic C: RECON-v1:411-416), because the Coder's experts are stored like IQ3_S, and because HEAD's Q2_0 prompt kernels are fused and not byte-identical to earlier releases (STRATA-DELTA, "What a HEAD arm changes"). - **The Strata commit (rules C1-C3).** - C1: AUD-S runs at **HEAD `36fa455e`** when all of these hold: - the lead has written the ledger row ruling STRATA-DELTA's HEAD arm; - the stage reads `git rev-parse v0.1.36^{commit}` = `36fa455e579b23a9c909c2c6fe1bddd9e51cb8ca`; - STRATA-DELTA's conditions 1-8 hold as S-HEAD applied them, including HEAD's `data/draft_vocab_en.bin` in its own `rt` folder and the agent-facing files read as untrusted data; - AUD-S's own boot passes G0 (section 2's G0 row, read by `engines.strata_g0`); - the AUD file is IQ3_S and S-HEAD reached RESULT on it (S-HEAD has a line on IQ3_S only, so on Q2_0 there is no HEAD line that has run). - C2: otherwise AUD-S runs at `8fc40dde` as **AUD-S-PIN** on the S arm's line. Every AUD-S-PIN table prints two sentences: - "8fc40dde reads no `response_format` (its server has no structured-output code), so the schema reaches the model only through the prompt's own words, and every FORMAT-FAILURE is the kit's python check." - "8fc40dde has no thinking budget (`reasoning_budget_tokens`, #123, came later), so the think-medium call may think up to its 14,336-token `max_tokens`." - C3: AUD-C runs only after AUD-S and AUD-L each reach RESULT or REFUSED with no stop condition fired, at AUD-S's commit. Its files must pass a fresh Hugging Face read of revision `5348543e…` and the sha256s above before any byte is pulled. The pull happens while no `~/CARD-LOCK` exists (PLAN-v2 §2.1's pull rule). - **The smoke boot (the dry-run law: AUD-C is a configuration no arm has run).** Before the measured AUD-C run, one `driver.py run --arm AUD-C --phase aud-smoke`: boot, G0, one 64-token call, stop. `aud-smoke` is its own phase, so its RESULT does not trip the measured `aud` phase's launch-once marker (like the fit phase, only the smoke attempt's own markers count). A REFUSED or STOPPED smoke means the measured run does not start until the lead has read the reason and fixed the configuration slip; the measured `aud` attempt stays unopened. **AUD-3 · The pass spec.** Each AUD arm's spec is the bench box's `pass-dry-e3.json` (`fbae63c13c82769e51b786306a891c6b5c94c8787fe5399cc415fd1dd638aa15`) with exactly six fields changed: `pass` (`aud-s-dry-e3`, `aud-l-dry-e3`, `aud-c-dry-e3`), `what`, `model` (the file, by name and revision), `serve` (the engine and commit), `prompts.path` (the frozen stage's `standin-v0.json`; its `sha256` unchanged) and each run's `snapshot` path (E3/pre on the laptop, `~/bench-archive/plans-2026-10-01/local-agents/replay-set/snapshots-kit/E3-pre`). `label` (DRY RUN), `decoding` (think-off), `budget_card_hours` (2.0), `prereg_sha256` (null), `notes`, and every run's `shape`, `seed` (1031), `decoding`, `max_calls` and `manifest_sha256` are byte-equal to the bench box's. Each spec's sha256 is recorded at its writing, and the spec is written into the run's attempt folder (the sandbox binds folders, not files: AUD-4). **Before any engine starts**, the client refuses unless: - **First, before any file is opened (the pre-read guard).** The kit's own label check runs only after `la_snapshot.verify` has hashed every file of a named snapshot (`la_r1.py:298-301`, `la_snapshot.py:570-609`), and a held-out snapshot is sealed by where it is written, never by its mode (`la_snapshot.py:68`). So the client first compares strings, with no filesystem call: each `runs[*].snapshot`, after `~` expansion and `os.path.normpath`, must equal E3/pre's registered path above; each `manifest_sha256` must equal `788fb80fb88e1fc50dfe3063d0dc43ef75b03385a797e7597cb25373ea02dc79`; `prompts.path` must equal the frozen stage's `standin-v0.json`; and no path in the spec may lie under `heldout/`, `key-v2-work/`, `replay-set/bundles/` or `replay-set/snapshots/`. Only then does it take the `realpath` of each accepted path and refuse unless it is unchanged (no link leads elsewhere). Any miss is PREFLIGHT-REFUSED, and the refusal names the run index and the check, never the path. The driver runs the same guard in its preflight (outside the sandbox), before it touches any path the spec names, and the client runs it again inside the sandbox; - `la_r1.check_spec_shape` and `la_r1.label_problems` (DRY RUN, card line) both read empty; - `la_r1.verified_snapshots` reads E3/pre whole against MANIFEST `788fb80f…`; - `la_screen.load_prompts` reads `5bdf385a…`, and `la_screen.config()` / `schema()` load `screen.json` `55359ef0…` and `submit-findings.schema.json` `f1364ce7…`; - the two plans' digests are `83cde0443f130adff4fc9318cb8fbb0bfc8b2bec941ecece375a61b6a117f49f` (review, 8 calls, 694,593 characters) and `ffa56b7806cc96cf730f4614cbac0ecd81cb3cd17d5006d93cc83431c0849fac` (sweep, 45 calls, 3,610,190 characters). These are the digests the bench box's arm expects, so the three arms' clients send the same messages byte for byte. (What each engine then does with a message differs: AUD-8.) **AUD-4 · The client: the kit's code, unedited, through an engine adapter.** - **The kit's code.** The client imports the kit from a frozen `git archive` stage of estate `530bdef3ed17b0d42da8f0e868bd864bec31c758` (the commit whose trees `bench/local-agents-2026-10-01` `2c66d45b215b…` and `bench/kits/vllm-seats` `cd0faba414db…` the bench box's arm stages). No kit file is copied into the harness or edited. A `git archive` stage carries no tree ids, and `stage.sh` writes the commit's tree ids from git, not from the staged bytes, so the tree ids alone are not a byte check. Instead: - **at every AUD start**, before the engine unit exists, the driver (outside the sandbox) hashes each staged file as a git blob and compares the set of (path, blob id) to `git -C ~/estate ls-tree -r 530bdef3 -- bench/local-agents-2026-10-01 bench/kits/vllm-seats`, refusing any extra, missing or differing file (PREFLIGHT-REFUSED); - the kit runs under `python3 -B` with `PYTHONDONTWRITEBYTECODE=1`, so no `__pycache__` lands in the stage; - the stage lives in a durable folder the lead names at staging (under `/data/strata-bench/`, so the sandbox's `/home` mask does not hide it), made read-only (files 0444, folders 0555), never in a lane cache that is removed when its lane ends; - the kit's tests run once against the stage, and the raw tally is cited beside the bench box's receipt (250 passed, 0 failed, 250 collected). Per D-20261002-042's operational note, TMPDIR sits unsealed and outside HOME, or 17 clean-launcher checks correctly refuse a sealed parent. - **The run object.** `AudRun`, a subclass of `la_r1.ScreenRun`, runs the kit's own `pin_pass`, `probes`, `one_run`, `idle_read`, `hold`, `on_row`, `engine_gone` and `write`, unchanged. It overrides only five things and one class attribute: - construction, so no `la_serve.SERVE` key is looked up; - `pins`: `pin_pass`, then, straight after it, `doc["label"]` replaced by AUD-6's sentence (`pin_pass` writes the module's R1a label, `la_r1.py:289`), then the harness's own file and engine pins. The findings head keeps the spec's `label: "DRY RUN"`; - `boot`: the harness has already started the engine and read G0; - `check_stop`: it reads the harness's stop request and telemetry guards; - `shutdown`: the harness stops its server; - the class attribute `PREFIX = "strata-aud"`, so run ids read `strata-aud-…`, never ScreenRun's inherited `la-r1-…`. It also annotates each row before calling the kit's `on_row`: - the adapter's translation (`adapter`, `engine_http`, `count_how`, `structured_validation`); - **on a Strata 502 (T-3)**, `think_tokens`, `content_tokens` and `completion_tokens` set to null, with `think_rule: "unread: Strata withheld the answer (HTTP 502)"`. The kit writes 0 for an absent `reasoning_content` (`la_probes.py:187`), and `one_run` copies that 0 into the findings record before `on_row` runs (`la_r1.py:403-404, 414`), so the 0600 findings file keeps the kit's 0; no AUD figure reads the findings file; - **a row-key allowlist**: `on_row` refuses (REFUSED, naming the key, never its value) any row key outside the kit's own row keys (CRITIQUE-AUD's list under "Row keys the kit writes", read from the walk's outward rows) plus AUD-5's per-call keys. A test pins the set. The kit's pen does not stop model text: `pen.TEXT_FIELDS` lets it through and scans it only for UUIDs, paths, addresses and box names (`pen.py:54`). So every outcome (SUBMITTED, FORMAT-FAILURE, CONTEXT-FULL, BUDGET-HIT, ENGINE-ERROR, NOT-RUN), the budget shares, the findings file and the outward rows come from the kit's own lines. - **The adapter**, one object with the kit's `http.call(method, url, body, timeout) -> (status, obj, seconds)` contract (`la_engine.UnixHTTP.call`). It speaks HTTP over loopback inside the harness's no-network sandbox and sends the harness's per-run key as a bearer header. The key never appears in a row. - **AUD-L:** every request and answer passes through unchanged. - **AUD-S and AUD-C**, the only translations (each one recorded on the row as `adapter`): - **T-1.** When a body carries `thinking_budget_tokens`, the same value is added as `reasoning_budget_tokens` (Strata's name, `serve/server.py:883-895` at HEAD; absent at the pin). No other body field changes. - **T-2.** `POST /tokenize` is answered in the adapter by llama.cpp `3cf03257`'s `llama-tokenize`. It loads only the vocabulary of the same shard 1 (add_special false, parse_special false: the kit's `/tokenize` semantics), and the text goes in on stdin and never to disk. The tool is not built yet (the build folder holds `llama-bench`, `llama-cli` and `llama-server`): its target is built from the same `3cf03257` tree, CPU only, in the single build lane, before the aud phase's dry run. Its argv is `llama-tokenize -m --stdin --ids --no-escape --no-bos --log-disable` (`parse_special` is off by default). `--no-escape` matters: escape processing defaults on at `3cf03257` (`common/common.h:565`) and is applied to stdin (`tools/tokenize/tokenize.cpp:173-176`), so code holding a literal `\n` would be rewritten before counting, which the server's `/tokenize` never does. `--ids` matters: without it the tool prints every token's text piece, which for the think and content counts is Flash-Next's text. The adapter keeps only the count; the id list is never written or logged. Strata has no `/tokenize` and no `/apply-template` (its POST routes, `serve/server.py:2021-2079`), so the kit takes its own fallback count, "tokenize(system)+tokenize(user)+64" (`la_r1.py:245-257`), and its own think and content counts (`la_probes.py:142-152, 187-189`). The row's `count_how` says so. - **T-3.** A `502 structured_output_failed` (HEAD's prompt-and-validate refusing an answer, `serve/server.py:2085-2087`) becomes the answer object `finish_reason: "structured_output_failed"`, with no content and the call's `timings` from `GET /v1/status` `last_timings` when that reading postdates the request. The kit's `read_submission` then counts a FORMAT-FAILURE. Strata's error message goes to the run's 0600 `private/generated.jsonl` and never to a row. The row carries `engine_http: 502` (the kit's own `http` reads 200 on that row, so every AUD reader reads `engine_http`). From the same `last_timings` reading the row also records `predicted_n` and `hit_max_tokens` (`predicted_n >= max_tokens`), which recovers the length class (`structured.py:133-134`) without reading the message. On Strata HEAD every other failure reason (not JSON, a duplicate key, not an object, a schema break) collapses into the one `structured_output_failed` string. - **T-4.** Each chat call's client timeout is the harness's `--request-timeout-s` (2,400 s), in place of `la_probes.chat_row`'s 900 s. The kit reads a client timeout as an engine death and REFUSES the run (`la_r0.py:203-212`), and a slow MoE answer is not a dead engine. This applies to AUD-L too. - **Where things go.** Rows go to `records//aud/a/screen/rows/.json` through the kit's pen (`la_r0.Run.write`), in the shape `benchbox-first-arm/read_dry_rows.py` reads unchanged. Findings go to `screen/private/findings/.json` (0600, `la_r1.write_findings`) and raw answers to `screen/private/generated.jsonl` (0600, `la_probes.SideFile`). `private/` is 0700. - **The never-collect rename.** `screen/private/findings/` is the very path `dev_tune_serve.stage()` reads (`dev_tune_serve.py:185`), and a finished AUD window passes every check in `handback_problems` (DRY RUN is in its LABELS; E3/pre reads split `dev` and `for_prompt_author: true`; the bundle is the stand-in's; the run is not partial). So when each AUD run ends (RESULT, REFUSED or STOPPED), the harness renames `records//aud/a/screen/private/` to `records//aud/a/aud-private/` (0700) and records the rename in the marker. A harness death before the rename leaves a partial window, which `handback_problems` refuses as partial; the driver's next start renames any `screen/private/` it finds under an `aud/` attempt before its launch-once check. `read_dry_rows.py` reads only `screen/rows/`, so it keeps working. - **The side-file window scan (counts only).** After every AUD run, a harness script takes each string in the run's side files and counts, printing counts only, how many of its 40-character windows occur in any open (non-side) file of the attempt; the run's marker carries the count, and 0 is required. A non-zero count holds every figure of that run out of AUD-7 and goes to the lead as counts and open-file names only. No Claude agent opens a side file to run it. - **The sandbox (no `/home`).** The harness sandbox is `bwrap … --ro-bind / /` with no mask over `/home` (`harness/units.py:33`), and the client and both engines (Strata is third-party code) run as the owner of the 0700 folders `heldout/`, `key-v2-work/`, `replay-set/bundles/` and `replay-set/snapshots/`, so their mode stops no read. The aud phase's sandbox therefore adds `--tmpfs /home` straight after `--ro-bind / /`, then binds back, read-only, only the harness folder and E3/pre, and read-write only the run's attempt folder (which holds the spec). The frozen kit stage, the engines, the model files and the build trees live under `/data` and are untouched by the mask. `units.bwrap_argv` already takes `ro_binds` for this (it binds folders, not files). The engine's `HOME` points at a folder inside the attempt folder. The dry run (Part G, Q-6) proves the masked sandbox: the stub leg and the CPU llama-server leg both run inside it. - **The engine's environment.** The harness's launch passes the whole environment today (`env = dict(os.environ)`, `harness/inner.py:132`). `STRATA_DEBUG` would dump raw model text into the open `server.log` (`server.py:1291, 1440`), and llama-server reads `LLAMA_ARG_*` (for example `LLAMA_ARG_VERBOSE` logs request and response bodies). The aud phase builds the server's environment from an allowlist (`PATH`, `LD_LIBRARY_PATH`, `CUDA_*`, `HOME` as above, and the per-run key), refuses to start (PREFLIGHT-REFUSED) if `STRATA_DEBUG`, any `LLAMA_ARG_*` or any `LLAMA_LOG_*` is present in the environment it was handed, asserts that Strata's written config has no `api_monitor`, and records all three checks in the marker. **AUD-5 · Recorded per call, beyond the kit's own row fields.** - `engine_http`, `adapter` (T-1..T-4 as applied) and `count_how`. - On AUD-S and AUD-C, `structured_validation` (`schema` or `object-only`, AUD-1). - On a Strata 502, `think_rule` ("unread: …") with the three token counts null, plus `predicted_n` and `hit_max_tokens` from `last_timings` (AUD-4, T-3). - From the engine's `timings`: `cache_n` and `prompt_n`, plus `draft_n` and `draft_n_accepted` where Strata reports them. - From `usage`: `prompt_tokens`, the prompt the engine actually read, including Strata's structured-output additions, reused tokens included (on Strata, `prompt_n` excludes what its conversation cache reused: AUD-7). - The harness's telemetry window (board watts, RAPL package-0 labelled "not wall", NVMe reads per second, VRAM against the pre-load baseline, GPU and SSD temperatures), as the speed rows carry it. These names, with the kit's own row keys, are the whole row-key allowlist (AUD-4). Per arm, also recorded: - the engine line by its sha256, and on AUD-S and AUD-C the interpreter's path and version and its `find_spec` reading; on AUD-C the expert profile's sha256; - the G0 record; - the spec's sha256 and the pre-read guard's result; - the stage's byte check against `530bdef3`'s blob list (files compared, extra, missing, differing); - the environment checks (the allowlist, the refused-variable check, no `api_monitor`); - the never-collect rename, and the side-file window scan's count; - the lock word and token; - `kit_word_not_used: la-r1`. **AUD-6 · Labels.** Every AUD row, table and line reads "DRY RUN: AUD (Strata bench §6): the la-r1 kit's E3 calls through the Strata harness; no reading". AUD-C adds "exploratory: no G1 pair for this file"; AUD-S-PIN adds C2's two sentences; every AUD-S line at HEAD adds "exploratory (HEAD; PREREG §1)". The rows carry this sentence as their `label` and a `strata-aud-…` run id (AUD-4's `pins` override and `PREFIX`), never the kit's "R1a" label or an `la-r1-…` id. The aud phase's tests pin both, and pin that `dev_tune_serve.stage()` refuses a finished AUD window. **AUD-7 · The comparisons, computed from rows only.** Flash-Next's generated text stays in the 0600 side files, and no Claude agent opens them. D-20261002-047's lift covers triage and the prompt author only, and AUD feeds neither. Every figure below is a count or a timing the kit or the harness computes, and none is text. That "rows carry no text" holds by mechanism, not by intent: the row-key allowlist and the environment allowlist (AUD-4) close the two routes by which text could reach a row or an open log, and the side-file window scan (AUD-4) is the per-run receipt. `records/*/aud/*/aud-private/` is closed by its mode only; until the lead adds it to LANE-PREAMBLE §1's path table and to `closed_path_scan.py`'s rows, every brief that touches the Strata bench names it closed (a brief can narrow). This claim covers the AUD rows only; the bench's speed and quality rows are Part G, Q-9. Every reader of AUD rows reads `engine_http`, never the kit's `http`, which reads 200 on a Strata 502 (T-3). - **C-a · Format.** FORMAT-FAILURE over sent calls (SUBMITTED + FORMAT-FAILURE + ENGINE-ERROR), per run and per arm, with an exact 95 % Clopper-Pearson interval (`la_probes.clopper_pearson`). For AUD-L, failures are binned by the kit's own reason classes (turn not `stop`; empty; not JSON; breaks the schema). For AUD-S and AUD-C at HEAD, where every engine-side failure reason collapses into one finish string, the print is one `structured_output_failed` total (with its `hit_max_tokens` count beside it) plus the kit's own classes for answers Strata did deliver; the arms are compared as totals only. Each arm's figure is printed beside its **mechanism**: - AUD-L: grammar, llama.cpp's JSON-schema decoding; - AUD-S / AUD-C at HEAD: prompt and validate, with no constrained decoding (`serve/server.py:1170-1171`), qualified by the run's `structured_validation` (`schema`: validated against the JSON Schema; `object-only`: checked only as one JSON object, so schema breaks surface as the kit's own "breaks the schema"); - AUD-S-PIN: the prompt's own words only. Read across arms, the figure compares these mechanisms on real audit calls. It is not an engine-fidelity figure. - **C-b · Call sizes against the window.** Per call: the kit's count and how it was taken; the engine's `usage.prompt_tokens`; and on Strata, the difference from AUD-L's count for the same `call_id` (Strata's structured-output additions, when both ran). Also: the largest call plus its generation cap and the 512-token margin against 65,536; the CONTEXT-FULL count. Engine-side call sizes are taken from `usage.prompt_tokens`, never from `prompt_n`. For every Strata call, `usage.prompt_tokens`, `cache_n` and `prompt_n` print side by side, and every call with `cache_n > 0` is flagged. Strata does not honour `cache_prompt: false` (HEAD's `serve/server.py` contains `cache_prompt` 0 times; its conversation cache reports reuse as `cache_n`, `server.py:1467-1474`), so the kit's contract, "no state crosses a call, a run or an episode" (`la_r1.py:36-37`), holds on AUD-L and on the bench box but not on Strata. The think-medium run resends `review-c01` byte for byte after the eight review calls in the same server start, so Strata may reuse almost all of it. `read_dry_rows.py`'s "prompts (engine count)" line sums `prompt_n`; on Strata it prints with the words "excludes conversation-cache reuse". - **C-c · Think.** The think-medium call's think tokens against the 8,192 cap, its finish reason and its content tokens. Any think-off call with think tokens > 0 or `think_in_content` true is counted. Calls whose think tokens are unread (a Strata 502: null, AUD-4) are counted apart and never as 0. - **C-d · Wall time.** Per call `wall_s` (client clock): the median and maximum per run, beside the run's budget share and BUDGET-HIT count. Strata's figures, here and in C-e, carry "conversation cache on: Strata does not honour `cache_prompt: false`". - **C-e · Speed under the audit calls.** - Prefill: `prompt_n / prompt_ms`, the tokens the engine read. Strata's `cache_n` is excluded from this rate and printed beside it. - Decode: `predicted_n / predicted_ms`. Both are the engine's own timings, as `read_dry_rows.py` prints them. - Both print per call and as each run's median, beside the same arm's section-4 speed row at 32K, with the words "the AUD calls are sampled (temperature 0.7 / 1.0, presence 1.5 at think-off), schema-bound and 25-50k tokens deep; the speed rows are greedy 256-token answers". - **C-f · Engine agreement on shapes, AUD-S against AUD-L** (and descriptively AUD-C against AUD-S), over the calls both arms sent: - the outcome 2×2 (SUBMITTED or not, per arm, with ENGINE-ERROR and Strata's 502s read from `engine_http`), with the exact two-sided McNemar test on its discordant cells; - over calls SUBMITTED in both, for `findings_n` and for `kit_anchored_n`: exact agreement, agreement within 1, the median absolute difference, and each arm's total; - each arm's anchored share. Printed under the words "k = 1 at sampled decoding: two engines on one file are not expected to give the same answer, so agreement bounds closeness, not fidelity; G1 (greedy) is the fidelity gate". When AUD-S ran at HEAD the caption adds "G1 was measured at 8fc40dde; at HEAD fidelity is unmeasured", and, where S-HEAD's own quality rows exist, quotes them by A1-1's counting as a descriptive n of 108 and m of 48. - **C-g · Watts.** J per 1,000 generated tokens from the board trace, per run, labelled DRY RUN. **AUD-8 · The cross-box comparison to the bench box's arm** (Qwen3.8-27B UD-Q4_K_M, the same 54 calls), when it has run. The bench box's side is read from its receipts (`06-readings.txt`), never from its 0600 window copy. One table, C-a to C-e side by side, printed under these sentences: "Box, card, engine build, model, quant and KV type all differ, and the engines honour the same request differently. Strata at 36fa455e adds a format directive and its schema to the system prompt and keeps a conversation cache across calls. 8fc40dde sees no schema. llama.cpp constrains decoding by grammar. AUD's client waits 2,400 s where the bench box's waits 900 s. These columns share only the request bodies the kit built: the calls, the sampling fields, the seed and the schema. A difference in any column has at least six candidate causes and names none of them." (The engine builds differ too: the bench box runs the bundle's llama-server b11081, llama.cpp `161755f2`; AUD-L runs `3cf03257`. T-1 adds one body field on Strata's think-medium call.) The per-call prompt counts are the one column expected to be near equal (the same tokenizer family is inferred); a gap above 2 % is opened as a tokenizer finding before anything else is read. **AUD-9 · Bets, registered before any AUD row** (descriptive, DRY RUN; a refuted bet stays on the page; a reading outside its band is opened under A1-4's rule before anyone quotes it; a bet whose reading is unread, as on a Strata 502 whose think tokens are null, reads UNREAD, never refuted; every bet on AUD-S at HEAD is exploratory, PREREG §1): | id | bet | |---|---| | AUD-B1 | AUD-L: FORMAT-FAILURE ≤ 2 of the 53 think-off calls sent (grammar) | | AUD-B2 | AUD-S at HEAD: FORMAT-FAILURE above AUD-L's and ≤ 15 of 53 (prompt and validate; read with the run's `structured_validation`) | | AUD-B3 | No CONTEXT-FULL on any arm (the largest E3 call is ≤ ~50k tokens even at 2.2 characters a token; plus 14,336 and 512 it stays under 65,536) | | AUD-B4 | The think-medium call reaches the 8,192-token think cap on AUD-L and on AUD-S at HEAD, then ends `stop` with content | | AUD-B5 | Median decode per call: AUD-S 25-70 tok/s, AUD-L 10-40 tok/s, AUD-C 25-75 tok/s | | AUD-B6 | Median prefill (tokens read per second): AUD-S 800-2,500, AUD-L 250-1,200, AUD-C 1,000-3,400 | **AUD-10 · Stop conditions** (section 3's, plus): - **S-1.** Every section-3 condition, through the harness's guards: a CPU refusal, memory pressure, SSD above 80 °C, or the GPU guard. - **S-2.** Any AUD-3 pin or digest fails (the pre-read guard first), the stage's byte check finds an extra, missing or differing file, the Coder's profile sha256 differs (AUD-C), or the environment check fails (AUD-4): PREFLIGHT-REFUSED, and no engine starts. - **S-3.** G0 fails at the AUD boot: REFUSED. - **S-4.** An engine death or a transport failure: the run is REFUSED at that call (the kit's rule), never retried. Launch-once by the harness's markers. - **S-5.** The pass's 2.0 card-hour cap, shared by planned characters (review 1,000 s, medium 1,000 s, sweep 5,199 s): calls past a share read BUDGET-HIT. The unit's wall is 10,800 s (`la_r1.runtime_max_sec`). - **S-6 · withdrawn (no futility stop).** All 45 sweep calls are sent whatever the review run reads. A runtime cap cannot be built from AUD-4's overrides (`check_spec_shape` refuses `max_calls: 0`; `one_run` reads `max_calls` once, before its loop; `probes()` keeps the run summaries in a local), it would change the bench box's pass, which D-20261002-047 says the arms run unchanged, and D-20261002-042 refused a cap on the bench box's arm because "the real call sizes, the FORMAT-FAILURE rate and the think length are the whole purpose of this arm". The number S-6 is kept unused so S-7 and S-8 keep their names. - **S-7.** A non-zero `c2_candidates` count goes to the lead before any other AUD figure is read (la-r1 PREREG R1.8.1). - **S-8.** The turbo fan: no AUD card step starts unless an operator's fan session is on. A gap since the speed and quality blocks means asking again. **AUD-11 · Order, minutes, memory.** - **Order.** After section 1's arms and the quality block (rule F needs G1): AUD-S, then AUD-L, then AUD-C's smoke boot (`--phase aud-smoke`, C3), then AUD-C. Each is one `driver.py run`, one server start, and the lock taken and released per run. - **Minutes and memory**, inferred; the lead narrows them from the speed rows before announcing: | Arm | Card minutes (boot included) | Resident RAM | MemoryMax | MemAvailable floor | |---|---:|---:|---:|---:| | AUD-S (IQ3_S) | 27-83, central ~45 | 49.8 GiB (46.8 pinned arena + 3.0) | 54 GiB | 51.3 GiB | | AUD-L (IQ3_S) | 51-131, central ~90 | N/48 × 46.8 + 3.0 GiB | min(working set + 14, MemTotal − 6) | working set + 4 | | AUD-C smoke boot | ~3-9 (boot 2-8, G0, one 64-token call) | as AUD-C | 30 GiB | 28.0 GiB | | AUD-C (Coder) | 22-75, central ~40 | 26.5 GiB (21.8 + 3.0 + 1.7 KV in RAM) | 30 GiB | 28.0 GiB | | AUD-S-PIN on Q2_0 (rule F2/F4; C1 needs IQ3_S) | ~20-70 | 36.3 GiB | 40 GiB | 37.8 GiB | **AUD-12 · What AUD cannot say.** - Nothing about Flash-Next's audit quality: the stand-in prompt, one dev episode and no key make every finding count descriptive. - Nothing about any held-out episode. - Nothing about Strata as a seat: one request at a time, RECON-v1:408. - Nothing about a llama.cpp or Strata commit other than the ones that ran. - Nothing about Strata with its conversation cache off: Strata does not honour `cache_prompt: false` (AUD-7 C-b). - Nothing about engine fidelity at HEAD: G1 was measured at 8fc40dde (AUD-7 C-f). - Nothing that the bench box's arm would show about the 27B: the cross-box table names at least six candidate causes for every difference. --- ## 7 · Amendment A2 and the lead's rulings (registered 2026-10-02T21:14:07Z, before any Strata row of this bench existed) - **A2 · "cold" for Strata (A1's open decision):** one server per arm and phase, as built. Every run carries its nonce and `requests_since_start`, and Strata's adaptive expert cache carries over between runs, as it does for any user. The first run of each context after a load is labelled `first-after-load` in the summary, and no fresh server is started per run. Why: the bench measures what a user of this engine gets; a fresh server per run would add 9 loads of about 20-40 s each to measure only the empty-cache case, and the hit rate on every row already shows the carryover. - **The S-HEAD arm is RULED IN** at `36fa455e579b23a9c909c2c6fe1bddd9e51cb8ca` (v0.1.36), under STRATA-DELTA.md's conditions 1-5 verbatim (no setup/update/docker, pinned by full sha, `-DSTRATA_GGML_DIR` local, an API key set, the new opt-in keys left out). It is built (receipts/build-strata.log, bin sha 5de8cbf464d9a582); 8fc40dde is built too (dba544d9e8d18225). Ledger D-20261002-048. - **Q-9 (AUD's I-10) · Flash-Next text in the speed and quality rows:** under LA-3 (a) (D-20261002-047), generated text in these rows is internal processing: house agents may read it to audit the bench. None of it is printed in any summary, page, post or kit; public-bound tables carry counts and figures only. The AUD arms keep the stricter 0600 side-file rule as AUD-ARMS v2 writes it. - **The two harness fixes after the first fit** (the load-phase PSI line and `-lv 4`; see receipts in the records and VERIFY-HARNESS-FIX.md when it lands) change no registered gate, band or arm. They change only when the safety stop fires and what the server logs. The fit attempts a1-a5 they voided stay on disk as STOPPED/REFUSED records. ## 8 · Amendment A3 (registered 2026-10-02T22:20:40Z, when only L-IQ3's fit attempts a1-a9, FROZEN-NCMOE-L-IQ3.json (N=34), SLICES.json and L-IQ3's speed attempt a1 (RESULT, 20:53:28Z-21:31:24Z, at llama.cpp's default 4 threads) existed [records read: L-IQ3: fit/a1 … fit/a9, speed/a1]; no L-IQ3-t8, L-Q2, Strata, quality or AUD row of this bench existed) Written by the strata-harness-fold lane under the lead's ruling of AUDIT-HARNESS I-1 as (b), the audit's own recommendation (ledger D-20261002-048), and an operator's "keep rolling with the rest of your recs" (that row). No gate, band, threshold or stop condition in sections 1-7 moves. - **A3-1 · The thread rule.** From this amendment on, every llama.cpp launch carries `-t 8 -tb 8`. The Core Ultra 9 290HX Plus has 8 P-cores and no SMT; llama.cpp 3cf03257's default (`common_cpu_get_num_math`, `common/common.cpp:182-195`) assumes SMT siblings sit side by side, skips every other P-core and counted 4. The rule covers L-IQ3-t8, every phase of L-Q2 (fit, speed, quality), L-IQ3's quality phase (its only phase not yet run) and every later llama.cpp launch, AUD-L included. - **A3-2 · L-IQ3's speed attempt a1 stands as recorded,** under its own label, at 4 threads (its server.log: `n_threads = 4 (n_threads_batch = 4) / 24`). Every figure from it prints that thread count beside it. Launch-once forbids re-running it. - **A3-3 · The arm L-IQ3-t8,** registered by this amendment: llama.cpp at 3cf03257 on ISTA IQ3_S, L-IQ3's line exactly (`-ngl 99`, the frozen `--n-cpu-moe 34` read from FROZEN-NCMOE-L-IQ3.json because the fit is about VRAM, not threads, `-lm mmap --lazy-mode on`, `-fa on`, 8-bit KV and the harness's recorded extra flags) plus `-t 8 -tb 8`; contexts 4K, 32K and 128K, 3 repeats, the same SLICES.json and the same nonces. Speed only: a quality phase would repeat L-IQ3's own quality phase, which A3-1 already runs at 8 threads, so G1's llama.cpp sides stay L-IQ3 and L-Q2 as section 4 registered them. Its band is L-IQ3's (20-55 tok/s at 4K), registered at 19:26:17Z before any row; no band is drawn after the 4-thread readings were seen, and a reading outside it is opened under A1-4. - **A3-4 · Threads on every row.** Each llama.cpp start's own `n_threads = N (n_threads_batch = M)` line, and Strata's `N expert-pool workers[ + the host thread]` line (Strata takes no thread flag), go into the marker's facts and every speed, quality, fit and load row, and the summary prints them beside every speed figure. For rows written before A3 the summary reads that attempt's own log line and says so. - **A3-5 · The rest of the harness fold** (FOLD-HARNESS.md: AUDIT-HARNESS B-1, B-2 and I-2 to I-9, and VERIFY-HARNESS-FIX's two IMPORTANT findings) moves no gate, band or threshold. Three changes touch what sections 2-4 registered, each only in the stricter direction: - A speed row whose token count fails its check is withheld from the figure of record, never added: llama.cpp rows need `token_frames == completion_tokens + 1`; Strata rows need usage within 3 % of the engine's own "N generated" line, `/metrics` `output_tokens` and a recount of the kept reply text on llama.cpp's tokenizer. - Each Strata arm boots once in a `load` phase (probe, G0, a 10 s hold, no request) before its first speed or quality run, so a launch slip costs a load attempt and not the registered arm. A G0 refusal there is the arm's G0 refusal. - The memory stop's lines (40 % while loading, 10 % from 30 s after ready) read the larger of the system-wide PSI and user@1000.service's own, the cgroup systemd-oomd acts on, and a pre-start settle that times out refuses the start instead of proceeding. ## 9 · Amendment A4 (registered 2026-10-03T00:45:06Z, when only these records existed [records read: L-IQ3 fit: a1 STOPPED, a2 REFUSED, a3 STOPPED, a4 STOPPED, a5 REFUSED, a6 RESULT, a7 RESULT, a8 REFUSED, a9 REFUSED; L-IQ3 quality: a1 STOPPED, a2 STOPPED; L-IQ3 speed: a1 RESULT; L-IQ3-t8 speed: a1 RESULT; L-Q2 fit: a1 RESULT, a2 RESULT, a3 RESULT, a4 RESULT, a5 RESULT; L-Q2 speed: a1 RESULT; S-Q2 load: a1 RESULT; S-Q2 quality: a1 running (no marker yet); S-Q2 speed: a1 RESULT; and FROZEN-NCMOE-L-IQ3.json, FROZEN-NCMOE-L-Q2.json, SLICES.json]; no L-IQ3-fa0 or L-Q2-fa0 row of this bench existed) Written by the strata-fa0 lane under the lead's ruling D-20261002-056, which acts on an operator's D-20261002-044 ("so we have to test that asap …") and D-20261002-054. No gate, band, threshold or stop condition in sections 1-8 moves, and every registered arm keeps its line and its records. - **A4-1 · The finding.** L-IQ3's quality attempts a1 (2026-10-02T23:49:50Z to 23:53:59Z) and a2 (2026-10-03T00:07:19Z to 00:11:30Z) both STOPPED on the doorman task's second item, A2 (A1 was answered: a 511-token prompt). Each time the server logged `CUDA error: an illegal memory access was encountered` (`ggml/src/ggml-cuda/ggml-cuda.cu:108`, raised in `ggml_backend_cuda_synchronize`) 60-66 ms into A2's 512-token prompt, which was being processed from an empty cache (server.log: `cached n_tokens = 0`, then the error), and the kernel logged an Xid 31 MMU fault for llama-server (FAULT_PDE, ACCESS_TYPE_VIRT_READ, at the same faulting address both times). The six-way task c completed both times: 108 items, prompts of 189-358 tokens. llama.cpp 3cf03257's commit message is "CUDA: enable sparse fa for qwen4 (#28770)". The full account, with the kernel lines, is `XID31-FINDING.md` beside this file. - **A4-2 · What stands.** L-IQ3's and L-Q2's speed arms keep `-fa on`, as registered. L-IQ3's quality attempts a1 and a2 stand as STOPPED, with their six-way rows recorded; launch-once keeps them. - **A4-3 · The arms L-IQ3-fa0 and L-Q2-fa0,** registered by this amendment. Each is its parent's line (llama.cpp 3cf03257, the same file, `-ngl 99`, the parent's frozen `--n-cpu-moe` read from FROZEN-NCMOE-.json, `-c 131072`, `-ctk q8_0`, `-lm mmap --lazy-mode on`, `-t 8 -tb 8` and the harness's other recorded flags) with flash attention off: `-fa off`. One more flag moves, because the engine forces it: 3cf03257 refuses a quantized V cache when flash attention is off (`src/llama-context.cpp:3732-3740`, "quantized V cache requires flash_attn to be enabled"; the server never reaches /health), so the V cache is `-ctv f16`, llama.cpp's default cache type, and the harness refuses `-fa off` with a quantized V cache before any launch. The lead's ruling said "identical to their parents but `-fa off`"; the V cache type is the only other difference, and it is forced. Each variant runs the quality phase (the same 108 six-way and 48 doorman items, the same instrument, scorer and counting) and may run a load phase (a boot, G0 and a 10 s hold, with no request); neither ever runs a speed phase, so neither has a band or a speed figure. Every table, record and sentence names them with the label `fa-off`. - **A4-4 · G1 under A4.** G1's llama.cpp side is read from the fa-off rows: L-IQ3-fa0 stands for L-IQ3 against S-IQ3, and L-Q2-fa0 for L-Q2 against S-Q2 (and for L-IQ3 against S-HEAD, if S-HEAD runs). Every G1 figure prints with that condition, as "vs L-IQ3-fa0 (fa-off)". A1-1's counting and the thresholds (105 of 108, 47 of 48) do not move. A fa-on quality row of a parent arm, if one ever exists, stays in the record as its own row and is not G1's side. - **A4-5 · If fa-off also faults.** If an fa-off arm's quality attempt completes the six-way and then fails inside the doorman task (the engine dies or a request gets no reply: the stop kinds `error` and `engine_died`), the llama.cpp doorman for that file is recorded as engine-failed. That arm's doorman count and G2 print `not read`, and G1's doorman half prints `not read (engine-failed)`, so G1 cannot read as passed for that pair. Its six-way half is read from that attempt's 108 rows. The first such attempt is the one read; a later attempt that reaches RESULT replaces it, and a repeat that fails again changes nothing. A guard stop (temperature, memory, the outer driver) inside the doorman reads `not read` with its own kind, never `engine-failed`. - **A4-6 · A start that never reaches /health is not the doorman fault.** With flash attention off, llama.cpp's attention keeps a score matrix of context × batch × heads in f32: at `-c 131072`, n_ubatch 512 and 24 heads that is about 6 GiB of compute buffer, and the V cache grows from 816 MiB (q8_0) to about 1,536 MiB (f16). These are arithmetic, not measurements, set against 1,200.57 MiB of compute buffer with flash attention on (L-IQ3 quality a1's server.log) and the free VRAM the frozen fits left: 2,014 MiB at L-IQ3's N=34 and 1,642 MiB at L-Q2's N=24. The fa-off line may therefore not fit the card at the parent's N. A start that fails before /health (a CUDA out-of-memory line, or any exit before ready) is recorded as that attempt's own STOPPED (`exited_before_ready`), with its log; it is never read as the doorman fault and never under A4-5. No other context or `--n-cpu-moe` is registered here: a changed fa-off line is a new amendment, written by the lead before its first attempt. ## 10 · Amendment A5 (registered 2026-10-03T02:29:07Z, when only these records existed [records read: L-IQ3 fit: a1 STOPPED, a2 REFUSED, a3 STOPPED, a4 STOPPED, a5 REFUSED, a6 RESULT, a7 RESULT, a8 REFUSED, a9 REFUSED; L-IQ3 quality: a1 STOPPED, a2 STOPPED; L-IQ3 speed: a1 RESULT; L-IQ3-fa0 load: a1 STOPPED; L-IQ3-t8 speed: a1 RESULT; L-Q2 fit: a1 RESULT, a2 RESULT, a3 RESULT, a4 RESULT, a5 RESULT; L-Q2 quality: a1 STOPPED; L-Q2 speed: a1 RESULT; L-Q2-fa0 load: a1 STOPPED; S-HEAD load: a1 RESULT; S-HEAD quality: a1 RESULT; S-HEAD speed: a1 RESULT; S-IQ3 load: a1 RESULT; S-IQ3 quality: a1 RESULT; S-IQ3 speed: a1 RESULT; S-IQ3-noMTP load: a1 STOPPED; S-Q2 load: a1 RESULT; S-Q2 quality: a1 RESULT; S-Q2 speed: a1 RESULT; and FROZEN-NCMOE-L-IQ3.json, FROZEN-NCMOE-L-Q2.json, SLICES.json]; no fa-off attempt at the 8K line and no second speed attempt of S-Q2, S-IQ3, S-HEAD or L-Q2 existed) Written by the strata-a5 lane under the lead's rulings in ledger D-20261003-063, which act on an operator's words in session 2026-10-02: "laptop fan is cranked so please run any benches you need to on this laptop 5090 that fit in 24g vram" and "keep rolling with your recs, and lmk when the laptop benches are done". A5-1 to A5-4 are the lead's rulings; A5-5 is this lane's account of how the harness holds them. No gate, band, threshold or stop condition in sections 1-9 moves, and every registered arm keeps its records. - **A5-1 · `-ctv f16` on the fa-off variants is confirmed as engine-forced.** 3cf03257 refuses a quantized V cache without flash attention (`src/llama-context.cpp:3732-3740`). Forcing V to f16 also turns off V's Hadamard rotation, which A4-3 did not say: `attn_rot_v` needs a quantized V type (`src/llama-kv-cache.cpp:334-338`), and the start logs read `attn_rot_v = 1` under q8_0 (L-IQ3 quality a1, server.log line 210) and `attn_rot_v = 0` with V at f16 (L-IQ3-fa0 load a1, server.log line 210). K stays q8_0 and keeps its rotation (`attn_rot_k = 1`). Every fa-off table prints "fa-off (V cache f16, forced)". - **A5-2 · The measured fa-off loads at A4's line, and the 8K context.** The lead ran both loads at A4's line (`-c 131072`). L-IQ3-fa0 load a1, 2026-10-03T02:12:00Z to 02:13:24Z, STOPPED `exited_before_ready`: its server.log reads `flash_attn = disabled`, KV 2352.00 MiB (K q8_0 816.00 MiB, V f16 1536.00 MiB), then "allocating 8304.57 MiB on device 0: cudaMalloc failed: out of memory" and "failed to allocate compute pp buffers". L-Q2-fa0 load a1, 02:13:39Z to 02:14:22Z, STOPPED the same way at 8847.57 MiB. Records: `records/L-IQ3-fa0/load/a1/` and `records/L-Q2-fa0/load/a1/`. RULED: the fa-off variants run at a context of 8192 (`"ctx": 8192` in each fa0 row's `llama_flags`; the harness's line already takes a `ctx` override), on the parent's frozen `--n-cpu-moe`, everything else as A4. Why: the quality prompts are at most about 512 + 8 tokens, so an 8K context cuts nothing (read from the records: llama.cpp counted the doorman's A1 at 511 and A2 at 512 tokens; the Strata arms' rows read 504-524 for the doorman and 189-358 for the six-way; the instrument decodes at most 8), while the fa-off score matrix at 128K cannot fit beside the frozen N. Each fa0 arm runs a load attempt (a2) at the new line before its quality attempt. Every fa-off table prints the condition "fa-off at an 8K context"; with A5-1 the summary prints "fa-off (V cache f16, forced) at an 8K context", read from each attempt's own argv (the two a1 loads print "at a 128K context"). The fa-on control at 8K (option c) is NOT registered: whether to diagnose the fault for an upstream report is an operator's call. - **A5-3 · Clean speed re-reads.** The fa0 build lane's dry runs (nice 19, MemoryMax 6G, CPUQuota 200%) overlapped four speed attempts: L-Q2 speed a1 (overlap 00:36-00:38Z), S-Q2 speed a1 (00:39-00:41Z), S-IQ3 speed a1 (00:45-00:53Z) and S-HEAD speed a1 (00:53-01:06Z). Their rows' `load1_mean` read S-IQ3 4.31-6.19, S-HEAD 3.97-8.43, S-Q2 2.03-5.97 and L-Q2 0.99-2.51, against L-IQ3-t8's 1.32-3.78 with no overlap (each the range over the attempt's 9 rows, `telemetry.load.load1_mean`). Each overlapped attempt STANDS AS RECORDED. Each of those four arms gets ONE more speed attempt (its next attempt number, a2) in a quiet window: before each start the chain checks that no other `sb-*` or lane dry-run unit is active, that no other lane process is on the box (`systemctl --user list-units` for `*dry*`, `*fa0ver*`, `*-dry-*` and any lane scope), and that the 1-minute load average is below 2.0 for 60 s; else it waits up to 10 minutes, then records a REFUSED quiet check and moves on. The CLEAN attempt is the figure of record for those four arms, whatever its direction; the overlapped attempt prints beside it in the same table with its window and `load1_mean`, labelled "overlapped a lane's dry run". The 4K band rule (section 4's G0 addendum, A1-4) applies to the clean attempt as registered. This is registered before any re-read exists. - **A5-4 · Unchanged.** L-Q2's fa-on quality is not re-opened, and S-IQ3-noMTP stands as an engine refusal (D-20261003-059). The AUD arms keep their registered line. No reading here feeds "Better" except through G0, G1 and G2 as registered. - **A5-5 · How the harness holds A5** (the strata-a5 lane; `A5-BUILD.md` beside this file). The clean attempt is the first RESULT speed attempt whose driver started at or after this section's stamp; a RESULT attempt that started before it is an overlapped one. Launch-once opens exactly one more speed attempt for each of the four arms, numbered one past its last overlapped attempt (a2), and only while this section exists: any other attempt number is refused, a marker in that attempt refuses it again, and a REFUSED in any attempt still refuses every launch (section 2's launch-once is otherwise unchanged). The driver refuses that attempt before any launch (a preflight refusal, no attempt spent) unless the quiet check wrote a PASS for it within the last 15 minutes. The quiet check (`harness/quiet.py`, one line per check in `records//speed/QUIET-CHECK.jsonl`) also counts as busy any unit shaped like a harness card step under any prefix (`-eng-`, `-watch-` or `-driver-` before an arm name) and any process running a harness dry run or stub server: stricter than A5-3, never looser. Until a clean attempt exists, the summary reads the overlapped attempt as the figure, labelled "clean re-read pending". ## 11 · Amendment A6 (registered 2026-10-03T04:51:06Z; appended by the lead, Opus 5.5, session fe125d2f, under ledger D-20261003-066) **A6 · the aud phase as built and folded** (registered 2026-10-03T04:51:06Z): V-1, the client writes findings and side files to `/aud-private/` from the first byte and the driver moves the pen's twin there at every run's end and any leftover at the next start, so AUD-4's sentence that a harness death leaves a partial window is withdrawn; V-3, the side-file window scan counts the model- and engine-written strings only (content, reasoning_content, tool_calls, engine messages; each finding's file, claim and evidence), in raw and JSON-escaped forms, 0 required, the literal scope recorded beside it; the scan sees only text that reached a side file, plus the first line of each llama.cpp unparsed-output tail; V-4, a Strata `503 server_error` is an engine death and REFUSES the run at that call; V-5, AUD-S and AUD-S-PIN boot in the aud sandbox (`--phase load`) and AUD-C's `aud-smoke` is that boot plus one 64-token call, the newest such attempt must be a RESULT on the same line, and an engine path under /home the mask would hide (shard 1 included) refuses the start; V-6, a call whose content_tokens + think_tokens differ from predicted_n or completion_tokens by more than 3 % reads COUNT-MISMATCH and its decode is withheld from C-e and AUD-B5. T-2: section 6's sentence "`parse_special` is off by default" is false at 3cf03257 (`common/arg.cpp:1401-1402`), so T-2's argv is `llama-tokenize -m --stdin --ids --no-escape --no-bos --no-parse-special --log-disable`, which keeps the registered semantics (add_special false, parse_special false) unchanged; the tool is the CPU build at `/data/strata-bench/build/llama.cpp-3cf03257-cpu/bin/llama-tokenize`; every arm's aud phase refuses to start without it, and refuses the attempt, never the arm, when it does not count inside the sandbox. Rule F reads G0 from S-IQ3, L-IQ3, S-Q2 and L-Q2, and G1 per A4-4: the IQ3 pair is S-IQ3 against L-IQ3-fa0 and the Q2 pair S-Q2 against L-Q2-fa0; F3 and F4 print "G1 MISSED on this file (n of 108, m of 48; vs L-IQ3-fa0, fa-off)" (or L-Q2-fa0); an fa-off side without a RESULT quality attempt reads unread, never a pass. The engine's raw log stays in the attempt's `aud-private/` (0600); the open `server.log` is a copy that stops before llama.cpp's first unparsed-output WARN (`common/chat.cpp:1494`). AUD-L's rebuilt line must equal the newest RESULT speed record of L-IQ3-t8 (IQ3_S) or L-Q2 (Q2_0), the port masked and the kit's three flags removed, with the same engine commit, or its start is refused. **I-4 (a), ruled by the lead (ledger D-20261003-066):** AUD-L runs its registered fa-on line at 3cf03257 (an fa-off AUD-L cannot fit its 25-50k-token prompts beside the frozen N: A5-2 measured the fa-off compute buffer at 8,304.57 MiB at 128K); an AUD-L attempt REFUSED by an engine death that carries 3cf03257's illegal-memory-access signature (`XID31-FINDING.md`) is read in the auditor comparison as an engine result, "engine-failed (CUDA illegal memory access)", and is never re-opened (launch-once). The label: this text was drafted as "A5" in FOLD-AUD-BUILD.md section 5; A5 was registered first (section 10), so it is appended as A6, its words otherwise unchanged. ## 12 · Amendment A7 (registered 2026-10-04T23:56:47Z, when only these records existed [records read: AUD-L aud: a1 STOPPED, a2 STOPPED; AUD-S aud: a1 RESULT; AUD-S load: a1 RESULT; L-IQ3 fit: a1 STOPPED, a2 REFUSED, a3 STOPPED, a4 STOPPED, a5 REFUSED, a6 RESULT, a7 RESULT, a8 REFUSED, a9 REFUSED; L-IQ3 quality: a1 STOPPED, a2 STOPPED; L-IQ3 speed: a1 RESULT; L-IQ3-fa0 load: a1 STOPPED, a2 RESULT; L-IQ3-fa0 quality: a1 RESULT; L-IQ3-t8 speed: a1 RESULT; L-Q2 fit: a1 RESULT, a2 RESULT, a3 RESULT, a4 RESULT, a5 RESULT; L-Q2 quality: a1 STOPPED; L-Q2 speed: a1 RESULT, a2 RESULT; L-Q2-fa0 load: a1 STOPPED, a2 RESULT; L-Q2-fa0 quality: a1 RESULT; S-HEAD load: a1 RESULT; S-HEAD quality: a1 RESULT; S-HEAD speed: a1 RESULT, a2 STOPPED; S-IQ3 load: a1 RESULT; S-IQ3 quality: a1 RESULT; S-IQ3 speed: a1 RESULT, a2 STOPPED; S-IQ3-noMTP load: a1 STOPPED; S-Q2 load: a1 RESULT; S-Q2 quality: a1 RESULT; S-Q2 speed: a1 RESULT, a2 RESULT; and FROZEN-NCMOE-L-IQ3.json, FROZEN-NCMOE-L-Q2.json, SLICES.json]; no L-IQ3-ub or L-IQ3-t16 record and no FROZEN-NCMOE-L-IQ3-ub.json existed) Written by the strata-a7 lane under an operator's words, verbatim, 2026-10-04 ~23:5xZ: "also, we need to keep rolling on strata bench + local agent tests (auditing, etc)" (the rest of that message quotes another person's post about their own box, not this bench), and page A's Q-5 taken at its default (D-20261003-064; PLAN-v2 section 16, Q-5's default: "yes (flipped from v1's no), and 5b yes if the minutes allow"); ledger D-20261004-095. No gate, band, threshold or stop condition in sections 1-11 moves, and every registered arm keeps its line and its records. - **A7-1 · The question, and the logs it rests on.** llama.cpp read every prompt of this bench 512 tokens at a time: L-IQ3-t8 speed a1's server.log reads `n_batch = 2048` and `n_ubatch = 512` (lines 195-196), 3cf03257's defaults (`common/common.h:451-452`), and `CUDA0 compute buffer size = 1200.57 MiB` (line 223). Its first-token waits at 128K read 569.7, 539.0 and 545.1 s (`ttft_ms` of L-IQ3-t8/speed/a1/run-007 to run-009), and the engine's own prompt rate read 211.7-258.6 tok/s at every context from 4K to 128K (`prompt_tok_s_server`, run-002 to run-009; run-001, the first request after load, 109.9). A rate that stays flat from 4K to 128K fits a fixed cost per micro-batch [inferred]. A7 asks one question: **whether llama.cpp's first-token wait at 128K on this card is set by its default 512-token micro-batch**, read as one control arm's figures beside L-IQ3-t8's. - **A7-2 · The arm L-IQ3-ub,** registered by this amendment: llama.cpp at 3cf03257 on ISTA IQ3_S, L-IQ3-t8's line exactly (`-ngl 99`, `-c 131072`, `-fa on`, `-ctk q8_0 -ctv q8_0`, `-lm mmap --lazy-mode on`, `-fit off`, `-np 1`, `--cache-ram 0`, `--no-webui`, `--jinja`, `-lv 4`, `-t 8 -tb 8`) plus `-b 4096 -ub 4096`, on its own frozen `--n-cpu-moe` (A7-3). `-b` moves with `-ub` because 3cf03257 clamps the micro-batch to the logical batch (`src/llama-context.cpp:247`) and the logical batch defaults to 2,048 (`common/common.h:451`): `-ub 4096` alone would run at 2,048. Every table prints L-IQ3-ub beside L-IQ3-t8 with the condition "llama.cpp at a 4,096-token micro-batch", read from each attempt's own argv, with the start's own `n_batch` and `n_ubatch` lines from its server.log and each arm's `--n-cpu-moe` beside it. - **A7-3 · Its fit.** The compute buffer grows with the micro-batch, so L-IQ3's frozen N (34) is not reused: L-IQ3-ub has its own fit phase under the rule L-IQ3's fit ran (HARNESS-NOTES decision 6; AUDIT-HARNESS I-6). `driver.py fit` loads each candidate N on L-IQ3-ub's whole line (`-b 4096 -ub 4096` included) and holds it 10 s with no request; `driver.py freeze-ncmoe` then freezes, once, the smallest N whose RESULT fit row leaves at least 1,536 MiB of the card's VRAM free, from that one fit row id, into `FROZEN-NCMOE-L-IQ3-ub.json`. A candidate that does not reach /health (a CUDA out-of-memory) is that fit attempt's own record; as in L-IQ3's fit, each fit attempt stands alone. If no candidate up to 48 leaves the margin, L-IQ3-ub has no speed phase: the step to `-b 2048 -ub 2048` that PLAN-v2 section 15.3 names is NOT registered here and needs a new amendment before its first attempt. Arithmetic, not measurement: L-IQ3's fit rows read 20,347 MiB used at N = 36 and 22,449 MiB at N = 34, of 24,463 MiB (L-IQ3/fit/a6 and a7, both RESULT), about 1,051 MiB per layer of experts; a compute buffer that grew in proportion to the micro-batch would add about 8,400 MiB (8 x 1,200.57 - 1,200.57) and put the smallest passing N near 42, and a smaller growth puts it lower. - **A7-4 · Its speed phase, a control.** 4K, 32K and 128K, 3 repeats, the same `SLICES.json` and nonces, the same instrument, clock of record (A1-2) and token-count check (A3-5), one server start, on `FROZEN-NCMOE-L-IQ3-ub.json`'s N. **No band and no gate:** no band is drawn (a band drawn now would be drawn after L-IQ3-t8's rows were read); its 4K reading prints as "no band: a control (PREREG A7)", never inside or outside a band; and nothing it reads feeds the verdict of G0, G1, G2 or "Better" for any arm (its own start still passes the harness's G0 read, and a refused start is recorded REFUSED, as for every arm). It has no quality phase and no load phase. Launch-once is section 2's. - **A7-5 · What it answers, and what not.** Read beside L-IQ3-t8 at each context: the first-token wait, the engine's prompt rate and the decode rate. Two things differ between the two arms, and both print beside every figure: the micro-batch, and N (a higher N keeps more experts on the CPU, which can slow decode [inferred]). L-IQ3-ub says nothing about other micro-batch sizes, thread counts, llama.cpp commits or flash attention off, and nothing about Strata. - **A7-6 · Q-5b, optional: the arm L-IQ3-t16.** L-IQ3-t8's line with `-t 16 -tb 16` in place of `-t 8 -tb 8` and nothing else (the micro-batch stays at llama.cpp's default 512), on L-IQ3's frozen N (34: threads do not move VRAM, so like L-IQ3-t8 it reads `FROZEN-NCMOE-L-IQ3.json`), speed only, 4K only, 3 repeats; no band, no gate, no fit, no quality, no load. It reads whether more threads than A3's 8 move llama.cpp's 4K figures on this box (24 cores, one thread each: lscpu, and the start logs' `/ 24`). It runs only after L-IQ3-ub's speed phase and only if the morning's card minutes allow; not running it is no deviation, and the page then keeps "llama.cpp at more than 8 threads was not measured". Every table prints it beside L-IQ3-t8 with the condition "llama.cpp at 16 threads", read from its argv. - **A7-7 · Stop rules and memory.** Section 3's stop conditions as the harness holds them (A3-5's memory lines, the SSD at 80 C, the GPU guard), and the memory plan as installed (`common.memory_plan`: llama.cpp's working set is N/48 of the IQ3_S arena plus 3.0 GiB; MemoryMax = min(working set + 14 GiB, MemTotal - 6 GiB); refused below MemAvailable = working set + 4 GiB). The plan does not count the micro-batch: the host compute buffer (208.82 MiB on L-IQ3-t8's start, server.log line 224) may grow with it, inside the plan's 3.0 GiB [inferred]. No floor or MemoryMax override is registered; a refusal at the floor is a PREFLIGHT refusal for the lead to read. - **A7-8 · Order.** In the morning, on an operator's turbo-fan word (an operator: "we'll do the remaining bench work … tomorrow morning, when it's cool"): L-IQ3-ub's fit, its freeze, its speed phase; then, if the minutes allow, L-IQ3-t16. Each step is one `driver.py` run in its own `sb-driver-*` unit under `~/CARD-LOCK`, never beside another card step. - **A7-9 · How the harness holds A7** (the strata-a7 lane; `A7-BUILD.md` beside this file). `engines.LLAMA_LINE` gains `batch`, `ubatch` (None: the flag is not passed and the engine's default stands) and `threads` (8, A3's) as keys an arm row's `llama_flags` may name; `-b N -ub M` go straight after `-c`, and `threads` sets `-t` and `-tb` together. An arm row that names none of the three keeps its argv byte for byte and its recorded three-key line. The line is refused before any launch, as before, for an unknown key or `-fa off` with a quantized V cache, and now also for a batch, micro-batch or thread count that is not a positive int, a micro-batch above the logical batch in force (the clamp above), or a logical batch above the context (`src/llama-context.cpp:245` clamps it). The rows: L-IQ3-ub (`llama_flags` batch 4096 and ubatch 4096, phases fit and speed, no band, its own N) and L-IQ3-t16 (`llama_flags` threads 16, 4K, phase speed, no band, L-IQ3's N), each ordered straight after L-IQ3-t8. The summary prints both beside L-IQ3-t8 with their condition read from each attempt's argv, each start's own `n_batch` and `n_ubatch` lines, each arm's N, and their 4K line as "no band: a control (PREREG A7)"; a section of its own sets L-IQ3-t8, L-IQ3-ub and L-IQ3-t16 side by side per context, with L-IQ3-ub's fit rows and frozen N. ## 13 · Amendment A8 (registered 2026-10-05T15:33:25Z, when only these records existed [records read: AUD-L aud: a1 STOPPED, a2 STOPPED; AUD-S aud: a1 RESULT; AUD-S load: a1 RESULT; L-IQ3 fit: a1 STOPPED, a2 REFUSED, a3 STOPPED, a4 STOPPED, a5 REFUSED, a6 RESULT, a7 RESULT, a8 REFUSED, a9 REFUSED; L-IQ3 quality: a1 STOPPED, a2 STOPPED; L-IQ3 speed: a1 RESULT; L-IQ3-fa0 load: a1 STOPPED, a2 RESULT; L-IQ3-fa0 quality: a1 RESULT; L-IQ3-t8 speed: a1 RESULT; L-IQ3-ub fit: a1 RESULT, a2 RESULT, a3 STOPPED, a4 STOPPED; L-IQ3-ub speed: a1 RESULT; L-Q2 fit: a1 RESULT, a2 RESULT, a3 RESULT, a4 RESULT, a5 RESULT; L-Q2 quality: a1 STOPPED; L-Q2 speed: a1 RESULT, a2 RESULT; L-Q2-fa0 load: a1 STOPPED, a2 RESULT; L-Q2-fa0 quality: a1 RESULT; S-HEAD load: a1 RESULT; S-HEAD quality: a1 RESULT; S-HEAD speed: a1 RESULT, a2 STOPPED; S-IQ3 load: a1 RESULT; S-IQ3 quality: a1 RESULT; S-IQ3 speed: a1 RESULT, a2 STOPPED; S-IQ3-noMTP load: a1 STOPPED; S-Q2 load: a1 RESULT; S-Q2 quality: a1 RESULT; S-Q2 speed: a1 RESULT, a2 RESULT; and FROZEN-NCMOE-L-IQ3-ub.json, FROZEN-NCMOE-L-IQ3.json, FROZEN-NCMOE-L-Q2.json, SLICES.json]; no S-NEW record existed) Drafted by the strata-snew-harness lane and appended by the lead, under an operator's words, verbatim: "this all sounds great! and the 5 hour credit window just reset, so please keep the train rolling overnight w/ your recs" and the standing "let's keep rolling with your recs" (ledger D-20261005-102). The staging and its conditions are `STRATA-DELTA-2.md` (C-1 to C-17) and `STAGE-NEW.md` beside this file. No gate, band, threshold or stop condition in sections 1-12 moves, and every registered arm keeps its line and its records. - **A8-1 · The question.** Strata v0.1.39 (`6f32ec070f23ced9f50e704d854d775da52591ab`, tagged 2026-10-04) is 285 commits past 36fa455e, S-HEAD's commit (STRATA-DELTA-2 section 2). It changed the decode verify pass (#646), the long-prompt expert ring (#583), the adaptive tier (#463), the PCIe probe (#485), the hit-rate readout (#588) and the Linux expert arena's pages (#650) (STRATA-DELTA-2 sections 3 and 9). The author claims decode +2.5 % to +7 % against 0.1.38 on a 12 GB card with byte-identical output; a user reported 170-190 → 200-230+ tok/s on a two-card box; both are claims about other boxes. A8 asks one question: **what S-HEAD's line reads at v0.1.39 on this laptop's one 24 GB card**, read beside S-HEAD's own figures and labelled exploratory. - **A8-2 · The arm S-NEW, not registered.** Strata at `6f32ec070f23ced9f50e704d854d775da52591ab` (= `v0.1.39^{commit}`) on ISTA IQ3_S (the same two shards and sha256 as S-HEAD), built from source with build-strata.sh's flags (`-DSTRATA_GGML_DIR` at 3cf03257) inside a no-network sandbox, binary `/data/strata-bench/build/strata-6f32ec07/strata`, 46,654,440 B, sha256 `2f315b46fc3b46d0532abc258b5fac66e1fc9efa1a980cf9a83afb00db9ec6c8`; its pack `/data/strata-bench/packs-6f32ec07/iq3_s` and MTP runtime `/data/strata-bench/mtp/rt-6f32ec07`, re-derived at 6f32ec07, are byte-identical to S-HEAD's (STAGE-NEW sections 2-3). **The engine line is S-HEAD's exactly**: the arguments setup writes for this box, `--pack --native --ple-gguf --expert-profile /data/expert-profile.bin --expert-cache auto --prefill auto --spec 4 --spec-min-p 0.5 --mtp --max-context 131072 --kv int8` (S-HEAD/speed/a1/RESULT.json, facts.strata_config.args), served by `serve/server.py` as setup's start script would, **with no `--pool-workers`**: v0.1.39's setup would write `--pool-workers 12` here from a miscounted P-core total (2 P + 22 E read from cpu_capacity, where the CPU has 8 P + 16 E; `strata-delta-2-receipts/box-cpu-thp.txt`), which is recorded and not used (C-11). **One difference, forced by v0.1.39 on this box:** the engine's environment carries `STRATA_NO_LARGEPAGES=1`, through the config's `"env"`, which v0.1.39's server copies into the engine's environment (`serve/server.py:1569-1570`), so the expert arena keeps the 4 KB pages S-HEAD ran on (S-HEAD/speed/a1/strata-engine.log line 11: "MAP_HUGETLB unavailable (no hugetlb pool configured?); using 4 KB pages"). Without it v0.1.39 asks for transparent huge pages (#650, `src/core/pinned.cu:227-247`), and this laptop reads THP `enabled [madvise]`, `defrag [madvise]` (box-cpu-thp.txt, read 2026-10-05T00:05:14Z), open issue #771's slow-arena case. A THP reading is NOT registered here. The keys and flags v0.1.39 added stay out (C-10: `parallel`, `vram_elastic`, `effort_position`, `allowed_hosts`, `remote_expert_opt`, `repeat_stop_tokens`; `--batch`, `--slots`, `--vram-elastic`, `--remote-expert-opt`, `--peer-*`, `--tail-role-token`, `--trim-stage-weights`), and the harness never sends POST `/config` or POST `/v1/vram`. Two v0.1.39 server defaults stand as shipped and cannot move a reading here: `REPEAT_STOP_TOKENS = 256` (`serve/server.py:76`, #606) cannot end a reply before the speed phase's 256-token cap or the quality phase's 8, and `ENGINE_SILENCE_S = 300.0` (`:88`, #481) sits above S-HEAD's longest first-token wait, 46.1 s at 128K (the median of S-HEAD/speed/a1/run-007 to run-009). - **A8-3 · Its phases.** S-HEAD's: a load phase (probe, G0, the thread line, a 10 s hold, no request; A3-5), then the speed phase (4K, 32K and 128K, 3 repeats, the same `SLICES.json` and nonces, the same instrument, clock of record (A1-2) and token-count check (A3-5), one server start, A2), then the quality phase (the same 108 six-way and 48 doorman items, instrument, scorer and counting). G0 is section 2's read, as for every Strata arm, and a G0-refused start is recorded REFUSED. Launch-once is section 2's. - **A8-4 · No band and no gate.** No band is drawn: S-HEAD's figures have been read (80.4, 79.6 and 74.0 tok/s at 4K, 32K and 128K, S-HEAD speed a1), and a band drawn now would be drawn after them. No registered band is inherited: S-IQ3's (40-90 tok/s at 4K, section 2) stays S-IQ3's, as S-HEAD inherited none (section 1). S-NEW's 4K line reads "no registered band (unregistered arm)". Nothing it reads feeds the verdict of G0, G1, G2 or "Better" for any arm: its quality row prints its strict counts and its agreement with L-IQ3-fa0 under A1-1's counting, each labelled "not a gate", with no G1, G2 or "Better" verdict. It feeds no AUD arm: AUD-S's rules C1 to C3 name 36fa455e (section 6), so an AUD reading at v0.1.39 needs its own amendment. **Every S-NEW figure, in every table, carries the caption "exploratory (v0.1.39)".** - **A8-5 · Beside S-HEAD.** S-NEW's rows print straight after S-HEAD's. Its 32K and 128K rows print "prompt path differs from S-HEAD (#583 ring, v0.1.39)": v0.1.39 reads long prompts through a byte-sized expert ring by default (`src/prefill/prefill.cpp:164-169`), and its 32K and 128K prompts change bits (STRATA-DELTA-2 section 3; C-13). `STRATA_RING_BYTES=0`, which restores the old ring, is NOT set: the arm reads v0.1.39 as shipped. The hit rate keeps its meaning across the two commits (#588 renamed the Monitor's column and printed the PCIe share beside it; it is still the VRAM share of the experts the CPU pool looked up, STRATA-DELTA-2 section 6.1), so the two arms' hit rates compare, and S-NEW's row adds the PCIe share when it is above 0. A request that prints no hit-rate line (#646's zero-doorbell graph, which needs every expert of a stage in VRAM, where one 24 GB card cannot hold IQ3_S's 46.84 GiB arena, S-HEAD/speed/a1/strata-engine.log line 12) prints "absent" and is named, never left blank. - **A8-6 · Stop rules, memory and the box.** Section 3's stop conditions as the harness holds them (A3-5's memory lines, the SSD at 80 C, the GPU guard), and S-HEAD's memory plan (`common.memory_plan`, Strata IQ3_S: 49.84 GiB resident, MemoryMax 54 GiB, refused below MemAvailable 51.3 GiB; S-HEAD/load/a1/RESULT.json reads the same 54 and 51.3, with 53.69 GiB available after its park). No floor or MemoryMax override is registered; a refusal at the floor is a PREFLIGHT refusal for the lead to read. Each step is one `driver.py` run in its own `sb-driver-*` unit under `~/CARD-LOCK`, never beside another card step, started only when no lane workflow runs on the laptop (S-HEAD's clean re-read a2 STOPPED on memory pressure from other lanes' work, 2026-10-03T05:59:25Z to 06:00:38Z, S-HEAD/speed/a2/STOPPED.json), and on an operator's turbo-fan word. - **A8-7 · The first load is read before any speed run.** S-NEW's speed and quality runs are refused before any launch (a PREFLIGHT refusal, no attempt spent) unless S-NEW's newest RESULT load record ran the same engine line, its env included, and that start's own expert-arena line reads "large pages skipped (STRATA_NO_LARGEPAGES); using 4 KB pages" (`src/core/pinned.cu:204-205`). The lead also reads that load's engine log for a fault on sm_120 IQ3_S before the speed run (v0.1.39's `055122c1` fixed one such fault on this card and file before the release; STRATA-DELTA-2 section 9 item 3); a fault at load is the load attempt's own record (STOPPED or REFUSED), never a speed reading. - **A8-8 · What it answers, and what not.** It answers what S-HEAD's line reads on this laptop at v0.1.39 with 4 KB arena pages, phase for phase beside S-HEAD (36fa455e): decode, first-token wait and prompt rate per context, the hit rate with its PCIe share, tokens per round, and the quality counts with their agreement against L-IQ3-fa0. It says nothing about which of the 285 commits moves a figure (it reads the release, not one change); nothing about transparent huge pages, `--pool-workers 12`, batch slots, a second card, `--remote-expert-opt` or the zero-doorbell path; nothing about another file (Q2_0, UD-IQ4_XS) or about the two-card report; and it moves no registered arm's verdict. A pin past v0.1.39 needs a new delta read and a new amendment (C-14). - **A8-9 · How the harness holds A8** (the strata-snew-harness lane; `SNEW-HARNESS-BUILD.md` beside this file). The arm row S-NEW in `common.ARMS`, ordered straight after S-HEAD: engine strata, IQ3_S, MTP, 4K/32K/128K, a quality phase, pair L-IQ3, no band, not registered, `"gates": False`, caption "exploratory (v0.1.39)", `"requires_amendment": "A8"`, `"strata_commit"` 6f32ec07…, `"strata_exe_sha256"` 2f315b46…, `"engine_env"` {STRATA_NO_LARGEPAGES: "1"} and the 32K/128K notes. The driver refuses S-NEW before any launch without `--allow-unregistered`, while PREREG carries no Amendment A8 heading, when `--strata-commit` or the binary's sha256 is not the pinned one, and when an `engine_env` names anything outside its allowlist (STRATA_NO_LARGEPAGES=1 alone). `strata_config` writes the env as the config's `"env"`, and every row of the arm carries it; G0's facts keep the expert-arena line and the page backing it names; a speed or quality run needs A8-7's load record. The summary captions every S-NEW name, prints the env beside it, flags `ENGINE ≠ ENV` when a start's arena line does not show the env, prints the 32K/128K note, prints the PCIe share beside the hit rate and the quality row without a gate. The same harness change reads v0.1.39's probe line (its burst list), its #588 suffix and a missing hit-rate line (named "absent") for every Strata arm, and prints every three-digit median with its own third digit (STRATA-DELTA-2 H-1 to H-5). ## 14 · Amendment A9 (registered 2026-10-06T00:36:37Z, when only these records existed [records read: AUD-L aud: a1 STOPPED, a2 STOPPED, a3 STOPPED; AUD-S aud: a1 RESULT; AUD-S load: a1 RESULT; L-IQ3 fit: a1 STOPPED, a2 REFUSED, a3 STOPPED, a4 STOPPED, a5 REFUSED, a6 RESULT, a7 RESULT, a8 REFUSED, a9 REFUSED; L-IQ3 quality: a1 STOPPED, a2 STOPPED; L-IQ3 speed: a1 RESULT; L-IQ3-fa0 load: a1 STOPPED, a2 RESULT; L-IQ3-fa0 quality: a1 RESULT; L-IQ3-t8 speed: a1 RESULT; L-IQ3-ub fit: a1 RESULT, a2 RESULT, a3 STOPPED, a4 STOPPED; L-IQ3-ub speed: a1 RESULT; L-Q2 fit: a1 RESULT, a2 RESULT, a3 RESULT, a4 RESULT, a5 RESULT; L-Q2 quality: a1 STOPPED; L-Q2 speed: a1 RESULT, a2 RESULT; L-Q2-fa0 load: a1 STOPPED, a2 RESULT; L-Q2-fa0 quality: a1 RESULT; S-HEAD load: a1 RESULT; S-HEAD quality: a1 RESULT; S-HEAD speed: a1 RESULT, a2 STOPPED; S-IQ3 load: a1 RESULT; S-IQ3 quality: a1 RESULT; S-IQ3 speed: a1 RESULT, a2 STOPPED; S-IQ3-noMTP load: a1 STOPPED; S-NEW load: a1 RESULT; S-NEW speed: a1 STOPPED, a2 STOPPED; S-Q2 load: a1 RESULT; S-Q2 quality: a1 RESULT; S-Q2 speed: a1 RESULT, a2 RESULT; and FROZEN-NCMOE-L-IQ3-ub.json, FROZEN-NCMOE-L-IQ3.json, FROZEN-NCMOE-L-Q2.json, SLICES.json]; no S-NEW speed attempt past a2, no S-NEW quality attempt and no AUD-L aud attempt past a3 existed) Drafted by the strata-a9-build lane and appended by the lead, under an operator's words, verbatim: "let's roll with your recs, thanks!" (ledger D-20261005-143), answering the lead's two-part recommendation recorded with the stops below (ledger D-20261005-141 and D-20261005-142). The harness change is `A9-BUILD.md` beside this file. No gate, band or threshold in sections 1-13 moves. The one stop condition A9 changes is AUD-L's PSI line (A9-4); every arm keeps its line and its records. - **A9-1 · Why: the five stops, read from their markers.** - **S-NEW (A8).** Speed a1, driver 2026-10-05T15:35:19Z to 15:36:18Z, with 52.37 GiB available after its park against the 51.3 GiB floor and three lane workflows running on the laptop (D-20261005-130), read "STOPPED: memory pressure: MemAvailable 1.90 GiB < 2 [PSI full avg10: engine unit's own 0.13 %, system-wide 1.25 %, user@1000.service 0.77 %]" inside its first 32K request (run 4, from 15:36:04Z), after 3 rows at 4K. Speed a2, 21:19:19Z to 21:21:10Z, on an idle laptop (51.92 GiB after its park), read "STOPPED: memory pressure: MemAvailable 1.91 GiB < 2 [PSI full avg10: engine unit's own 0 %, system-wide 0.15 %, user@1000.service 0.15 %]" inside its first 128K request (run 7, from 21:20:47Z), after 6 rows at 4K and 32K. In a2's six finished requests MemAvailable fell no lower than 2.183 GiB (S-NEW/speed/a2/run-002, at 4K) and 2.272 GiB at 32K (run-006): each row's `telemetry.memory.mem_available_gib_min`. - **AUD-L (section 6, A6).** Aud a1, 2026-10-03T07:45:36Z to 07:46:52Z, read "STOPPED: memory pressure: PSI memory full avg10 10.73 % >= 10 % (steady; the box's = the larger of system-wide and user@) [PSI full avg10: engine unit's own 30.4 %, system-wide 10.04 %, user@1000.service 10.73 %]". Aud a2, 07:52:07Z to 09:05:57Z, read "STOPPED: memory pressure: PSI memory full avg10 10.12 % >= 10 % (steady; the box's = the larger of system-wide and user@) [PSI full avg10: engine unit's own 0 %, system-wide 10.09 %, user@1000.service 10.12 %]". Aud a3, 2026-10-05T21:23:06Z to 21:24:20Z, ready 21:23:48Z, read "STOPPED: memory pressure: PSI memory full avg10 12.76 % >= 10 % (steady; the box's = the larger of system-wide and user@) [PSI full avg10: engine unit's own 4.07 %, system-wide 12.43 %, user@1000.service 12.76 %]". From each attempt's own `telemetry.csv`: a2's engine unit's own PSI full avg10 peaked at 9.6 % from 120 s after ready to its stop (4,261 readings); a3's peaked at 13.51 % in its first 32 s after ready. - **A9-2 · S-NEW at 4K and 32K only.** S-NEW's speed phase sends its 4K and 32K slices only, 3 repeats each, with the same `SLICES.json`, nonces, instrument, clock of record (A1-2) and token-count check (A3-5) as A8-3. Its quality phase sends what A8-3 registered: the instrument's 108 six-way and 48 doorman items, whose prompts are far below 4K (A5-2), so A9 moves nothing in it. Both run on S-NEW's line as A8-2 registered it, unchanged: `--max-context 131072` stays (S-HEAD's), so S-NEW's load a1 (RESULT, 2026-10-05T15:33:41Z to 15:34:23Z) still stands for both under A8-7. Any S-NEW speed run whose contexts include 128K is refused before launch with the sentence "S-NEW's 128K context is refused: not run on this laptop (PREREG A9): S-NEW speed attempts a1 and a2 both STOPPED on the 2 GiB MemAvailable guard, a2 on an idle laptop as its 128K slice began; the 128K reading moved to the desktop's window 2". The 128K reading moved to the desktop's window 2 (Strata on the desktop's larger card, where memory is not tight). A9 registers no the desktop reading: whatever runs there is planned and registered with its own box, card and memory plan, and nothing it reads joins S-NEW's rows here. S-NEW's floor (51.3 GiB), MemoryMax (54 GiB) and the 2 GiB MemAvailable line do not move (A8-6, A3-5). - **A9-3 · S-NEW reopens once.** Every S-NEW launch (load, speed and quality) now waits for A9 as well as A8. S-NEW's speed phase reopens as attempt a3, exactly once (A9-5's rule). Its quality phase opens as a1 under section 2's launch-once (it never ran). Order: speed a3, then quality a1, each one card step under A8-6's rules: its own `sb-driver-*` unit under `~/CARD-LOCK`, no lane workflow on the laptop, and an operator's turbo-fan word. - **A9-4 · AUD-L's memory guard, for its aud phase only.** The steady line reads the engine unit's own PSI full avg10 (its own cgroup's `memory.pressure`) against the same 10 % line, from 120 s after the server reports ready. Before A9 it read the larger of the system-wide PSI and user@1000.service's, from 30 s after ready (A3-5). Before the steady line begins, the box's 40 % load line applies as before. After it, the box's 40 % line stays in force as a backstop below systemd-oomd's 50 %: A3-5's 10 % box line covered that band before, and without the backstop a box-wide pressure between 10 % and oomd's line would go unguarded. Unchanged: MemAvailable < 2 GiB, swap >= 80 %, a rising oom_kill, the pre-start settle (the box's PSI under 5 % within 180 s), AUD-L's floor (40.2 GiB) and MemoryMax (50 GiB). A sampler row whose engine-unit PSI cannot be read does not fire the steady line, as an unread box reading never fired A3-5's line; the box's 40 % backstop and the MemAvailable and swap lines still apply (the oom_kill line reads the unit's own memory.events, so it cannot read either while the unit's cgroup is unknown or gone), and the attempt's facts count those rows (`memory_guard`, `unit_unread` per window). Every other arm and phase (every arm of sections 1-13, AUD-S, AUD-C and AUD-L's load phase) keeps A3-5's rule, its stop sentence byte for byte. Every attempt's facts carry `memory_guard`: the rule, what each of its lines read in the load and steady windows, and which line fired. - **A9-5 · Each reopened phase opens once.** S-NEW's speed phase reopens as attempt a3 and AUD-L's aud phase as attempt a4, each only while PREREG carries this amendment, and only while the attempts it reopens from (S-NEW speed a1 and a2; AUD-L aud a1, a2 and a3) read STOPPED and ended before A9's stamp, as recorded. Any other attempt number is refused before launch. A RESULT or REFUSED in any attempt refuses every launch (section 2). Any marker in the reopened attempt (RESULT, REFUSED, STOPPED or PREFLIGHT-REFUSED), or files without one, refuses it again: nothing reopens twice, and another attempt needs a new amendment. A refusal before launch (a floor, a settle, a gate) spends nothing. AUD-L a4 runs after the page-cache warm (`aud-l-a2.sh`'s lines), on a3's line, kit stage, rule F file and tools, on an idle laptop with no lane workflow running, and on an operator's turbo-fan word. - **A9-6 · What stands.** S-NEW speed a1 and a2 and AUD-L aud a1, a2 and a3 stand as recorded: STOPPED, with their sentences, rows and telemetry. A STOPPED attempt's finished rows (S-NEW a2's six) stay rows of a STOPPED attempt, labelled with its end reason and captioned "exploratory (v0.1.39)" as A8-4 asks; they are not S-NEW's figure of record, which is the first RESULT speed attempt, a3 if it reaches one. - **A9-7 · What A9 answers, and what not.** It answers what S-HEAD's line reads at v0.1.39 on this laptop at 4K and 32K, beside S-HEAD (A8-8, less 128K), and how AUD-L behaves under the la-r1 kit's E3 calls when its stop line answers to its own engine's pressure (section 6, AUD-7; DRY RUN, AUD-6). It does not claim: - that S-NEW a3 will finish: in a2's six finished requests MemAvailable fell to 2.183 GiB at 4K and 2.272 GiB at 32K, against the unchanged 2 GiB line, on an idle laptop; - that AUD-L a4 will finish: a2's engine unit's own PSI peaked at 9.6 % in its steady window, 0.4 under the line, and a1's own read 30.4 % at its stop, 37 s after ready (D-20261005-141 reads a1's stop as its own cold-cache pressure); these are read from the records, not predicted; - why S-NEW's 128K slice needs more host memory than its 32K slice: no line of either attempt's logs says so (a2's `strata-engine.log` line 27, "strata serve: the prompt path borrows 2183 CUDA0 cache slots (4.12 GiB)", is VRAM); - anything about S-NEW at 128K on this laptop or on the desktop, about another context, file, commit, box or Strata setting, or about AUD-L under a box-wide pressure between 10 % and 40 %, which is no longer its stop line: such a run reads to its end, its box PSI in its facts, and every reader prints it beside the run's figures. A9 moves no registered arm's verdict and no gate or band, and it feeds no AUD-S or AUD-C reading. - **A9-8 · How the harness holds A9** (the strata-a9-build lane; `A9-BUILD.md` beside this file). `common.ARMS["S-NEW"]` reads `"contexts": ["4K", "32K"]`, `"contexts_refused"` {"128K": the sentence in A9-2} (the driver's step `context`, `common.context_refusal`) and `"requires_amendment": ("A8", "A9")`. `common.REOPENS` names ("S-NEW", "speed") with attempt 3 after a1 and a2 and ("AUD-L", "aud") with attempt 4 after a1, a2 and a3, and `Records.launch_once` holds A9-5 through `reopen_launch` (a records folder with none of a phase's attempts, as a dry run's, keeps section 2's rule). `telemetry.GUARD_RULES["engine_unit"]` is A9-4's rule (the steady line on the unit at 10 % from 120 s, the box's 40 % before it and as the backstop), `common.MEMORY_GUARD` gives it to AUD-L's aud phase alone, and every other run keeps `"box"`, A3-5's. Every marker's facts carry `memory_guard`, and a reopened attempt's carry `reopen` (A9's stamp and the STOPPED attempts it reopened from). The summary prints S-NEW's 128K line as "not run (PREREG A9)" with the refusal's sentence, after S-NEW's own speed rows.