TECHNICAL companion for the 2s era (verified code-side + hub-side, 2026-09-04)

TECHNICAL_2s.md

@@ -0,0 +1,1064 @@
+<!-- VERIFIED 2026-09-04: code-side (wf_15fc8b16) and hub-side (wf ft2-finish) passes applied. -->
+
+# alephllm-mini-beatrix-training — Technical Companion (the 2s era: the full-splat craft and its softmax twin)
+
+Companion to *Twinning Beatrix: A Full-Splat Byte Model, Its Softmax
+Control, and What Reaches an Image Generator* (AbstractPhil with Claude
+Fable 5 and Claude Fable 5.1, September 2026). It covers two crafts and
+one packaged model: `mini-beatrix-2s/` and `mini-beatrix-2s-control/`
+under AbstractPhil/alephllm-mini-beatrix-training, and the AutoModel at
+AbstractPhil/mini-beatrix-2s; the dates run from the first launch
+(run0, 2026-08-26) through the control's endpoint (2026-09-03) and the
+claim audit that graded it (2026-09-04). It is written for a reader who
+will load the checkpoints and read the reports. It is not the
+mini-beatrix-1 life record (`TECHNICAL.md`, which stays as it is), not
+the article's argument, and not a manual for the side campaigns that
+share the repo root (`reports/v2/{battery,wide_moe,aflow,bcd}` appear
+only as a catalogue line). Every number carries its pointer: `file:line`
+means E:/mirel/AlephLLM/geolip/alephllm/ at HEAD 4f4b7d6 (package
+0.8.7, the last commit of the 2s era); hub paths are relative to the
+craft prefix; journal paths are relative to the claude-mind repo. Where
+the journal and the code disagree, the code wins and the disagreement
+is reported in place. Stack-side detail lives in the
+[AlephLLM companion](https://github.com/AbstractEyes/alephllm), which
+covers the 0.7.0 mechanisms only; the 0.8.x organs (specials, driver
+contract, revival, gauge fallback, twin isolation) are carried here.
+
+## The two crafts at a glance
+
+| | mini-beatrix-2s | mini-beatrix-2s-control | mini-beatrix-1 |
+|---|---|---|---|
+| d_model / layers / heads | 1024 / 20 / 16 | 1024 / 20 / 16 | 768 / 16 / 12 |
+| attention | CausalSplatHUB in all 20 blocks | CausalSDPA (16 × 64) in all 20 | 13 sdpa + 3 hubs (layers 4, 9, 14) |
+| hub books × anchors @ D | 4 × 64 @ 128 (supply 0.5×) | — | 1 × 512 @ 32 (supply 16×) |
+| banks | 3 experts @ ff 1024 | 3 @ 1024 | 3 @ 768 (full width) |
+| head (K @ D) | 256 @ 256, revived at 24,860, address frozen after | 256 @ 256, born null, never elected | 512 @ 32, never elected (W_s = 0.0 at ship) |
+| context / vocab | 4096 / 256 byte-trigram | 4096 / 256 | 2048 / 256 |
+| params | 237,125,949 | 257,442,109 (+20,316,160, all attention) | 112,524,593 |
+| tokens per step | 16 × 4 × 4096 = 262,144 | 262,144 | 48 × 3 × 2048 = 294,912 |
+| steps / tokens | 61,422 / 16,101,408,768 | 61,422 / 16,101,408,768 | 88,508 / 26,102,071,296 |
+| wall-hours / hosts | 78.33 on one RTX PRO 6000 | 49.98 on three hosts | 70.45 |
+| final val bpb (report ledger) | **1.1097** | **2.8846** | 1.121 |
+| optimizer | Muon 2e-2 + pure Adam 3e-4, flat after 200 | same | same |
+| governor | minsep 45°, every 8 steps, from birth | inherited (head book only) | off |
+| package at birth → end | 0.8.1 → 0.8.6 (revival under 0.8.2) | 0.8.7 throughout | cc89a87 → 0.6.0 (pre-specials) |
+
+Shape and knobs: `presets.py:191-203` (2s), `:214-235` (the `-control`
+derivation and the head_addr_frozen override), `:155-160` (mb1).
+Parameter counts were computed by constructing each preset on the meta
+device (`alephlm.py:218-224` `param_count`): 2s = embed 4,982,784 +
+20 blocks × 11,574,275 (hub attention 3,178,496 + bank 8,391,683 +
+norms 4,096) + final norm 2,048 + head 655,617; the control's block
+swaps the hub's 3,178,496 for sdpa's 4,194,304 (qkv 3072×1024 + o
+1024×1024, no biases; `attention.py:24-32`). Tokens per step is
+`micro_batch × grad_accum × context` (`trainer.py:186`); 61,422 ×
+262,144 lands on both manifests' `tokens_seen` exactly. The mother's
+numbers are the exemplar's (`TECHNICAL.md`, `mini-beatrix-1/manifest.json`).
+
+## Layout
+
+```
+mini-beatrix-2s/
+  manifest.json                  # 14 phases, 142 checkpoint entries, notes
+  checkpoints/step_XXXXXXXX.safetensors   # 46 bf16 (2000-cadence + every boundary and cap)
+  checkpoints/step_00024860_revived.safetensors   # fp32, the post-BOUNDARY-WRITE head
+  checkpoints/fp8/               # 20 e4m3 ship-only copies
+  resume/latest.pt               # fp32 model + Muon/Adam + stream + RNG + manifest
+  resume/boundary_<phase>_step<N>.pt      # 13 immutable boundary archives
+  resume/pre_revival_step24860.pt         # the state the revival overwrote
+  reports/v2/                    # 13 boundary + 3 session_cap + revival + 4 cultivation
+  runs/                          # 5 TensorBoard event files (one per session)
+  archive/run0-nospecials/       # the pre-specials first attempt, whole
+  beatrix_v2_colab.ipynb         # the driver
+
+mini-beatrix-2s-control/
+  manifest.json                  # identical phases and budgets; 136 entries
+  checkpoints/step_XXXXXXXX.safetensors   # 44 bf16 (incl. the 22,854 cap)
+  checkpoints/fp8/               # 20 e4m3 ship-only copies
+  resume/latest.pt  resume/boundary_*.pt  # latest + 13 boundary archives
+  reports/v2/                    # 13 boundary + 2 session_cap (22,854; 53,792)
+  runs/                          # 6 event files (two are 88-byte aborted starts)
+```
+
+The control has no notebook file and no AutoModel packaging; these
+checkpoints are its weights. Files: bf16 475,876,922 B (2s) and
+515,164,234 B (control); fp8 238,219,518 / 257,813,142 B; resume
+archives ~1.904 / ~2.064 GB each; the revived fp32 file 951,692,996 B
+(hub headers read by ranged GET; `checkpoint.py:102-128` for the two
+export rules).
+
+## Architecture in detail
+
+**The block.** Pre-norm, two residual branches: `x = x + attn(n1(x))`,
+`x = x + bank(n2(x))` (`alephlm.py:37-70`). `attn` is CausalSplatHUB
+when the layer index is in `hub_layers`, else CausalSDPA
+(`alephlm.py:41-50`); every block carries an AnchoredBank
+(`alephlm.py:51`). `hub_ckpt` (0 on 2s: the retained scan fits the
+96 GB card at 237M, `presets.py:184-198`) would wrap the branches in
+activation checkpointing (`alephlm.py:60-68`). The model is embedding →
+20 blocks → final LayerNorm → DualHead (`alephlm.py:81-96`); `forward`
+takes pre-shifted `targets` (ours) or HF-style `labels` (shifted
+internally) and ignores `attention_mask` deliberately
+(`alephlm.py:98-124`).
+
+**Trigram embedding and positions.** `e_t = emb0[x_t] + emb1[x_{t-1}] +
+emb2[x_{t-2}] + pos[t]`; the shift tables have a 257th PAD_ROW so the
+two positions shifted in at the sequence start never read a legal byte
+(`embedding.py:19-34`; the pad law — padding with a real byte starved
+address consumption, measured +.05..+.11 on repair). `pos` is a learned
+absolute table `(1, 4096, 1024)` (`embedding.py:28`); there is no RoPE.
+
+**CausalSplatHUB — the address.** Each book is an `AlephAddress`: K unit
+anchors in D dims (`address.py:24-36`, with a `home` buffer holding the
+birth copy for drift). The read is a cosine at temperature,
+`u_k = cos(x̂, â_k)/τ` with τ = 0.1 (`address.py:38-40`); the oriented
+form is the 2K-softmax over the axes `(+a_k, −a_k)`, and the signed read
+is its half-difference `w_k = sinh(u_k)/Σ_j cosh(u_j)` — inhibition
+(negative w) is first-class; there is no softmax over choices, no
+argmax, no top-k (`address.py:1-13,42-66`). The hub's q and k frames are
+`Linear(d, D)` per book, orthogonal-init; v and o are shared `Linear(d,
+d)` (`attention.py:64-79,106-109`). Construction warns when K > 2D — the
+supply law from ROUND 5e and the mini-beatrix-1 hub census
+(`attention.py:85-92`); 2s runs 64 @ 128, half of the lawful ceiling.
+
+**CausalSplatHUB — books and budget.** With `n_const = 4` the four books
+each own a codebook and q/k frames (`attention.py:64-79`); their
+numerators and agreement masses are summed across books before the one
+divide — composition by budget, never softmax over books
+(`attention.py:245-254`; B4 measured comparative composition at −.10).
+`n_const = 1` is the v1 layout with the same state-dict keys
+(`attention.py:93-101`), which is how mini-beatrix-1 checkpoints still
+load.
+
+**CausalSplatHUB — the exact chunked scan (prefix memory).**
+`_code_cat_qk` computes q and k for all books in one stacked GEMM,
+folds the row-norm and τ into one post-GEMM scale, and takes ONE fused
+softmax over `cat([u, −u])` — the module's docstring names this a
+kernel substitution, not a mechanism change: the softmax that exists is
+over the 2K oriented axes of a single query, never over positions
+(`attention.py:154-212`). `_scan_cat` splits the sequence into chunks of
+C = 256 (16 chunks at ctx 4096), forms per-chunk `(2K × d)` sums, takes
+the exclusive prefix over chunks as a strictly-lower-triangular GEMM
+with fp32 accumulation, adds the within-chunk causal affinity, and
+divides the numerator by the scalar agreement mass `den`, floored at
+`dtype_floor` (`attention.py:139-151,229-281`; `address.py:16-22`: fp16
+flushes 1e-12 to zero, the measured landmine). Exactness is
+chunk-independent (`forward_naive` is the oracle, `attention.py:320`;
+fp reorder ~1.5e-06). Decode carries a constant-size state per book —
+`{Σ k⁺⊗v, Σ k⁻⊗v, Σ k⁺, Σ k⁻}` — regardless of length
+(`attention.py:284-318`); the generate path falls back to a sliding
+window once the position table is exhausted because "the hub's
+constant-size state cannot evict" (`alephlm.py:180-201`).
+
+**The autocast trap.** `torch.einsum` sits in autocast's PROMOTE
+category and `F.normalize`/`exp`/`softmax` on its fp32 list, so one fp32
+operand dragged the whole scan to fp32 (`attention.py:167`); 0.7.2
+(@2be28dd) cast the operands explicitly. Every earlier "bf16" splat run
+had silently run fp32 scans; sdpa was unaffected — so every pre-0.7.2
+splat-vs-sdpa wall-clock comparison favoured sdpa, and accuracy
+verdicts stand (autocast einsum-promote law).
+
+**The governor.** `minsep_project_` bounds `|cos(a_i, a_j)| ≤
+cos(θ_min)` for every anchor pair by an exact symmetric geodesic
+push-apart, largest violation first, projected to θ_min + 0.5°
+(`governor.py:35-80`); `govern_model` collects hub and head codebooks,
+runs one batched `bmm` slack check with one device sync, and projects
+only the violating books (`governor.py:92-137`). It is a
+post-optimizer-step projection, never an auxiliary loss
+(`governor.py:11`); the trainer calls it every 8 steps after `opt.step`
+and accumulates pair-pushes into `governor/hits_cum`
+(`trainer.py:263-267,294-296`; `presets.py:99-105`: θ = 45°). Banks are
+excluded by default (a 3-anchor book never crowds). The docstring
+records the small-rig verdict it shipped on (gov25m: fires only when
+needed, census tail cut 5.4×, fragile-seed +.007, stable-seed +.002;
+`governor.py:19`). Code-wins note: the journal's covariance program
+describes a *metric* governor through the frame W_a; alephllm's is the
+plain projective form on the D-space books, justified in place —
+"Hub and head codebooks live natively in their own D-dim address space"
+(`governor.py:14`), since the q/k frames project d → D before the cosine
+read (`address.py:38-40`).
+
+**CausalSDPA in the twin.** `qkv = Linear(d, 3d)`, `o = Linear(d, d)`,
+both orthogonal-init and bias-free; `F.scaled_dot_product_attention(q,
+k, v, is_causal=True)` over 16 heads of 64 (`attention.py:24-42`);
+the KV cache grows O(n) (`attention.py:43-61`). No QK-norm, no logit
+softcap.
+
+**AnchoredBank.** `Bank(x) = trunk(x) + Σ_k w_k(x)·σ(g_k)·expert_k(x)`
+(`bank.py:3`): a dense trunk `t_out(GELU(t_in(x)))`, three experts
+`(3, 1024, 1024)` with `w_out` zero-initialised (the null path), gates
+at −3.0, and dispatch `w = addr.signed(x)` through a 3-anchor book in d
+dims. `disable_dispatch` returns the trunk alone — bit-identical to the
+dense control at birth (the C6 null); "No balance machinery of any
+kind" (`bank.py:10,41-50`).
+
+**DualHead.** `logits = W_h h + γ·W_s s(h)`, `s(h) = addr.signed(proj(h))`
+with proj `Linear(1024, 256)`, a 256 @ 256 book, `W_s` zero-initialised
+("weight-zero: self-starting") and γ = 1 frozen as an ablation knob
+(`head.py:23-51`). The docstring carries the law that set it: on
+mini-beatrix-1 over 8.4B tokens a gamma-gated branch DEADLOCKS while a
+weight-zero bank elected into +2 bpb (`head.py:8-11`; gate-zero deadlock
+law). `disable_aleph` returns `W_h h` alone — the head toggle.
+
+**The special-token control plane.** Thirteen ids that no UTF-8 encoder
+can emit — `{0xC0, 0xC1} ∪ [0xF5, 0xFF]`, the overlong leads and the
+leads past U+10FFFF — carry structure inside vocab 256: DOC 0xFF, USER
+0xFE, MODEL 0xFD, END 0xFC, SYS 0xFB, THINK 0xFA, DATA 0xF9, SEP 0xF8,
+MODE 0xF7 (+1 ASCII payload), CUE 0xF6, ESC 0xF5 (+payload = 256
+extended slots; 0x00 the null guard, 0x01 CANARY), RES0 0xC0, RES1
+0xC1 (`special_tokens.py:20-34,50-71`; `assert len(SPECIALS) == 13`).
+The proof is exhaustive — every codepoint 0..0x10FFFF encoded and
+checked — and the Trainer runs it at every byte-craft launch
+(`trainer.py:72-73`). Doctrine: DOC is appended by the packer after
+every document in every phase from birth, identity-gated to the
+byte-trigram tokenizer (`streams.py:59-62,209,355-356`); the chat frame `[SYS] text
+[END] [USER] text [END] [MODEL] text [END]` (`special_tokens.py:112-136`)
+is unforgeable (content is UTF-8) and appears only in the anneal
+(`special_tokens.py:36-44`; chat-in-anneal law). The canary frame moved
+to CUE/SEP because the old QRY=255 collided with DOC
+(`canaries.py:20-29`); `recall_acc` re-baselines at 0.8.0. The trigram
+embedding feeds each special into the next two positions' input
+representations by construction.
+
+## The recipe (pinned from source; unchanged cc89a87 → b472815)
+
+- **Split**: every parameter with `ndim ∈ {2, 3}` that is not an
+  `nn.Embedding` weight rides Muon; everything else — the three byte
+  tables, LayerNorms, bank gates, γ, the head bias — rides
+  `torch.optim.Adam(weight_decay=0.0)` (`optim.py:54-79`; "pure Adam,
+  wd=0 — never AdamW", `presets.py:82`). Measured split for 2s: Muon 385
+  tensors / 236,253,184 numel, Adam 107 / 872,765; the control's Muon
+  set is 145 / 256,569,344 with the same Adam set. Code-wins note: the
+  `optim.py:4-5,55-58` docstrings say positions ride Adam; the code
+  sends `embed.pos` (shape `(1, 4096, 1024)`, ndim 3, not an
+  `nn.Embedding`) to Muon (`optim.py:68`), verified on the meta device.
+  The journal already records the code's behaviour.
+- **Muon**: 5-step Newton–Schulz (a, b, c = 3.4445, −4.7750, 2.0315) on
+  the momentum buffer after whole-matrix Frobenius normalisation
+  `X/(‖X‖_F + 1e-7)`; plain momentum 0.95, no Nesterov, no shape
+  scaling; 3-D stacks orthogonalised per slice (`optim.py:20-51`).
+- **Learning rates**: Muon 2e-2, Adam 3e-4; `lr_scale = (step+1)/200`
+  for 200 steps, then 1.0 forever (`optim.py:82-93`, `presets.py:80-83`).
+  The tfevents read `train/lr_scale` 0.25/0.50/0.75 at steps 50/100/150
+  and 1.000 from step 200 to the last log on both crafts, through both
+  anneal phases: the anneal is a diet change, not a decay.
+- **Clip**: `clip_grad_norm_(…, 1.0)` over all parameters; the logged
+  `train/grad_norm` is the PRE-clip norm it returns (`trainer.py:244,
+  287`). Because Muon normalises the momentum buffer before
+  orthogonalising, its update magnitude is independent of gradient
+  scale: clipping never changes the magnitude of a Muon step; it only reweights
+  steps inside the momentum buffer. The Adam set (`torch.optim.Adam`,
+  wd 0, default eps 1e-8; `optim.py:79`) is per-coordinate
+  scale-normalised (`m/sqrt(v)`), so under a persistent clip its step
+  magnitude is likewise unchanged and the clip only reweights the two
+  moment averages (Muon is clip-blind; Adam is nearly so).
+- **Precision and batch**: fp32 masters, bf16 autocast on CUDA, TF32 on
+  (`trainer.py:14-15,65-66,239`); micro-batch 16 × accum 4 × ctx 4096;
+  seed 1337 (`presets.py:97,199`); each micro-batch row is 4097 ids
+  scored at 4096 positions.
+- **Guards**: a non-finite loss or gradient raises before any optimizer
+  step, weights untouched and the resume state not overwritten
+  (`trainer.py:250`); the spike flag `loss > 2·EMA + 0.5` is logged
+  only (`trainer.py:273-275,293`). Neither fired on either craft.
+- **Cadences**: log 50, health census 500, eval and checkpoint 2000,
+  fp8 every 5th checkpoint, TB upload 1000, val 262,144 tokens, 128
+  canary episodes (`presets.py:88-96`).
+- **Absent by design**: no QK-norm, no logit softcap, no z-loss, no
+  weight decay, no dropout, no RoPE, no LR decay in any phase.
+
+## The diet (all on one gauge: fineweb-edu holdout bpb)
+
+| phase | dataset | budget | → step | 2s bpb | control bpb | note |
+|---|---|---|---|---|---|---|
+| warmup_wikitext | wikitext-103 | 0.30B | 1,145 | 2.3626 | 2.1056 | sdpa led by 0.257; protocol pre-registered here |
+| fineweb_main | fineweb-edu | 5.0B | 20,219 | **1.1172** | 1.1763 | the crossover; hubs +2.22 / banks +3.55 |
+| fineweb_extended | fineweb-edu | 10B | — | — | — | DEFERRED, unspent on both |
+| curriculum_s0 | curriculum-s0 | 0.7B | 22,890 | 1.2522 | 1.5047 | |
+| REVIVAL | — | — | 24,860 | 1.2768 → 1.2339 (op gauge) | — | BOUNDARY-WRITE; `pre_revival_step24860.pt` archived |
+| curriculum_s1 | curriculum-s1 | 0.7B | 25,561 | 1.2544 | 1.3917 | first live head toggle in the lineage, +0.0258 |
+| curriculum_s2 | curriculum-s2 | 1.0B | 29,376 | 1.2177 | 1.3938 | 2s grad-norm curriculum+anneal max 0.619 @26,750 |
+| curriculum_s3 | curriculum-s3 | 1.2B | 33,954 | 1.2318 | 1.5317 | |
+| curriculum_s4 | curriculum-s4 | 1.2B | 38,532 | 1.2356 | 1.5689 | both 2s mechanisms above +3.0 |
+| curriculum_s5 | curriculum-s5 | 1.0B | 42,347 | 1.2504 | 2.1762 | control grad-norm median 126 |
+| curriculum_s6 | curriculum-s6 | 0.8B | 45,399 | 1.2683 | 3.1940 | control max 41,070 @44,600 |
+| curriculum_s7 | curriculum-s7 | 1.4B | 50,740 | 1.1883 | 3.1201 | |
+| curriculum_s8 | curriculum-s8 | 0.8B | 53,792 | *1.0737* (synthetic gauge) / **1.1911** (cap) | 3.0810 | 2s row STRUCK; true ledger = `session_cap_step53792` |
+| anneal_nochat | anneal-nochat | 1.0B | 57,607 | 1.1153 | 2.9270 | the pre-chat baseline; probe mean .389 |
+| anneal_mix | anneal-mix | 1.0B | 61,422 | **1.1097** | **2.8846** | run best; probe mean .389 == pre-chat |
+
+Phases and budgets: `presets.py:132-146` (the preset plan carries
+anneal_mix at 2B deferred; the notebook's C6 cell rewrote it to 1B and
+inserted anneal_nochat before it — "two-phase anneal activated: nochat
+1B then chat 1B (plan of record 2026-08-31)" in both manifests' notes; the
+hub copy of `beatrix_v2_colab.ipynb`, uploaded 2026-08-28T23:00Z with cells
+C1–C5 and pinned to `geolip-alephllm @2a902b7` (0.8.1), predates the
+amendment and carries no C6 cell),
+`curriculum.py:657-663` (STAGE_TOKENS), `curriculum.py:666-689`
+(append at runtime). Manifest order is not chronology: the S0–S8 phases
+are listed after the anneals but ran before them, because
+`current_phase()` activates the first `planned` phase and deferred
+phases are invisible until flipped (`manifest.py:33-41`); count back
+from the totals (16,101,408,768 − anneal_mix's 1,000,079,360 lands on
+step 57,607) rather than reading the list.
+
+**The mixes** (`curriculum.py:614-655`; weights sum to 1): s0
+tinystories .74, simple-wiki .20, aochildes .01, recall-synth .03,
+counting-synth .02 · s1 perspective-synth .30, tinystories .28,
+simple-wiki .20, cosmo-young .12, concept-synth .04, recall-synth .03,
+siqa-narrative .02, aochildes .01 · s2 concept-synth .30, cosmo-young
+.30, simple-wiki .12, tinystories .10, definitions .08, wikipedia-en
+.07, recall-synth .03 · s3 rulechain-synth .32, proofwriter-prose .22,
+simple-wiki .12, tinystories .10, wikipedia-en .08, cosmo-young .08,
+concept-synth .04, recall-synth .03, babi-prose .01 · s4 arith-synth
+.35, cosmo-young .32, simple-wiki .12, tinystories .08, rulechain-synth
+.06, counting-synth .04, recall-synth .03 · s5 causal-synth .32,
+atomic-flicker .25, tinystories .12, simple-wiki .10, gutenberg .08,
+cosmo-young .07, recall-synth .05, siqa-narrative .01 · s6
+tryfail-synth .32, tinystories .22, arith-synth .13, cosmo-young .10,
+simple-wiki .10, causal-synth .08, recall-synth .05 · s7 tinystories
+.10, cosmo-young .10, rulechain-synth .10, arith-synth .10, fineweb-good
+.10, simple-wiki .08, atomic-flicker .08, causal-synth .08,
+tryfail-synth .08, proofwriter-prose .08, recall-synth .05,
+perspective-synth .04, babi-prose .01 · s8 definitions .25,
+register-synth .25, simple-wiki .15, cosmo-young .12, wikipedia-en .10,
+tinystories .09, recall-synth .03, siqa-narrative .01. Rails audited at
+append time: MAX_EPOCHS 4.0, MAX_GENERATOR_SHARE 0.35, MIN_BALLAST 0.30
+natural text (`curriculum.py:548-551,565-596`); holdouts enforced at
+the generator — bAbI tasks 16/19, ProofWriter depth 5, rule-chain
+depth 5, three-digit subtraction (`curriculum.py:26-31`). No chat
+template in s0–s8.
+
+**The anneal recipes** (`streams.py:68-77`): ANNEAL_MIX = fineweb-edu
+.45, cosmopedia .20, tinystories .15, soda-dialogue .12,
+beatrix-texture-sp .05 (the specials-native SYS/USER/MODEL/END
+identity texture), recall-synth .03; ANNEAL_NOCHAT is the same list
+minus beatrix-texture-sp, renormalised by MixStream — so the nochat
+boundary is the exact pre-chat baseline on the same distribution.
+MixStream draws one component per batch from a counter-seeded RNG
+(`streams.py:375-404`): reproducible and resumable, but its state
+carries no recipe fingerprint (fresh starts only across recipe
+changes).
+
+**The DOC plane on the diet.** The packer appends DOC after every
+document (`streams.py:192-372`); the specials gauge reads `doc_bpb`
+(bits at positions whose target is DOC) and `reset_bpb` (mean bits over
+the 16 targets after each DOC) on the fixed val batches
+(`instruments.py:310-352`). doc_bpb fell 12.83 → 3.29 by 0.52B and
+sits at 3.862 at the endpoint (control 5.422); reset_bpb 4.287 → 2.130
+(control 3.825). doc_count is 70 in every 2s and control report except the struck 2s
+`curriculum_s8_step53792.json`, which reads doc_count 1612 (the synthetic
+fallback stream) — the same 70 documents every time on the fineweb-edu gauge.
+
+**The val gauge.** `_val()` builds 4 batches of (16, 4097) from
+`build_stream(dataset, …, seed = 1337 + 9999, role="val")`
+(`trainer.py:384-411`); for fineweb-edu the val region is the first
+2,048 unshuffled rows, which the training stream skips
+(`streams.py:56,279-282`), and `build_stream` routes every
+`curriculum-*` and `anneal-*` val request to that same fineweb-edu head
+holdout — "gauge continuity" in the source (`streams.py:423-447`). So
+from fineweb_main onward every row of both crafts is one gauge; the
+canon's CB2/CB3 "own slice" wording is struck by erratum
+(`canon/splat_aleph_battery.md:583`). **The s8 fallback caveat**: at the
+terminal curriculum boundary `current_phase()` is None (everything done
+or deferred) and pre-0.8.5 `_val` fell to the `synthetic` stream, so the
+2s `curriculum_s8_step53792` ledger is an incomparable artifact; 0.8.5
+(@7d48328) makes `_val` fall back to the last DONE phase's dataset
+(`trainer.py:397-401`), and the true end-of-curriculum ledger is
+`session_cap_step53792`, taken at the same step on the restored gauge
+(1.1911; banks +3.214, hubs +3.341, head +0.0149). The control, born
+under 0.8.7, measured its s8 row on the repaired gauge; the s8 pair is
+therefore not same-gauge and is struck from the paired count.
+
+## The life (`reports/v2/`, `resume/`, `runs/`)
+
+**Sessions.** The 2s craft ran five sessions on the one RTX PRO 6000
+(Blackwell, 96 GB; 4.54 s/step, ~58k tok/s), each its own event file:
+steps 50–8,300 (host 4d130c0e7351), 8,350–24,850 (91b9f3518593),
+24,900–43,100 (e935248f0778), 43,150–53,750 (68304a2b8506),
+53,800–61,400 (c2dc3d694638). The breaks are the session caps at 8,320
+(fineweb, 2.181B), 43,130 (inside s6, 11.306B) and 53,792 (the s8 boundary
+itself, the resumed session's first action) — `session_cap_step*.json`
+is written when a session hits MAX_HOURS mid-phase — and the revival
+halt at 24,860. Sessions are boundary-exact: the driver calls
+`train(max_hours, stop_at_boundary=True)`, which returns after each
+boundary checkpoint with `_last_boundary` set, and never auto-resumes a
+manual stop (`_interrupted`; `trainer.py:170-184,328-335`; the 0.8.1
+driver contract, minted after run0 rolled through its boundaries and
+swallowed a KeyboardInterrupt).
+
+**Resume.** `_restore` loads `resume/latest.pt` — fp32 model, both
+optimizer states, the stream position, torch and CUDA RNG, and the
+manifest snapshot embedded in the payload, which wins over the hub's
+`manifest.json` (`trainer.py:110-153`; `checkpoint.py:131-175`). A
+missing payload over a manifest with steps > 0 refuses to start fresh
+(`trainer.py:110-120`). Every phase boundary archives an immutable copy
+`resume/boundary_<phase>_step<N>.pt` (`trainer.py:469`;
+`checkpoint.py:134-154`). Resume is not row-exact: the datasets shuffle
+buffer (10,000 rows, `streams.py:292-293`) is not part of the saved
+state, so each resume refills it (`streams.py:12`, the honesty note).
+
+**The revival at 24,860.** The born-null head buried itself inside the
+first 2,000 steps (0.032× chance liveness at the first stored
+checkpoint; ‖s‖ ~6e-4; proj cosines ~60× below chance — learned
+avoidance; `repos/alephllm.md:1564-1643` — journal readings from
+checkpoint analysis: the craft's TB carries no `head/liveness_ratio`
+scalar before 0.8.4; the control's TB reads 0.052× @2,000, 0.014×
+@12,000, 0.010× @24,000). The BOUNDARY-WRITE op
+(`revival.py:44-104`) ran on the halted run: proj ← uncentered
+whitening-PCA of the final-norm outputs (sv floor 1e-3 relative);
+codebook ← fresh `normalize(randn)` with min-sep 45° (0 pushes needed);
+W_s ← fp64 ridge on the base head's CE residual, α swept on the held-out
+half and folded in. `revival_step24860.json`: K 256, D 256, seed 13,
+sv0 3676.66, svD 15.90, α 8.0, ‖W_s‖ 481.53, fit_positions 65,536,
+base_bpb 1.27682 → revived_bpb 1.23391 (Δ −0.04290 held-out),
+liveness 0.01027× → 0.99642×, version 0.8.2, commit d6e1854. The
+pre-revival resume was archived, Muon momentum zeroed for the three head
+tensors, and the revived payload promoted on Phil's explicit go
+(`repos/alephllm.md:1669`); thereafter `head_addr_frozen` freezes proj
+and the head codebook by `requires_grad` alone, so optimizer groups and
+resume state are unchanged and Muon skips them (`trainer.py:75-80`;
+`optim.py:42-43`). `checkpoints/step_00024860.safetensors` is the
+pre-revival bf16 weight; `step_00024860_revived.safetensors` (fp32) is
+the post-write weight; neither the revived file nor the resume archives
+appear in `manifest.json`'s checkpoint index.
+
+**The anneal.** Activated 2026-08-31T09:54Z after s8; nochat done
+14:42Z, chat done 19:31Z; the frame cost nothing in a bracketed phase
+(probe mean .389 → .389; val 1.1153 → 1.1097).
+
+**The 2s boundary ledgers** (`reports/v2/*.json`; bpb on the fineweb-edu
+holdout; toggles = mechanism-off minus full):
+
+| report | step | tokens | bpb_full | banks | hubs | head | doc / reset |
+|---|---|---|---|---|---|---|---|
+| warmup_wikitext | 1,145 | 0.300B | 2.36257 | +0.0365 | **+1.5042** | −2.3e-06 | 12.83 / 4.287 |
+| session_cap | 8,320 | 2.181B | 1.20332 | +1.727 | +2.036 | −4.9e-07 | |
+| fineweb_main | 20,219 | 5.300B | 1.11719 | +3.5527 | +2.2157 | −3.4e-07 | |
+| curriculum_s0 | 22,890 | 6.000B | 1.2522 | | | ~0 (born null) | |
+| curriculum_s1 | 25,561 | 6.700B | 1.2544 | | | **+0.0258** | |
+| curriculum_s2 | 29,376 | 7.700B | 1.2177 | | | +0.0140 | |
+| curriculum_s3 | 33,954 | 8.900B | 1.2318 | | | +0.0072 | |
+| curriculum_s4 | 38,532 | 10.100B | 1.2356 | >3.0 | >3.0 | +0.0130 | |
+| curriculum_s5 | 42,347 | 11.100B | 1.2504 | | | +0.0278 | |
+| session_cap | 43,130 | 11.306B | 1.2614 | | | | |
+| curriculum_s6 | 45,399 | 11.900B | 1.2683 | | | +0.0126 | |
+| curriculum_s7 | 50,740 | 13.300B | 1.1883 | | | −0.0010 | |
+| curriculum_s8 (STRUCK) | 53,792 | 14.100B | *1.0737* | *+3.396* | *+5.164* | | *0.843 / 1.889* |
+| session_cap (true s8) | 53,792 | 14.100B | **1.19112** | +3.2144 | +3.3410 | +0.0149 | 5.052 / 2.469 |
+| anneal_nochat | 57,607 | 15.100B | 1.1153 | | | +0.0101 | |
+| anneal_mix | 61,422 | 16.101B | **1.10970** | +3.3115 | +3.3584 | +0.0123 | 3.862 / 2.130 |
+
+Blank cells are not in the record consulted here; the head column is
+complete. The warmup row is the first full-splat-under-AR ledger: with
+all 20 hubs off the craft loses its entire attention (+1.50 at 0.3B),
+which is what "load-bearing, not decorative" measures against the
+mother's 3-hub form. `hidden_erank_floor` flags TRUE in every report from the 8,320 cap on (the
+trainer's own TB census, on the first val batch, flags it from step 500)
+(L19 pre-norm erank in single digits — the byte funnel; the post-norm
+`nf(h)` erank reads 334/1024), `head_buried` FALSE from s1 on, den
+floors 0.0 the entire run, zero loss spikes. Two "final val" readings
+exist on the hub: the report ledger 1.10970 (the gauge of record) and
+the manifest's checkpoint entry `val_bpb` 1.11403 at 61,422 — the
+manifest column is the LAST PERIODIC EVAL's `bpb_full` (eval every
+2,000; `trainer.py:444-447`), so it lags every boundary (fineweb 1.1156
+vs 1.1172; s8 1.1833 vs 1.0737/1.1911); the manifest minimum is 1.1140
+@60,000. Cite the report.
+
+## The paired record (`mini-beatrix-2s-control/reports/v2/`)
+
+**Derivation.** Every preset auto-generates a `-control` twin: the same
+`AlephLMConfig` with `hub_layers = ()` (`presets.py:216-229`), so
+`hub_K/hub_D/hub_const/hub_chunk` are carried but unused and every
+block's attention is CausalSDPA. 0.8.7 (@b472815) gave twins their own
+`TrainConfig` copy — the shared instance had let `head_addr_frozen=True`
+leak into the control, a post-revival flag no birth recipe may carry —
+and sets the 2s control to `head_addr_frozen = False` explicitly: the
+birth recipe, born-null unfrozen head, which buries as the treatment's
+did for its first 24,860 steps (`presets.py:221-235`). The control
+inherits `governor="minsep"`; with no hub books it governs the head
+codebook only (hits_cum 10 at warmup, fineweb and the 22,854 cap — the first
+session — and 0 in every later session's report;
+`crowd_check_extra_hits` 0). Same seed 1337: construction order embed →
+blocks → norm → head after `torch.manual_seed` (`trainer.py:63`;
+`alephlm.py:85-96`) makes the embedding draws identical between craft
+and twin; the RNG streams diverge from block 0's attention onward
+(a derivation from construction order, not a weight comparison).
+
+**Protocol.** Declared at the control's warmup boundary, before the
+outcome, while sdpa led (2.1056 vs 2.3626): the architecture verdict is
+the paired boundary table across the full 16.1B matched budget; the
+headline is endpoint val; secondaries are probe means at matched
+boundaries and the doc/reset gauges; no verdict from any intermediate
+lead in either direction (`repos/alephllm.md:1961-2002`; a control must
+be able to fail). Completed unaltered through 13 paired rows. Budgets
+are matched in tokens, not wall-clock: fused sdpa ran 71.9k tok/s on the
+RTX PRO 6000 and 113k on the H100 against the eager scan's ~58k.
+
+**The paired rows** (bpb_full, same step, same tokens, same gauge except
+where struck; deficit = control − craft):
+
+| boundary | step | tokens | 2s | control | deficit | control bank toggle | control grad-norm median |
+|---|---|---|---|---|---|---|---|
+| warmup | 1,145 | 0.30B | 2.3626 | 2.1056 | −0.257 | −0.008 | |
+| fineweb | 20,219 | 5.30B | 1.1172 | 1.1763 | +0.059 | 1.62 | 0.31 |
+| s0 | 22,890 | 6.00B | 1.2522 | 1.5047 | +0.253 | 3.44 | 6.47 |
+| s1 | 25,561 | 6.70B | 1.2544 | 1.3917 | +0.137 | 3.61 | 2.43 |
+| s2 | 29,376 | 7.70B | 1.2177 | 1.3938 | +0.176 | 4.13 | 11.9 |
+| s3 | 33,954 | 8.90B | 1.2318 | 1.5317 | +0.300 | 4.73 | 12.7 |
+| s4 | 38,532 | 10.10B | 1.2356 | 1.5689 | +0.333 | 5.09 | 24.5 |
+| s5 | 42,347 | 11.10B | 1.2504 | 2.1762 | **+0.926** | 4.36 | 126.4 |
+| s6 | 45,399 | 11.90B | 1.2683 | 3.1940 | **+1.926** | 3.89 | 471 |
+| s7 | 50,740 | 13.30B | 1.1883 | 3.1201 | +1.932 | 4.17 | 162 |
+| s8 | 53,792 | 14.10B | *1.0737* | 3.0810 | STRUCK (gauges differ) | 5.48 | 145 |
+| anneal_nochat | 57,607 | 15.10B | 1.1153 | 2.9270 | +1.812 | 5.64 | 167 |
+| anneal_mix | 61,422 | 16.10B | **1.1097** | **2.8846** | **+1.775** | 6.11 | 215 |
+
+Eleven same-gauge rows after the crossover, all in the craft's favour;
+the endpoint gap is +1.775 at 16,101,408,768 tokens on both. The
+control's own trajectory is the finding: 1.1763 at 5.3B → 3.1940 at s6
+→ 2.8846 at the end — a destabilised model at its endpoint, not a
+trailing one. Its endpoint ledger: bank_off 8.99015 (toggle +6.1056),
+head toggle −1.06e-05, `head_buried` TRUE at every row from fineweb on,
+doc_bpb 5.422, reset_bpb 3.825; probes p0 .200 p1 .333 p2 .267 p3 .333
+p4 .300 p5 .433 p6 .233 p7 .433 p8 .333 against the craft's .367 .367
+.600 .200 .333 .567 .333 .333 .400 — ties at n = 30 (SE of a difference
+.126). The control's bank dispatch entropy fell through the curriculum
+(`collapse/dispatch_entropy_L5`: .94 at the s0 census, .75 @30,000, .48
+@35,000, .22 at the s5 census; L0 .75 → .47 @30,000; layer minimum .14
+@42,500), ahead of the >30 grad-norm-median onset at 38,000.
+
+**The destabilisation facts** (from the hub tfevents, `train/grad_norm`
+= pre-clip): the control first crossed the clip at step 17,600 (4.61B,
+inside fineweb, on the RTX PRO 6000, while still leading); 813 of 824
+logged curriculum+anneal steps clipped (98.7%); 38 steps above 1,000;
+max 41,070 @44,600; the > 30 onset at bin 38,000 (late s4) and > 100 at
+40,500 (mid-s5) inside one event file. The 2s craft: 0 of 1,225
+logged steps from step 200 on above the clip (the only reading above 1.0 is
+step 50, 1.063, inside the 200-step LR warmup); max 0.760 @1,300 after the
+warmup boundary, and 0.619 @26,750 (s2) over the 824 curriculum+anneal steps. The spike
+detector and the non-finite guard never fired on either craft. Under
+Muon the clip braked nothing in the Muon group (qkv/o, the position
+table, the head); the escalating norm is a sharpness signal, not a
+throttled step.
+
+**The grade and its caveats.** The instance holds: the all-sdpa twin is
+a destabilised control under the splat-tuned recipe, one craft per arm
+(S-1802 INSTANCE). The general claim — softmax attention is inadequate
+for this model's attention requirement — is a CANDIDATE (S-1803) behind
+confounds stated as measurements: (a) the recipe was tuned on the splat
+craft and carries none of the field's softmax stabilisers (QK-norm,
+softcap, z-loss, weight decay, decay), and the signature — clip-engaged
+smooth degradation, entropy and rank collapse, no NaN, onset on plain
+prose while leading — is the documented softmax logit-growth mode;
+(b) n = 1, no bar, +20.3M parameters in the losing arm; (c) shape: the
+mother null — mini-beatrix-1 (13 sdpa + 3 hubs, d768) under the
+identical TrainConfig (git cc89a87..b472815; the manifests record no
+train_config) through the same nine stages at the same budgets ran a
+post-warmup grad-norm max of 0.883, 0 of 1,750 logged steps clipped
+(`canon/splat_aleph_battery.md:955`; canon-cited, not re-verified against
+the mini-beatrix-1 event files for this companion — her 88,508 steps /
+26,102,071,296 tokens / 70.45 h do verify against
+`mini-beatrix-1/manifest.json`) — with the nuance that v1 entered
+s0 at 17.3B tokens after 15B prose and a 2B anneal, the control at 5.3B;
+(d) the aleph-addressed bank sits in both crafts, its dispatch collapse
+precedes the escalation, and no sdpa + dense-FFN arm exists at any
+scale; (e) the 4096×1024 position table on WD-free Muon at 2e-2 forever;
+(f) house Muon is not reference Muon; (g) host and row-order
+asymmetries. One gauge (val bpb; probes are ties); the s8 pair struck;
+three hosts. dist-e002 (vision, two seeds) remains the only Law-E
+splat-vs-sdpa endpoint, and it is a tie.
+
+**Provenance of the three hosts.** RTX PRO 6000 from birth to the 23.5 h
+cap at 22,854 (event file 50–22,850); a Colab H100 80 GB from 22,854
+(~2.3–2.4 s/step) through s0–s8 (22,900–53,750), 36 steps before the s0
+boundary, with the shuffle buffers refilled; a session 53,800–56,000
+follows the 53,792 cap in the H100 session's own host and process (event
+file `…0a706d592fec.620.1`, 20:01–21:35Z, ~2.3 s/step, 114k tok/s); a third
+host (2b1783ef9e94) opened 2026-09-03T01:41Z from the step-56,000
+checkpoint at ~3.6 s/step and ran both anneal rows (56,050–61,400; two
+88-byte event files are aborted starts) — a replay of up to 999 steps at
+that restart is a hedge on the 1,000-step TB-upload cadence, not a hub
+reading (the H100 process's last event is 21:35:20Z, the step-56,000
+checkpoint landed 21:35:33Z and its manifest 21:36:06Z, the third host
+opened 01:41:15Z; the hub can neither confirm nor refute a replay), and
+it left no cap report.
+The canon's "on the H100" lines for boundaries 11–12 are wrong by
+erratum (`canon/splat_aleph_battery.md:1008`). The escalation began
+pre-resume on the RTX PRO 6000; a 36-step data-order change cannot make
+a 0.25 bpb gap on a fixed eval.
+
+## The boundary report (`reports/v2/`) — schema
+
+Written by the notebook's `boundary_report(run, tag)` cell to
+`reports/v2/{tag}_step{step}.json`, tag = the phase that just finished
+or `session_cap`:
+
+- `tag`, `step`, `tokens` — `tokens` is `manifest.tokens_seen` (new
+  in the v2 record).
+- `probes` — `{p0_grounding, p1_self_other, p2_difference, p3_logic,
+  p4_arithmetic, p5_causal, p6_learning, p7_composite,
+  p8_articulation}`, each `{acc, families{…}, n: 30}`; byte-NLL argmin
+  over the options, fp32, no sampling (`probes.py:191-221`); holdout
+  families p3:d5 and p4:sub3 gauged from time zero (`probes.py:171`).
+- `census_flags` — `hidden_erank_floor` (any block-output effective
+  rank < 0.05·d = 51.2), `anchor_merge` (any pair |cos| > 0.99 in a
+  bank/hub/head book), `dispatch_collapse` (bank dispatch entropy
+  fraction < 0.10), `den_floor` (hub den floor_frac > 1e-3),
+  `head_buried` (liveness < 0.1; added at 0.8.2 — absent from the 2s
+  warmup_step1145, session_cap_step8320, fineweb_main_step20219 and
+  curriculum_s0_step22890 reports, present from s1; present in every
+  control report),
+  `codebook_erank_floor` (bank codebook erank < 1.5)
+  (`instruments.py:150-178`). The census sample is `(2, min(1024,
+  ctx))` random bytes in 0..254 (`torch.randint(0, 255, …)`, so DOC never appears in the census sample) in the notebook writer; the trainer's own census
+  uses the first val batch (`trainer.py:371-374`).
+- `ledger` — `bpb_full`, `bpb_bank_off`, `bpb_head_aleph_off`,
+  `bpb_hub_off` (only if any block is a hub — the control's ledger has
+  five keys), and `toggle_<x> = bpb_<x> − bpb_full`; mean CE over the
+  fixed val batches / ln 2 (`instruments.py:187-212`). No `w_s_norm`
+  field (the mb1 schema had one).
+- `special` — `{doc_count, doc_bpb, reset_bpb}` (`instruments.py:
+  310-352`); None on BPE crafts.
+- `governor_hits_cum` — the session's cumulative pair-pushes; the
+  counter is a Trainer attribute defaulting to 0 (`trainer.py:266`),
+  not persisted in the manifest or the resume payload, so it resets
+  every session (103,951 @1,145; 1,304,497 @20,219; 70,747 at s1 after
+  1,604,488 at s0; 0 at session_cap_53792; 776,450 @61,422).
+- `crowd_check_extra_hits` — pushes from an on-demand `govern_model` at
+  report time (415 @20,219; 709 @61,422; 0 on the control).
+
+Other report kinds in the same directory: `revival_step24860.json` (the
+op record above, no probes/ledger — chart code must skip it) and
+`cultivation_{A_born_null,B_revival_birth,C_matured_transplant,
+D_live_address_only}.json` — the C7 head-cultivation screen, 1,200
+steps at seed 1337 with gauges at 300/600/900/1200 `{toggle, w_s_norm,
+head_s_norm, head_s_chance, head_liveness_ratio, head_buried}` and,
+for B and D, a `revival` dict (α 16.0, fit 16,384, base 8.336 → 5.389).
+Endpoint toggles: A −5.3e-06 (buried, liveness 0.045); B +3.496
+(liveness 1.125); C +0.0922 (‖W_s‖ 520.5); D −7.1e-05 (liveness 1.037,
+not buried, no function) — a live address alone does not carry
+function; a revived head at birth does.
+
+**The manifest** (`manifest.py:16-110`): `preset`, `model_config` (the
+full `AlephLMConfig`), `created_utc`, `updated_utc`, `steps`,
+`tokens_seen`, `wall_hours`, `phases[{name, dataset, planned_tokens,
+tokens_done, status ∈ planned|active|done|deferred}]`,
+`checkpoints[{step, tokens, kind ∈ safetensors|resume|fp8, path,
+val_bpb, utc}]`, `data_state{dataset, rows_consumed, epoch}`,
+`notes[{utc, msg}]`. 2s: created 2026-08-27T00:35:31Z, updated
+08-31T19:37:50Z, 142 entries (59 safetensors / 24 fp8 / 59 resume → 46
+distinct bf16 paths). Control: created 08-31T21:26:32Z, updated
+09-03T07:16:38Z, 136 entries → 44 bf16. Neither records a train_config.
+
+**Checkpoint kinds** (`checkpoint.py:102-155,187-195`): bf16 safetensors
+every 2,000 steps and at every boundary, every state-dict tensor
+including the `addr.home` buffers (so the file's numel, 237,908,285,
+exceeds the parameter count by 782,336); fp8-e4m3 every 5th checkpoint
+or final, 2-D+ tensors with numel > 4,096 stored with a per-tensor fp32
+scale `amax/448` under `<key>.scale`, small params kept bf16, metadata
+"inference/testing only" — never train from these; `resume/latest.pt`
+fp32 with the manifest embedded, overwritten at every checkpoint and
+archived at boundaries. Hub uploads retry three times and never crash
+training; downloads distinguish genuine absence from network trouble
+and raise on the latter (`checkpoint.py:29-100`).
+
+**TensorBoard tags** (`trainer.py:283-296`; `instruments.py:215-260`;
+314 tags on the craft, 212 on the control): from the loop
+`train/{loss,bpb,grad_norm,lr_scale,tokens,tokens_per_sec}`,
+`collapse/loss_spike`, `governor/hits_cum`, `sys/vram_gb`; from the
+census per layer i `erank/hidden_L{i}`, `erank/hub_consumed_L{i}`,
+`erank/hub_codebook_L{i}`, `erank/bank_codebook_L{i}`,
+`cv/bank_load_L{i}`, `cv/hub_usage_L{i}`, `drift/bank_L{i}`,
+`drift/hub_L{i}`, `sign/bank_frac_neg_L{i}`,
+`collapse/dispatch_entropy_L{i}`, `collapse/den_floor_L{i}`,
+`gates/L{i}_e{k}`; head `head/{gamma,w_s_norm,s_norm,liveness_ratio,
+consumed_erank}`, `erank/head_codebook`; `collapse/flag_{…}` for the six
+flags; `toggles/{bpb_full,bpb_bank_off,bpb_head_aleph_off,bpb_hub_off,
+toggle_bank_off,toggle_head_aleph_off,toggle_hub_off}`; from the full
+eval `canary/{recall_acc,wrongpair_frac,noretrieval_frac}` and
+`special/{doc_count,doc_bpb,reset_bpb}`. The control lacks every hub
+family; the archived run0 file lacks `head/liveness_ratio`,
+`head/s_norm`, `special/*` and `flag_head_buried` (pre-0.8.0 specials;
+the `head_buried` flag arrived at 0.8.2 @d6e1854 and the `head/s_norm` +
+`head/liveness_ratio` TB scalars at 0.8.4 @a690ea4).
+
+**`archive/run0-nospecials/`.** The pre-specials attempt, archived whole
+2026-08-27T00:16Z: its manifest (created 08-26T20:50:18Z, steps 2,537,
+tokens 665,059,328, wall 3.22 h, warmup done at 1,145, fineweb_main in
+progress), bf16 checkpoints 1,145/2,000/2,253/2,537, fp8 2,253/2,537,
+`resume/{latest,boundary_warmup_wikitext_step1145}.pt`, one event
+file, and a report at the doubled path
+`archive/run0-nospecials/mini-beatrix-2s/reports/v2/warmup_wikitext_step2253.json`
+— a late-tagged fineweb report written on interrupt (stale tag, doubled
+path: the 0.8.1 driver-contract bug) with probes, five census flags and
+governor fields but no `ledger`/`special` block. Code-wins note: the
+manual's RIDER 9 says run0 "halted at step 2000"; the archived manifest
+says 2,537 (train() swallowed the interrupt and the driver auto-resumed
+~19 minutes; `repos/alephllm.md:1408`). The hub wins: 2,537.
+
+## The AutoModel (AbstractPhil/mini-beatrix-2s)
+
+Thirteen files: `README.md`, `config.json`, `modeling_minibeatrix.py`,
+the vendored `address.py`, `alephlm.py`, `attention.py`, `bank.py`,
+`embedding.py`, `governor.py`, `head.py`, `presets.py`,
+`model.safetensors` (475,880,498 B; 593 bf16 tensors, numel
+237,908,285, every key prefixed `model.`, metadata `{tokens: 16.101B,
+step: 61422, format: pt}`), `.gitattributes`. No tokenizer files: input
+ids are raw UTF-8 byte values. The vendored files are byte-identical to
+`geolip/alephllm/model/*.py` and `presets.py` at 0.8.7 except one
+import line (`alephlm.py:30`, `..presets` → `.presets`). `config.json`
+is the craft's `model_config` plus `model_type "mini-beatrix"`,
+`auto_map` to `MiniBeatrixConfig`/`MiniBeatrixForCausalLM`,
+`torch_dtype "float32"` (the file is bf16; the loader upcasts on
+request), `use_cache false`. The wrapper (`modeling_minibeatrix.py:
+21-99`) holds `self.model = AlephLM(cfg)`, forces `hub_ckpt = 0`, makes
+`_init_weights` a no-op ("AlephLM initializes itself; loader must not
+re-init"), truncates to the last `context` positions, returns
+`CausalLMOutputWithPast(loss, logits)` with HF label semantics, and
+carries no KV cache — HF `generate()` recomputes the prefix each step;
+the inner `AlephLM.generate(idx, max_new, temperature, top_p,
+use_cache=True)` uses the constant-size hub state.
+
+**The parity gate.** The ship gate — strict load, logits parity 0.0
+against the geolip code path, `generate()` ok — is journal-recorded
+(`repos/alephllm.md:1840-1846`; `history/timeline.md` 2026-08-31;
+`MIRROR.md` step 2 in the AlephLLM repo), not hub-shipped: no parity
+script exists on either hub repo or in the package. Re-verified on CPU
+by the drafting workflow (torch 2.11.0, transformers 5.13.0, no geolip
+installed; not re-run in the hub-side pass, which found the hub
+consistent with these readings — TB `head/w_s_norm` 515.13 at step
+61,000, 593 bf16 tensors, numel 237,908,285): 593 file keys == 593 model keys, parameter count
+237,125,949, ‖W_s‖ 515.918, γ 1.0; the inner cached decode equals the
+parallel path (`torch.equal` True); logits parity against geolip was
+not recomputed. Two notes for the reader: the model card's lineage line
+says alephllm 0.8.6 while the vendored files are the 0.8.7 mirror
+(commit 90a06b75, 2026-08-31 21:11 — the `presets.py` carries the 0.8.7
+twin-isolation block); and the card's "17 reports" counts the 16
+boundary/session reports plus the revival op — the prefix holds 21
+JSONs with the four cultivation arms.
+
+**Load and evaluate** (the steps below were executed by the drafting
+workflow; the numbers are from that run and were not re-run in the
+hub-side pass):
+
+```python
+import math, torch
+from transformers import AutoModelForCausalLM
+m = AutoModelForCausalLM.from_pretrained("AbstractPhil/mini-beatrix-2s",
+                                         trust_remote_code=True).eval()
+ids = torch.tensor([list(text.encode("utf-8"))])          # bytes in
+bpb = m(input_ids=ids, labels=ids).loss.item() / math.log(2)
+# toggle ledger on the inner model (positive delta = mechanism carries function)
+core = m.model
+full = core(ids, labels=ids).loss / math.log(2)
+bank_off = core(ids, labels=ids, disable_bank=True).loss / math.log(2)
+hub_off = core(ids, labels=ids, disable_hub=True).loss / math.log(2)
+head_off = core(ids, labels=ids, disable_head_aleph=True).loss / math.log(2)
+# generation: HF path (no cache) or the inner cached decode
+out = core.generate(ids, max_new=40, temperature=0.0, use_cache=True)
+print(bytes(out[0].tolist()).decode("utf-8", errors="replace"))
+```
+
+On a 227-byte English snippet this read 0.9446 bpb full, +3.872 bank
+off, +3.925 hub off, +0.0156 head off; greedy from "The history of
+astronomy begins with the" continued " study of the sun and the
+planets. The s". Chat: wrap raw bytes in 0xFB SYS / 0xFE USER / 0xFD
+MODEL / 0xFC END (`special_tokens.py:112-136`). Training checkpoints
+load into the same wrapper after prefixing every key with `model.`, or
+into a bare `AlephLM(cfg.to_aleph())`; fp8 files must be rehydrated
+first (`checkpoint.py:187-195`). What the AutoModel cannot reproduce is
+the gauge of record: the fineweb-edu holdout needs
+`geolip.alephllm.data.streams.build_stream(dataset, tok, 4096, 16, seed
+= 1337 + 9999, role="val")` and 262,144 tokens (4 batches of 16 × 4096),
+then `toggle_ledger` and `special_token_gauge` over those fixed batches
+(`trainer.py:384-411`; `instruments.py:187-212,310-352`).
+
+## The process that made 2s different (dated)
+
+**The mother, measured (2026-08-12 → 08-27).** mini-beatrix-1 was built
+with 13 sdpa blocks and three hubs at layers 4/9/14, each a single
+512-anchor book in D = 32 (`git show cc89a87:presets.py`), full-width
+banks holding 67% of the mass, and a 512 @ 32 head. Two post-mortems set
+the 2s agenda: the 08-25 hub census — 16× the K ≤ 2D supply, 333/646/181
+duplicate anchor pairs at |cos| ~1.0, consumed erank 2.2/3.7/10.8 — and
+the 08-27 autopsy of the shipped weights, W_s exactly 0.0 after 8.4B:
+the "head election" lore retracted, the head never carried function
+(`repos/alephllm.md:1586`; `history/plans/2026-08-26_mini_beatrix_v2_shape.md`).
+A third: the v1 anneal (2B, chat template inside, before the school)
+baked the chat frame into the core irreversibly — the chat-in-anneal
+law (2026-08-15) that later dictated the bracketed two-phase anneal.
+
+**Why every block (08-23 → 08-26).** Phil's directive: "the entire model
+to be splat attention". The record's support was dist-e002 — cured
+splat in all 12 ViT-Ti blocks ties sdpa at matched params and matched
+wall-clock on two seeds (R@1 .0545 vs .0562), late placement edging
+(R@5 +.0128, outside the bars); the untested bet, flagged in the plan,
+was that full-splat CAUSAL had never trained. The payoff row was the
+warmup ledger (+1.50 with the hubs off at 0.3B) and the endpoint
+(+3.36).
+
+**The shape (08-24/25 → 08-26).** ROUND 5e's shape ladder: 8 × 256 lost
+4 of 4 paired against 12 × 128, the wide model seed-fragile, its
+crowding tail (79% of layer-1 heads over the 25° floor on one seed)
+naming the chain width → crowding → positional ranking flips → deficit;
+hence SUPPLY K ≤ 2D (`STATUTES_INDEX.md:53`) and depth over width. B2's
+product code (independent books compose, .859 → .955 monotone in
+members) gave the multi-book form; the rotary × anchor flip analysis
+gave governability D ≥ 128 (γ* 32° at d512, 45° at 256, unreachable at
+64). The arithmetic lands on 4 × 64 @ 128 (0.5× supply, 4× headroom
+against v1's 16×), L20, d1024, ctx 4096 (splat's wall-clock crossover
+~2k; below 4k a full-splat trunk pays attention's price without the
+O(L) payoff), banks narrowed to ff 1024, head 256 @ 256. The 849M
+sibling (L32, ctx 8192, 16 × 256 @ 256) was designed the same session
+(`presets.py:161-183`).
+
+**The governor from birth (08-24 → 08-26).** Phil's proposal —
+"a middleman to control a min/max space that drift can occur to
+guarantee there's always enough space between the anchor points" — was
+confirmed in the math: for a crowded pair the static logit gap is
+quadratic in separation while the positional oscillation is linear, so
+small separation flips weight rankings along the sequence; separating
+an already-crowded trained book leaves its flip pattern bit-identical,
+so min-sep is preventive, not curative — run it from birth. Rung 1 ran
+bit-identical to the ungoverned run (raw books never crowd; the
+crowder was the frame W_a); gov25m fired on the fragile seed only,
+harmlessly. Shipped as a post-step projection, 45°, every 8 steps
+(`governor.py`, `presets.py:99-105`). In-mission it ran hot — ~120
+pushes/step at step 1,000, ~84–105 sustained through fineweb, never
+decaying — with every function gauge healthy; the θ ladder 35/40/45 for
+K = 64 @ D128 is an open rung, and the preset comment's "45 at D=256"
+does not itself justify 45° at D = 128.
+
+**The kernel campaign and the pivot (08-26, one day).** 0.7.0 at 10:41
+(multi-constellation hub, supply guard, governor wired in, the 849M
+rescale, 2s as the screen craft). The Blackwell preflight OOMed
+(`hub_ckpt`), then launched at 161.88 s/step; the per-op profiler
+printed `qc torch.float32` under autocast — 0.7.2 at 12:27 (the einsum
+promote trap; 4090 hub fwd+bwd 229.7 → 178.8 ms). The dtype fix bought
+~6%; the binding constraint was kernel shape — 0.7.3 at 13:14 (one
+stacked GEMM, one fused softmax, prefix as a triangular GEMM; 65.3 ms,
+3.5×; peak 7.4 → 1.9 GB; Blackwell 149 → 69.7 s/step). Compile refuted
+by measurement (bf16-backward NaN, and the pre-NaN projection 67 vs
+69.7 s eager) — eager-only on Blackwell. Economics: 17.3B at 8k tok/s
+is 24–26 days on the one card. Phil: "we can't train the large one
+currently. Not until we work out a series of logistics problems." 0.7.5
+at 13:43 (@73218bd): 2s is the mission, `hub_ckpt` 2 → 0; launched at
+4.54 s/step, 58k tok/s. "Not a bad start. We'll train this one." The
+849M is shelved, not retired (its value-bottleneck relaunch lever
+quantified at ~46 s/step).
+
+**The format restart (08-26 16:43).** Phil: "We'll want a practical
+array of them for usage, nothing small. We'll halt this one and start
+over with the correct formatting." 0.8.0: the thirteen unreachable ids,
+the exhaustive proof at every launch, DOC from birth, the frame only in
+anneal, the canary collision caught; run0 archived whole, run1 fresh on
+the clean prefix (manifest 08-27T00:35Z). DOC cost nothing — run1 train
+bpb 1.49 @1,100 against run0's 1.494 @1,000 — and doc_bpb fell 12.83 →
+3.29 by 0.52B. 0.8.1 the same day: the driver contract that made every
+later boundary row a real boundary.
+
+**The head saga (08-13 → 08-29 → 08-31).** Born weight-zero by law
+(gate-zero deadlock, `head.py:8-11`); buried inside 2,000 steps on run1
+(0.032× chance at the first stored checkpoint, 0.014× @12k — journal
+readings from checkpoint analysis, not TB scalars; learned
+avoidance — proj rotated into codebook-orthogonality while W_s grew to
+norm 31 multiplying ~0); LS-ignite alone refuted (0.0006 bpb); the
+governor exonerated (the ungoverned v1 buried deeper; the 45° floor is
+free at birth). Candidate law at 2/2 crafts, 3/3 with the control: a
+born-null aleph head racing a strong same-target linear base
+self-buries within ~2k steps; the bank's self-start does not transfer
+across competitor types. Phil ruled activation; the BOUNDARY-WRITE law
+was minted (`revival.py:26`; `STATUTES_INDEX.md:67`) — a third
+intervention category outside both the governor statute and the
+no-balance-machinery law, permitted only at run boundaries or halted
+resume points, always logged — and the deterministic op executed at
+24,860. The first nonzero head toggle in lineage history landed at s1
+(+0.0258, after 6.5B tokens of exactly 0.000); the settled read is a
+durable, small, diet-sensitive niche in the band −.001..+.028,
+band-exits upward on the binding-adjacent diets (s5 causal +.0278),
+touching zero at s7 as bpb_full fell 1.268 → 1.188.
+
+**The recipe that never changed (08-12 → 09-04).** Muon on the trunk
+because the 08-10 validity battery on the AR bed read muon .8081 >
+sgd_mom .7995 > adam .7157 > lion .5638, with the address ~20× more
+optimizer-fragile than sdpa (cross-optimizer spread .79 vs .037) and
+schedules no-op-to-harmful (flat .714 > warmcos .596) — so the flat-LR
+law; pure Adam on the rest by the 09-01 optimizer statute (Adam the
+experimental baseline, Muon the trunk, AdamW never;
+`STATUTES_INDEX.md:76`). `presets.py:80-84` is the same text at
+cc89a87 (where it sits at `presets.py:65-69`) and at HEAD. The same recipe is the audit's confound (a).
+
+**The diet (08-15 → 08-31).** The nine stages and budgets are v1's
+(0.6.0), placed before the anneal rather than after it (Phil,
+2026-08-30: "Let her really build up that internal knowledge first";
+`history/plans/2026-08-26_mini_beatrix_2s_mission.md`), fineweb_extended
+deferred; the two-phase anneal (Phil, 08-31: "enable the anneal mix
+without chat and the anneal mix with chat, we'll run without first,
+then just train chat on after"; `streams.py:63-77`), 0.8.6 at 02:48.
+The s8 terminal-gauge hole appeared at 04:57Z and 0.8.5 had already
+closed it in code (08-30 22:03); the true ledger was re-measured at
+09:53Z. Mission complete 19:31Z: 61,422 steps, 16.101B tokens, 78.33 h,
+zero spikes; the HF outage at the final push was recovered by a Drive
+rescue and retry.
+
+**The twin (08-31 → 09-04).** 0.8.7 at 14:10 (twin isolation, birth
+recipe); the control born 21:26Z; the protocol declared at its warmup
+boundary while sdpa led; the crossover at fineweb 5.3B and every row
+after; the rank story as the mechanism claim (at step 4,000 the control
+collapses early hidden erank to 5–9 of 1024 at L2–L4 (5.5 / 5.4 / 9.3)
+while the craft reads 234 / 225 / 250 there and 150–396 across L0–L15
+(`erank/hidden_L{i}`, TB census); screen scale reproduces it; rank ≠ function — the
+control led val at 4k while running rank-5 layers); the H100 resume at
+22,854; the grad-norm escalation rider at s5; Phil's claim held on
+09-02 ("SDPA isn't an adequate representative of this model's
+attention requirement. We can say that without question now."); the
+third host from 56,000; the endpoint 09-03; the 12-agent audit on 09-04
+(S-1802 INSTANCE, S-1803 CANDIDATE, the s8 strike, the mother null,
+Muon clip-blind, the falsifier filed).
+
+## Gauges, defined once
+
+- **val bpb**: mean cross-entropy in bits/byte over 262,144 tokens
+  (4 batches of 16 × 4096) of the fineweb-edu reserved head slice —
+  the first 2,048 rows, fixed, unshuffled, seed 1337 + 9999 — for every
+  phase from fineweb_main onward, both crafts (`trainer.py:384-411`;
+  `streams.py:279-282,423-447`; gauge continuity law). The warmup row
+  vals on wikitext-103's validation split. Pre- and post-0.8.0 gauges
+  differ for v1-era crafts (DOC rides the val stream).
+- **toggle ledger**: bpb with one mechanism disabled minus full bpb —
+  the causal contribution of banks / hubs / head aleph
+  (`instruments.py:187-212`). Positive = the mechanism carries function.
+- **specials gauge**: `doc_bpb` and `reset_bpb` in bits, read against
+  the same val batches (`instruments.py:310-352`); `doc_count` 70 on
+  every 2s-era report on the fineweb-edu gauge (the struck 2s s8 file reads 1612).
+- **head liveness**: mean ‖signed read‖ of real hidden states over the
+  same book's mean on 512 random unit vectors — self-calibrating;
+  `head_buried` = ratio < 0.1 (`instruments.py:144,176,356-382`).
+  Both buried crafts sat at 0.003×–0.03× chance.
+- **probe accuracy**: byte-NLL argmin over the item's options, nine
+  suites × 30 items, holdout families d5 and sub3 gauged from time zero
+  (`probes.py:171-235`). At n = 30 a between-craft difference has SE
+  .126: the paired probe calls are ties.
+- **train/grad_norm**: the pre-clip global norm returned by
+  `clip_grad_norm_` (`trainer.py:244,287`), logged every 50 steps; under
+  Muon it measures sharpness, not the applied step.
+- **governor hits**: cumulative pair-pushes per session
+  (`trainer.py:266`); a session-scoped counter, comparable within one
+  event file only.
+
+## Known caveats and open items
+
+- The autocast einsum-promote trap voids every pre-0.7.2 splat speed
+  verdict (fp32 scans under "bf16"); accuracy verdicts stand. Any
+  autocast performance reading over einsum code is invalid until the
+  dtypes are printed (`attention.py:167`).
+- Muon is clip-blind (`optim.py:24`), and Adam's per-coordinate
+  normalisation makes it nearly so: `grad_clip 1.0` shrank the applied
+  step of neither group on the control, only the weighting of steps
+  inside each optimizer's buffers; the recipe carries no softmax
+  stabiliser.
+- The 2s `curriculum_s8_step53792` ledger is on the synthetic fallback
+  and is struck; the same-gauge pair is owed by a zero-training
+  re-evaluation of `resume/boundary_curriculum_s8_step53792.pt` on the
+  0.8.7 gauge (T0b in `history/plans/2026-09-04_sdpa_falsifier_screen.md`).
+  Hub-vs-journal note: the file on the hub reads doc_count 1612,
+  bpb_hub_off 6.2378 (toggle_hub_off 5.164), doc_bpb 0.843 — agreeing
+  with the trainer comment and the manual (doc_count 1612, hub_off 5.16 =
+  the toggle; `trainer.py:397-399`); the file carries no dataset field,
+  so the strike rests on the same-step cap discrepancy (doc_count 70,
+  bpb_full 1.1911 in `session_cap_step53792.json`) and on the 1612-document
+  count itself. The hub file's numbers win for what the file says.
+- The control's third host from 56,000: a replay of up to 999 steps is a
+  TB-cadence hedge, not a hub reading; no cap report; the 53,800–56,000 segment ran in the H100
+  session's own process (event file `0a706d592fec.620.1`); canon CB11/12 "on the H100" wrong by erratum.
+- Every resume refills the shuffle buffer (not row-exact); the control
+  resumed three times, the craft four; MixStream state carries no
+  recipe fingerprint.
+- The 2s preset at HEAD carries `head_addr_frozen = True`
+  (`presets.py:199-201`), the post-revival state: a fresh birth of the
+  treatment preset under 0.8.7 would freeze a random proj and codebook
+  from step 0, which is not what the shipped run did (born-null unfrozen
+  under 0.8.1 for 24,860 steps, revived, then frozen). The control's
+  override (`presets.py:235`) is the birth recipe.
+- Stale text, code wins: `presets.py:18` "~233M" (built 237,125,949);
+  `presets.py:14,166` "~873.7M" for mini-beatrix-2 (built 849,023,425);
+  the training README's ladder row "mini-beatrix-2 | 1024/20/2048 |
+  249.1M" is the retired v1 shape; the hub driver `beatrix_v2_colab.ipynb`
+  is headed "mini-beatrix-2 — the governed full-splat mission" and names
+  `mini-beatrix-2-control` while its CRAFT is `mini-beatrix-2s` (no
+  control notebook exists on the hub — only this file and
+  `mini-beatrix-1/beatrix_curriculum.ipynb`); `AlephLMConfig.hub_chunk` defaults to
+  128 while the module's own default is 256 (`presets.py:52`;
+  `attention.py:83`) — the config governs, and 2s sets 256.
+- `governor_hits_cum` resets per session; the manifests record no
+  train_config or package version — the mother null's "identical
+  TrainConfig" is a git fact, and the craft's birth version 0.8.1 is
+  inferred from commit dates (run1 created 08-27T00:35Z between 0.8.1
+  on 08-26 and 0.8.2 on 08-29; the revival report records 0.8.2; the hub
+  driver `beatrix_v2_colab.ipynb` pins `geolip-alephllm @2a902b7`, the
+  0.8.1 commit).
+- Owed instruments: the per-layer hidden-erank census of both crafts at
+  the full-scale boundaries; the falsifier S-1803-F (Tier 0 on the 4090;
+  a 40M twin screen with sdpa + QK-norm / LR/3 / dense-FFN / positions
+  on Adam arms; pivot = resume the control at 20,219 through s0 at LR/3
+  with QK-norm). Without it the general claim stays CANDIDATE.
+- `article_assets_ft2/make_charts_ft2.py` sources chart 01 from the hub
+  but charts 02–05 from local scratch paths, and chart 01 pairs the
+  struck s8 rows unless filtered.
+
+## Provenance discipline
+
+Both crafts are resume-first: the manifest is embedded in the resume
+payload (atomic consistency), a crash never overwrites
+`resume/latest.pt` (`trainer.py:334-368`: any exception other than a
+manual stop leaves the hub state untouched), an interrupted session
+uploads before exit, and every phase boundary archives its own
+immutable resume. The revival is auditable from the prefix alone: the
+pre-write state (`resume/pre_revival_step24860.pt`), the op's
+provenance (`reports/v2/revival_step24860.json`, with version and
+commit), the pre- and post-write weights (`step_00024860` and
+`step_00024860_revived`), and the first live row after it
+(`curriculum_s1_step25561.json`). The struck s8 ledger stays public
+beside the cap that supersedes it, as run0 stays public under
+`archive/`, for the same reason the mother's rewind checkpoints do. The
+recipe is pinned from source, not from the manifests. The AutoModel
+vendors the model files verbatim and ships the mission-final weights
+re-prefixed; the training checkpoints, not the card, are the control's
+weights. Every refuted arm of the head-cultivation screen ships.
+
+## Pointers
+
+- Canon: `canon/splat_aleph_battery.md` — CONTROL BOUNDARY 1–12
+  (522–889), ENDPOINT VERDICT (891), CLAIM AUDIT (901–1006: the s8
+  strike 930–937, MUON IS CLIP-BLIND 936, THE MOTHER NULL 955–968,
+  PROVENANCE RIDER 1008), ROUND 5a/5d/5e, B2/B4/B5.
+- Statutes (`STATUTES_INDEX.md`): S-701 a control must be able to fail;
+  S-801 supply law K ≤ 2D; S-1001 gate-zero deadlock; S-1002 born-null
+  head self-burial 3/3; S-1003 BOUNDARY-WRITE; S-1201 optimizer family;
+  S-1202 autocast einsum-promote; S-1801 the crossover; S-1802 the
+  destabilised control (INSTANCE); S-1803 sdpa-inadequacy (CANDIDATE);
+  S-1901 the specials plane.
+- Manual: `repos/alephllm.md` — the 0.7.0 era (1180–1330) and RIDERS
+  7–21b (1333–2081): pivot, launch health, specials and the run0
+  archive, driver contract, the dead head, the revival trial, the
+  boundary-write and promote, the head trend 14–14l, curriculum complete
+  and the s8 artifact, the pre-chat baseline, mission complete, the
+  ship-out, twin isolation, the pre-registered protocol.
+- Plans: `history/plans/2026-08-26_mini_beatrix_v2_shape.md` (the
+  shape arithmetic), `2026-08-26_mini_beatrix_2s_mission.md` (the pivot,
+  the anneal-timing ruling, the two-phase amendment),
+  `2026-08-24_covariant_address_program.md` (the governor),
+  `2026-09-02_sdpa_inadequacy_claim_held.md`,
+  `2026-09-04_sdpa_falsifier_screen.md`.
+- Dockets: `history/dockets/2026-09-04_sdpa_claim_audit/`,
+  `2026-09-01_ft2_article/` and `2026-09-01_article/tools/`
+  (`writeback_cb*.py`, `writeback_endpoint.py`).
+- Article: `articles/article_beatrix_ft2.md`; charts under
+  `article_assets_ft2/` on the training repo.
+- Code: AlephLLM HEAD 4f4b7d6 (0.8.7); the era's commits a63a29b
+  (0.7.0) · 2be28dd (0.7.2) · 60ee496 (0.7.3) · 73218bd (0.7.5, the
+  pivot) · 3ea3103 (0.8.0) · 2a902b7 (0.8.1) · d6e1854 (0.8.2) ·
+  7d48328 (0.8.5) · af9319c (0.8.6) · b472815 (0.8.7). No git tags
+  exist; versions are commit subjects.
+- The mother: `TECHNICAL.md` on the training repo (byte-identical local
+  copy `articles/TECHNICAL_training_repo_beatrix.md`).