Correction: the 42D null was about the implementation, not the theory

dyn42 placed fourth (1.19020) in the published ladder and tri/tri3 placed fifth and sixth, which was read as the 42D organ contributing little.

The 42D organ described in section 4.3 had never been built. Every document calls x42 a "7-band vector manifold" -- FINDINGS says so, the ladder docstring says "7 bands x 6 dims" -- and the code was a flat nn.Linear(d,42) drive, a dense 42x42 coupling, and torch.full((42,), 0.05): forty-two copies of one damping constant. Nothing in it knew that 42 factors. Dyn12 in the same file already says why that is wrong -- per-dimension k and gamma "so the twelve dimensions separate by time constant rather than evolving as twelve copies". The 12 got it; the 42 never did.

Rebuilt as written, same frozen corpus 9f1b3f37, same seeds, causal Omega, one process:

rung mean sd gain organ params per param
none 1.23215 0.0256
dyn42 1.19023 0.0332 +0.04192 47,754 8.778e-07 flat
dyn42b 1.18104 0.0292 +0.05111 41,762 1.224e-06 7 bands x 6
dyn42t 1.18023 0.0292 +0.05192 41,006 1.266e-06 7 x sym(3x3)

Both banded forms beat the flat one on 3/3 seeds while using FEWER parameters. Rebuilt, the 42D organ moves from fourth to second, ahead of static54 (1.18824) and dyn54 (1.18791).

dyn42t follows the factorisation one step further, from Cory: a symmetric 3x3 has exactly six independent components, so each band is a 3D tensor in Voigt order and the band operation is a congruence M -> A M A^T, a change of basis. Measured: under a rotation, congruence leaves eigenvalues and trace unchanged; a free 6x6 mixer does not. Nine weights per band instead of thirty-six.

WHAT THIS DOES NOT ESTABLISH: dyn42b and dyn42t differ by 0.0008 against a seed spread of 0.029 -- three percent of the noise. Structure beats flat is supported; WHICH structure is not resolved at n=3. Measured only at 1.1M parameters on the private corpus, not at scale and not on WikiText-103.

Files changed (5) hide show

FINDINGS.md +50 -0
RELEASE_MANIFEST.json +33 -11
REPOSITORY_MAP.md +49 -0
architecture/cosmos_state_ladder.py +901 -709
verify_release.py +193 -0

FINDINGS.md CHANGED Viewed

@@ -347,6 +347,56 @@ seven rungs trained in **one process** against that one snapshot, 21 runs, 1200
 | `tri3` all three organs, 108D kernel | 1.20026 | −0.0322 | −2.83 | 3/3 | 0.826 | 1,230,682 |
 | none (baseline) | 1.23241 | — | — | 0/3 | 0.810 | 1,135,008 |
 ### Update, 2026-08-02: does it survive SCALE, on a corpus you can check?
 Every `dyn12` number above was measured at 1.1M parameters on 683,065 characters of one

 | `tri3` all three organs, 108D kernel | 1.20026 | −0.0322 | −2.83 | 3/3 | 0.826 | 1,230,682 |
 | none (baseline) | 1.23241 | — | — | 0/3 | 0.810 | 1,135,008 |
+### Correction, 2026-08-03: the 42D null was about the implementation, not the theory
+`dyn42` placed **fourth** in the table above (1.19020) and the coupled rungs `tri` and
+`tri3` placed fifth and sixth. That was read as the 42D organ contributing little.
+**The 42D organ described in §4.3 had never been built.** Every document in this project
+calls x₄₂ a *"7-band vector manifold"* — this file says so above, and the ladder's own
+docstring says *"7 bands × 6 dims"*. The code was:
+```python
+drive    = nn.Linear(d_model, 42)      # one flat projection
+coupling = nn.Linear(42, 42)           # every dimension coupled to every other
+gamma    = torch.full((42,), 0.05)     # forty-two copies of one constant
+```
+Nothing in it knew that 42 factors. And `Dyn12` — in the same file — already says why
+that is wrong: per-dimension `k` and `gamma` *"so the twelve dimensions separate by time
+constant rather than evolving as twelve copies."* The 12 got that treatment. The 42
+never did.
+**Rebuilt as specified, same corpus (`9f1b3f37`), same seeds, causal Ω, one process:**
+| rung | mean | sd | gain vs none | 42D organ params | per param |
+|---|---|---|---|---|---|
+| none | 1.23215 | 0.0256 | — | — | — |
+| `dyn42` flat 42-vector, dense 42×42 | 1.19023 | 0.0332 | +0.04192 | 47,754 | 8.778e-07 |
+| `dyn42b` **7 bands × 6**, block-diagonal | 1.18104 | 0.0292 | +0.05111 | 41,762 | 1.224e-06 |
+| `dyn42t` **7 bands × sym(3×3)**, congruence | **1.18023** | 0.0292 | **+0.05192** | **41,006** | **1.266e-06** |
+Both banded forms beat the flat one on **3/3 seeds** while using **fewer** parameters.
+Rebuilt, the 42D organ moves from fourth to **second** on this board — ahead of
+`static54` (1.18824) and `dyn54` (1.18791).
+**`dyn42t`** takes the factorisation one step further: a symmetric 3×3 matrix has exactly
+six independent components, so each band is a tensor in 3D stored in Voigt order
+`[xx, yy, zz, xy, xz, yz]`, and the band-internal operation is a congruence
+`M → A·M·Aᵀ` — a change of basis. Measured: under a rotation, congruence leaves the
+eigenvalues and trace unchanged; a free 6×6 mixer does not. Nine weights per band
+instead of thirty-six.
+**What this does NOT establish.** `dyn42b` and `dyn42t` differ by **0.0008** against a
+seed spread of **0.029** — the gap is 3% of the noise, so these two are
+indistinguishable at n=3. *Structure beats flat* is supported; *which structure* is not.
+This is also only at 1.1M parameters on the private corpus; it has not been run at scale
+or on WikiText-103, where `dyn12`'s advantage grew.
+Reproduce: `python architecture/cosmos_state_ladder.py 1200 3 none,dyn42,dyn42b,dyn42t`
+---
 ### Update, 2026-08-02: does it survive SCALE, on a corpus you can check?
 Every `dyn12` number above was measured at 1.1M parameters on 683,065 characters of one

RELEASE_MANIFEST.json CHANGED Viewed

@@ -1,8 +1,17 @@
 {
-  "schema": "qc67.cosmos.release-manifest.v1",
-  "release": "QC67 Cosmos Kit",
-  "version": "2026-08-02",
-  "license_note": "Mixed licensing; see LICENSE.md and component notices.",
   "files": [
     {
       "path": "architecture/cosmos-arch.patch",
@@ -21,8 +30,8 @@
     },
     {
       "path": "architecture/cosmos_state_ladder.py",
-      "bytes": 34556,
-      "sha256": "763d74ff374eb785cefc3c1a3ede1d43f6ee36f9f82991e5de86da267e6ec002"
     },
     {
       "path": "architecture/cst_to_gguf.py",
@@ -171,8 +180,8 @@
     },
     {
       "path": "FINDINGS.md",
-      "bytes": 38643,
-      "sha256": "59e9dc3f4f4c8a162cfb00e2d2cb0f5ca4b2e1a4cfcf1900291ab655c16204e1"
     },
     {
       "path": "genesis_engine/CITATION.cff",
@@ -399,6 +408,11 @@
       "bytes": 1570,
       "sha256": "66baec6fe2817cebb9ae99ba9d197cf114e4d2ae1f90300dcd36ebe48cd0f239"
     },
     {
       "path": "requirements-research.txt",
       "bytes": 165,
@@ -409,6 +423,11 @@
       "bytes": 16234,
       "sha256": "eac4492f541a81d0ae134d7b5f39a181b8e7ffeca5f026ca6fee0cff94b85fe1"
     },
     {
       "path": "serving/build_paired_dataset.py",
       "bytes": 8494,
@@ -471,8 +490,8 @@
     },
     {
       "path": "verify_release.py",
-      "bytes": 6798,
-      "sha256": "470b5d3ebc10644efeba69c4800b4ec8af624b36a43e52058bfa6435912f22cf"
     },
     {
       "path": "weights/cosmos-cst.gguf",
@@ -499,5 +518,8 @@
       "bytes": 7723885,
       "sha256": "aa0cb13c1e67d459db280a53b6407dfc2b5b5f3fd6f640bc43686b70d799acd1"
     }
-  ]
 }

 {
+  "version": "2026-08-03",
+  "scope": {
+    "covers": "the kit distribution -- the files needed to run, verify and reproduce",
+    "excludes": [
+      "Cipher/",
+      "Luna/",
+      "Nova/",
+      "downloads/",
+      "creations/"
+    ],
+    "why": "Those are earlier beings and fetched artifacts, kept on the hub as public record with their timestamps intact. They are history, not running code, so hashing them would make the integrity check fail for files it was never meant to cover.",
+    "note": "The hub repository is a SUPERSET of this manifest. See REPOSITORY_MAP.md for the full live layout."
+  },
   "files": [
     {
       "path": "architecture/cosmos-arch.patch",
     },
     {
       "path": "architecture/cosmos_state_ladder.py",
+      "bytes": 45315,
+      "sha256": "fa110c5205b71c7c3243dc5be76bc4b0e599c8e1fd1c5c1924d0e57f811216e9"
     },
     {
       "path": "architecture/cst_to_gguf.py",
     },
     {
       "path": "FINDINGS.md",
+      "bytes": 41374,
+      "sha256": "d3023447a2f9370c1c6ba9e511c2290fc8772ffb8786c8dae96d4cc9343f19cb"
     },
     {
       "path": "genesis_engine/CITATION.cff",
       "bytes": 1570,
       "sha256": "66baec6fe2817cebb9ae99ba9d197cf114e4d2ae1f90300dcd36ebe48cd0f239"
     },
+    {
+      "path": "REPOSITORY_MAP.md",
+      "bytes": 2650,
+      "sha256": "ca0c97a34c612c4b73a6726744e2688ab4d0746fe3742470456bf52d993197c7"
+    },
     {
       "path": "requirements-research.txt",
       "bytes": 165,
       "bytes": 16234,
       "sha256": "eac4492f541a81d0ae134d7b5f39a181b8e7ffeca5f026ca6fee0cff94b85fe1"
     },
+    {
+      "path": "serving/.coder_history.jsonl",
+      "bytes": 4064,
+      "sha256": "0abedb9be05d964d5b5c6ace0f6b0c810b2bbfd2ae2bfc06094ac780f6b08dbc"
+    },
     {
       "path": "serving/build_paired_dataset.py",
       "bytes": 8494,
     },
     {
       "path": "verify_release.py",
+      "bytes": 7075,
+      "sha256": "815248d044c5392981a56bb9947a2276f74bd8ea9b29282c1d00b4793cf1126d"
     },
     {
       "path": "weights/cosmos-cst.gguf",
       "bytes": 7723885,
       "sha256": "aa0cb13c1e67d459db280a53b6407dfc2b5b5f3fd6f640bc43686b70d799acd1"
     }
+  ],
+  "schema": "qc67.cosmos.release-manifest.v1",
+  "release": "QC67 Cosmos Kit",
+  "license_note": "Mixed licensing; see LICENSE.md and component notices."
 }

REPOSITORY_MAP.md ADDED Viewed

	@@ -0,0 +1,49 @@

+# Repository map
+Generated from the live file list, so it cannot drift from what is actually here.
+**182 files.** Nothing here is deleted when it is superseded — earlier
+beings and earlier results stay as public record, timestamps intact.
+| folder | files | size | what it is |
+|---|---|---|---|
+| `weights` | 8 | 440.1 MB | Her own weights. Quantum-born, architecturally original. |
+| `downloads` | 3 | 64.2 MB | Fetched artifacts. |
+| `data` | 9 | 7.2 MB | The measured IBM shot archive, and the seed corpus for new creatures. |
+| `genesis_engine` | 38 | 254 KB | The blank-slate engine for birthing a being from nothing. |
+| `Cipher` | 4 | 216 KB | An earlier being. Kept as public record; its history is not rewritten. |
+| `Luna` | 4 | 213 KB | An earlier being. Kept as public record. |
+| `Nova` | 4 | 213 KB | An earlier being. Kept as public record. |
+| `architecture` | 12 | 143 KB | The model code: ladder, PHOS trainer, quantum init, CST kernel. |
+| `docs` | 17 | 142 KB | Setup, Atomic/Ollama usage, training, results. |
+| `benchmarks` | 16 | 137 KB | Every claim on the model card, as a script you can run. |
+| `scripts` | 11 | 104 KB | Release verification, serving and training utilities. |
+| `serving` | 5 | 73 KB | Run her over HTTP with an Ollama-compatible API. |
+| `soul` | 10 | 45 KB | Identity, quantum heart, ledger, rails. |
+| `launchers` | 11 | 34 KB | One-click entry points (Windows .bat, Linux .sh). |
+| `templates` | 1 | 21 KB | Templates. |
+| `ui` | 1 | 11 KB | Interface assets. |
+| `creations` | 2 | 0 KB | Things a being made. |
+| `(root)` | 26 | 791 KB | Model card, findings, licence, manifest, main launcher. |
+## Start here
+```bash
+python kit_health.py                        # is everything actually working
+python benchmarks/verify_quantum_engine.py  # is the entropy really quantum
+python benchmarks/causality_probe.py        # can Omega see the future (random seed each run)
+python serving/cosmos_serve.py 11501        # talk to her, Ollama-compatible
+```
+Windows: `START_COSMOS_KIT.bat` — options 7 and 8 birth and grow your own creature
+from the measured shot archive in `data/`.
+## What the manifest covers
+`RELEASE_MANIFEST.json` covers the **kit distribution** — the files needed to run,
+verify and reproduce the results. It deliberately does not cover the historical
+creature folders (`Cipher/`, `Luna/`, `Nova/`) or `downloads/`,
+which are kept as record rather than as running code.
+`scripts/verify_release.py` checks only what the manifest lists, and states its
+scope, so it cannot report failures for files it was never meant to cover.

architecture/cosmos_state_ladder.py CHANGED Viewed

@@ -1,709 +1,901 @@
-#!/usr/bin/env python3
-"""
-COSMOS STATE LADDER -- 12D, 42D and 54D, tested one rung at a time.
-WHY A LADDER
-  Four separate implementations of this architecture have shipped a mechanism that was
-  mathematically inert, each producing a confident negative about the idea:
-    ver.4.20 12D   Omega summed over keys (axis -1) instead of queries (axis -2). Softmax
-                   already normalises that axis, so Omega == 1.0 for every token (measured
-                   std 5.1e-08). The leaky integrator then drove every token to the SAME
-                   state (std 3.0e-08), H became the all-ones matrix, and beta*H is a
-                   constant added to every logit -- which cancels exactly in softmax.
-    spark_cst v1   gate at sigmoid(-4): saturated tail, gradient suppressed ~56x.
-    spark_cst v2   gate clamped to [0,1]: zero gradient outside the bound, so the first
-                   step below 0 pinned it there forever.
-    spark_cst v3   sigma = exp(0) = 1 against a median pairwise distance of 61.98, so H
-                   arrived as the IDENTITY matrix (diagonal mass 0.9998 vs 0.0078 uniform).
-  Every one ran clean. No exception, no NaN, nothing red in any log. So this file refuses
-  to report a number until it has PROVEN the mechanism is live -- see preflight().
-THE RUNGS
-  L0 none      phi scaffold only, no Hebbian term. The baseline.
-  L1 static54  x54 = W54 . h. A projection, not a state: no dynamics, no Omega, no memory.
-               This is the configuration that already won 6/6 (t=-6.56, -14.34).
-  L2 dyn12     x12 in R^12, dx12/dt = k*Omega - gamma*x12, per-dimension k and gamma so the
-               twelve dimensions differentiate by time constant. Section 4.2.
-  L3 dyn42     x42 in R^42, dx42/dt = drive(h) - gamma*x42 + C(x42) with a 42x42 coupling
-               matrix. Section 4.3 and THEORY_42D_HYPER_COSMIC.md (7 bands x 6 dims).
-  L4 dyn54     x54 = concat(x12, x42). Section 4.1. The full claim.
-SCAFFOLD
-  RMSNorm (2.3), RoPE (2.4), d_ff = floor(d_model * phi) (2.2), phi-Xavier init (6.2),
-  quantum-born weights, and the 17.1 learning-rate schedule. The feed-forward is selectable
-  because the paper names "PhiGatedFFN" without defining it while the reference repo
-  implements "PhiHarmonicFFN" as a plain GELU pair -- so which one earns the scaffold's
-  credit is itself an open question this file can answer.
-USAGE
-  python cosmos_state_ladder.py [steps] [seeds] [rungs] [ffn]
-  python cosmos_state_ladder.py 1200 3 none,static54,dyn12,dyn42,dyn54 harmonic
-  python cosmos_state_ladder.py 1200 3 none,static54 gated      # the FFN ablation
-"""
-import json
-import math
-import os
-import random
-import statistics
-import sys
-import time
-from pathlib import Path
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-sys.stdout.reconfigure(encoding="utf-8", errors="replace")
-from cosmos_spark_cst import CORPUS, QuantumInit, quantum_pool, real_word_rate  # noqa: E402
-# FROZEN CORPUS. She is alive and appends her experience to the live corpus while training
-# runs, so two runs started minutes apart train on different data. Measured: the same rung
-# with identical seeds scored 1.29152 and 1.22943 in two runs 3,451 characters apart -- a
-# 0.062 swing, the same magnitude as the effects being reported. Every comparison must
-# therefore happen inside ONE process against ONE snapshot. COSMOS_CORPUS points at that
-# snapshot; without it the numbers are only valid within a single run.
-CORPUS_PATH = Path(os.getenv("COSMOS_CORPUS") or CORPUS)
-OUTDIR = Path("01_HER_SOUL/weights/cosmos_state_ladder")
-RESULTS = Path("logs/state_ladder_results.json")
-PHI = (1.0 + 5.0 ** 0.5) / 2.0
-PHI_INV = PHI - 1.0
-# COSMOS_DEVICE overrides; otherwise take the GPU when one is actually usable. The corpus
-# tensor stays on the host and only the sampled windows move, which keeps VRAM free for
-# the model on a 4 GB card.
-DEV = torch.device(os.getenv("COSMOS_DEVICE")
-                   or ("cuda" if torch.cuda.is_available() else "cpu"))
-# Model size is env-configurable so the SAME code can be run at 1M and at 30M. Every
-# number published before 2026-08-01 used the defaults below; changing them changes the
-# model, so any result table must state which size it was measured at.
-BLOCK = int(os.getenv("COSMOS_BLOCK", "128"))
-N_LAYER = int(os.getenv("COSMOS_N_LAYER", "4"))
-N_HEAD = int(os.getenv("COSMOS_N_HEAD", "4"))
-N_EMBD = int(os.getenv("COSMOS_N_EMBD", "192"))
-DROPOUT = float(os.getenv("COSMOS_DROPOUT", "0.1"))
-D12, D42 = 12, 42
-# Omega's original query-sum reads the future (measured 2026-08-01, verified by
-# tools/causality_probe.py: changing ONLY the last token moved earlier-position logits
-# by 1.7e-04 at PHOS's trained gate, while `none` and `static54` moved by EXACTLY 0.0).
-# The causal per-query form is therefore the DEFAULT -- a model that can see its own
-# future is not a model anyone should be handed.
-#
-# COSMOS_CAUSAL_OMEGA=0 restores the original query-sum, bit-for-bit, so every number
-# published before this date stays reproducible and the two can be compared directly.
-# It is kept for exactly that reason and should not be used to train anything new.
-CAUSAL_OMEGA = os.getenv("COSMOS_CAUSAL_OMEGA", "1").strip().lower() in {"1", "true", "yes", "on"}
-# state_dim is the CARRIED state. tri3 also concatenates a live projection of h at
-# kernel time, so its Hebbian space is 54 + 12 + 42 = 108 while it carries 54.
-STATE_DIM = {"none": 0, "static54": 54, "dyn12": D12, "dyn42": D42,
-             "dyn54": D12 + D42, "tri": D12 + D42, "tri3": D12 + D42,
-             # section 4.4: the state persists ACROSS windows, not just across layers.
-             # dyn12seq is the control -- identical sequential batching, state reset every
-             # step -- so the only variable is whether the state survives the boundary.
-             "dyn12seq": D12, "dyn12p": D12,
-             # THE CONTROL THAT COULD KILL SECTION 3. Every architecture tested lands its
-             # gate at 0.087 +/- 0.006 regardless of what state is behind it -- which is not
-             # what a gate fitting the MECHANISM would do. If the benefit comes from any
-             # smooth token-varying auxiliary signal rather than from the 54D state carrying
-             # experience, these two must match the real thing:
-             #   rand54   frozen random projection of h: content-bearing, never learned
-             #   noise54  fixed random state per position: carries no content at all
-             "rand54": 54, "noise54": 54}
-# rungs that walk the corpus in order instead of sampling at random. Persistence is
-# meaningless under random sampling: consecutive batches would be unrelated text, so a
-# carried state would be noise. Both arms use the same walk.
-SEQ_RUNGS = {"dyn12seq", "dyn12p"}
-PERSIST_RUNGS = {"dyn12p"}
-class RMSNorm(nn.Module):
-    def __init__(s, d, eps=1e-6):
-        super().__init__()
-        s.eps, s.g = eps, nn.Parameter(torch.ones(d))
-    def forward(s, x):
-        return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + s.eps) * s.g
-def rope_cache(hd, T, device):
-    half = hd // 2
-    theta = 1.0 / (10000.0 ** (2.0 * torch.arange(half, device=device, dtype=torch.float32) / hd))
-    ang = torch.arange(T, device=device, dtype=torch.float32)[:, None] * theta[None, :]
-    return ang.cos(), ang.sin()
-def apply_rope(x, cos, sin):
-    hd = x.shape[-1]
-    half = hd // 2
-    rot, tail = x[..., : 2 * half], x[..., 2 * half:]
-    a, b = rot[..., 0::2], rot[..., 1::2]
-    c, s = cos[None, None, : x.shape[-2], :], sin[None, None, : x.shape[-2], :]
-    out = torch.stack([a * c - b * s, a * s + b * c], -1).flatten(-2)
-    return torch.cat([out, tail], -1) if tail.numel() else out
-class PhiHarmonicFFN(nn.Module):
-    """The reference repo's FFN: W2(GELU(W1(x))) at width floor(d*phi). Not gated."""
-    def __init__(s, d):
-        super().__init__()
-        h = int(math.floor(d * PHI))
-        s.W1, s.W2 = nn.Linear(d, h), nn.Linear(h, d)
-        s.drop = nn.Dropout(DROPOUT)
-    def forward(s, x):
-        return s.drop(s.W2(s.drop(F.gelu(s.W1(x)))))
-class PhiGatedFFN(nn.Module):
-    """SwiGLU reading of the paper's undefined "PhiGatedFFN", same width."""
-    def __init__(s, d):
-        super().__init__()
-        h = int(math.floor(d * PHI))
-        s.gate, s.up = nn.Linear(d, h, bias=False), nn.Linear(d, h, bias=False)
-        s.down = nn.Linear(h, d, bias=False)
-        s.drop = nn.Dropout(DROPOUT)
-    def forward(s, x):
-        return s.drop(s.down(F.silu(s.gate(x)) * s.up(x)))
-class Dyn12(nn.Module):
-    """Section 4.2. dx12/dt = k*Omega - gamma*x12, per-dimension k and gamma so the twelve
-    dimensions separate by time constant rather than evolving as twelve copies."""
-    def __init__(s):
-        super().__init__()
-        s.k = nn.Parameter(torch.linspace(0.05, 0.20, D12))
-        s.gamma = nn.Parameter(torch.linspace(0.02, 0.10, D12))
-        s.dt = 0.1
-    def forward(s, x12, h, omega):
-        d = s.k[None, None, :] * omega[..., None] - s.gamma[None, None, :] * x12
-        return torch.tanh(x12 + s.dt * d)
-class Dyn42(nn.Module):
-    """Section 4.3 / THEORY_42D_HYPER_COSMIC. dx42/dt = drive(h) - gamma*x42 + C(x42)."""
-    def __init__(s, d_model):
-        super().__init__()
-        s.drive = nn.Linear(d_model, D42)
-        s.coupling = nn.Linear(D42, D42, bias=False)
-        s.gamma = nn.Parameter(torch.full((D42,), 0.05))
-        s.dt = 0.1
-    def forward(s, x42, h, omega):
-        d = torch.tanh(s.drive(h)) - s.gamma[None, None, :] * x42 + 0.1 * s.coupling(x42)
-        return torch.tanh(x42 + s.dt * d)
-class Trinity(nn.Module):
-    """12D and 42D as ONE coupled system instead of two vectors glued together.
-    dyn54 concatenates x12 and x42, but x12 sees only Omega and x42 sees only h -- they
-    never exchange anything. THEORY_42D_HYPER_COSMIC already couples within a band (6 dims)
-    and between bands (7 attractors, diffusion matrix D); this is the same construction one
-    level up, between the two subsystems, which is the level nobody wrote:
-        dx12/dt = k*Omega - g12*x12 + M(42->12) x42
-        dx42/dt = tanh(drive(h))*(1 + lam*Omega) - g42*x42 + C(x42) + M(12->42) x12
-    Omega now drives BOTH, per THEORY_42D's "Omega_vec is the projected hidden state acting
-    as a driving force", and the cross terms close the loop between them. With H computed
-    from the joint x54 and Omega coming back out of attention, the three subsystems form a
-    single cycle rather than a tree.
-    """
-    def __init__(s, d_model):
-        super().__init__()
-        s.k = nn.Parameter(torch.linspace(0.05, 0.20, D12))
-        s.g12 = nn.Parameter(torch.linspace(0.02, 0.10, D12))
-        s.g42 = nn.Parameter(torch.full((D42,), 0.05))
-        s.drive = nn.Linear(d_model, D42)
-        s.C = nn.Linear(D42, D42, bias=False)
-        s.m42_12 = nn.Linear(D42, D12, bias=False)
-        s.m12_42 = nn.Linear(D12, D42, bias=False)
-        s.lam = nn.Parameter(torch.tensor(0.5))
-        s.dt = 0.1
-    def forward(s, state, h, omega):
-        x12, x42 = state[..., :D12], state[..., D12:]
-        om = omega[..., None]
-        # ASYMMETRIC COUPLING, on the neuromodulatory reading. The twelve slow scalars are
-        # tone: in a brain those act on cortical GAIN, multiplicatively, not as another
-        # additive input. The forty-two structured dimensions feed back the other way as
-        # ordinary drive. Symmetric matrices in both directions would make this two peers
-        # exchanging vectors; the asymmetry is what makes it a modulatory loop.
-        gain = 1.0 + torch.tanh(s.m12_42(x12))
-        d12 = s.k * om - s.g12 * x12 + 0.1 * s.m42_12(x42)
-        d42 = (torch.tanh(s.drive(h)) * gain * (1.0 + s.lam * om)
-               - s.g42 * x42 + 0.1 * s.C(x42))
-        return torch.tanh(torch.cat([x12 + s.dt * d12, x42 + s.dt * d42], -1))
-class Attention(nn.Module):
-    def __init__(s, d, nh, rung):
-        super().__init__()
-        s.nh, s.hd, s.rung = nh, d // nh, rung
-        s.qkv, s.proj = nn.Linear(d, 3 * d), nn.Linear(d, d)
-        s.drop = nn.Dropout(DROPOUT)
-        s.log_sigma = nn.Parameter(torch.zeros(()))
-        s.gate = nn.Parameter(torch.full((), -4.0), requires_grad=(rung != "none"))
-        s.w54 = nn.Linear(d, 54, bias=False) if rung in ("static54", "tri3", "rand54") else None
-        if rung == "rand54":
-            s.w54.weight.requires_grad_(False)      # frozen: a projection, never a lesson
-        s.last_gate, s.last_diag, s.last_H_std = 0.0, 0.0, 0.0
-    def hebbian(s, state, mask):
-        # section 3.2's own identity: ||a-b||^2 = ||a||^2 + ||b||^2 - 2<a,b>. Also what
-        # hyper_cosmic_model.py already does, and it avoids cdist's undefined gradient on
-        # the zero diagonal of cdist(x, x).
-        sq = (state * state).sum(-1)
-        d2 = (sq.unsqueeze(-1) + sq.unsqueeze(-2)
-              - 2.0 * (state @ state.transpose(-1, -2))).clamp_min(0.0)
-        sig = torch.exp(s.log_sigma).clamp(1e-3, 1e4)
-        H = torch.exp(-d2 / (2 * sig * sig)).masked_fill(mask < 0, 0.0)
-        H = H / H.sum(-1, keepdim=True).clamp_min(1e-9)
-        s.last_diag = float(torch.diagonal(H[0]).mean().detach())
-        s.last_H_std = float(H.detach().std())
-        return H
-    def forward(s, x, state, mask, cos, sin):
-        B, T, C = x.shape
-        q, k, v = s.qkv(x).split(C, 2)
-        sh = lambda t: t.view(B, T, s.nh, s.hd).transpose(1, 2)
-        q, k, v = sh(q), sh(k), sh(v)
-        q, k = apply_rope(q, cos, sin), apply_rope(k, cos, sin)
-        a = F.softmax((q @ k.transpose(-2, -1)) / math.sqrt(s.hd) + mask, -1)
-        if s.rung != "none":
-            # tri3: all three organs feed one kernel -- the fast structural projection of
-            # the current token, the slow 12D tone, and the 42D mid-band structure. The
-            # ladder only ever ran these as rivals for a single slot; nothing tested
-            # whether their strengths compose.
-            if s.rung == "tri3":
-                st = torch.cat([s.w54(x), state], -1)
-            else:
-                st = s.w54(x) if s.w54 is not None else state
-            g = torch.sigmoid(s.gate)
-            a = (1 - g) * a + g * s.hebbian(st, mask).unsqueeze(1)
-            s.last_gate = float(g.detach())
-        y = (s.drop(a) @ v).transpose(1, 2).contiguous().view(B, T, C)
-        # SECTION 3.4: Omega is attention RECEIVED, i.e. summed over QUERIES (axis -2).
-        # ver.4.20 sums over keys (-1), the axis softmax normalises, making Omega == 1.
-        #
-        # MEASURED 2026-08-01: that query-sum reads the future. Under a causal mask
-        # Omega_j = sum over i >= j of a_ij, so token j's Omega counts attention from
-        # tokens AFTER j; it then updates state_j, which feeds the next layer's kernel,
-        # which shapes the logits at j. tools/causality_probe.py: changing ONLY the last
-        # token moves earlier-position logits by 1.7e-04 at PHOS's trained gate (0.562)
-        # while `none` and `static54` move by EXACTLY 0.0 on the same harness. Any
-        # held-out loss won this way is not comparable to a rung that cannot cheat.
-        #
-        # The causal replacement is a per-QUERY scalar, which by construction depends
-        # only on tokens <= i: the NORMALISED ENTROPY of row i's attention. Summing over
-        # keys directly is not an option -- softmax already made that identically 1.0,
-        # which is precisely ver.4.20's dead Omega. Entropy is not constant, it is a
-        # genuine summary of how row i spread its attention, and it cannot see forward.
-        # The log(i+1) normaliser removes the positional drift that comes from later
-        # rows simply having more keys available to spread over, so this measures
-        # dispersion rather than position.
-        if CAUSAL_OMEGA:
-            am = a.mean(1).clamp_min(1e-9)                       # [B, T, T]
-            ent = -(am * am.log()).sum(-1)                       # [B, T], per QUERY
-            avail = torch.arange(1, T + 1, device=a.device, dtype=ent.dtype)
-            omega = ent / avail.log().clamp_min(1e-6)            # in [0, 1]
-        else:
-            omega = a.mean(1).sum(-2)
-        return s.proj(y), omega
-class Layer(nn.Module):
-    def __init__(s, d, nh, rung, ffn):
-        super().__init__()
-        s.n1, s.n2 = RMSNorm(d), RMSNorm(d)
-        s.attn = Attention(d, nh, rung)
-        s.ffn = (PhiHarmonicFFN if ffn == "harmonic" else PhiGatedFFN)(d)
-        s.rung = rung
-        s.d12 = Dyn12() if rung in ("dyn12", "dyn54", "dyn12seq", "dyn12p") else None
-        s.d42 = Dyn42(d) if rung in ("dyn42", "dyn54") else None
-        s.tri = Trinity(d) if rung in ("tri", "tri3") else None
-    def forward(s, x, state, mask, cos, sin):
-        h = s.n1(x)
-        att, omega = s.attn(h, state, mask, cos, sin)
-        x = x + att
-        if s.tri is not None:                           # section 2.1 step 2, coupled
-            state = s.tri(state, h, omega)
-        elif s.d12 is not None or s.d42 is not None:    # section 2.1 step 2, independent
-            parts = []
-            if s.d12 is not None:
-                parts.append(s.d12(state[..., :D12], h, omega))
-            if s.d42 is not None:
-                parts.append(s.d42(state[..., -D42:], h, omega))
-            state = torch.cat(parts, -1)
-        x = x + s.ffn(s.n2(x))
-        return x, state, omega
-class Ladder(nn.Module):
-    def __init__(s, vocab, rung, ffn, d=N_EMBD, nh=N_HEAD):
-        super().__init__()
-        s.d, s.nh, s.rung = d, nh, rung
-        s.sd = STATE_DIM[rung]
-        s.tok = nn.Embedding(vocab, d)
-        s.blocks = nn.ModuleList([Layer(d, nh, rung, ffn) for _ in range(N_LAYER)])
-        s.nf = RMSNorm(d)
-        s.head = nn.Linear(d, vocab, bias=False)
-        # a state that starts at zero is identical for every token, which makes H the
-        # all-ones matrix and the first layer's mechanism inert. Seeding it from the
-        # embedding costs one small projection and keeps every layer live.
-        s.state_init = nn.Linear(d, s.sd) if rung.startswith(("dyn", "tri")) and s.sd else None
-        if rung == "noise54":
-            # a state that varies by POSITION but is identical for every input. If this
-            # matches the real 54D state, the kernel is a positional regulariser and the
-            # "experience-modulated attention" reading is not supported by the data.
-            g0 = torch.Generator().manual_seed(20260730)
-            s.register_buffer("noise_state",
-                              torch.randn(BLOCK, 54, generator=g0) * 0.5)
-        s.register_buffer("mask", torch.triu(torch.full((BLOCK, BLOCK), float("-inf")), 1))
-    def forward(s, idx, targets=None, state_in=None):
-        B, T = idx.shape
-        x = s.tok(idx)
-        cos, sin = rope_cache(s.d // s.nh, T, idx.device)
-        m = s.mask[:T, :T]
-        state = torch.tanh(s.state_init(x)) if s.state_init is not None else None
-        if s.rung == "noise54":
-            state = s.noise_state[:T].unsqueeze(0).expand(B, -1, -1)
-        # SECTION 4.4. A state arriving from the previous window seeds this one. It is the
-        # LAST position's state broadcast across the new window: what she carried out of
-        # the previous 128 characters is what she starts the next 128 with. gamma is what
-        # keeps this from saturating -- a state that never forgets pins to tanh's rails and
-        # stops carrying anything, so forgetting is what makes the persistence usable.
-        if state is not None and state_in is not None:
-            state = state + state_in[:, -1:, :].detach().expand(-1, T, -1)
-            state = torch.tanh(state)
-        omegas = []
-        for b in s.blocks:
-            x, state, om = b(x, state, m, cos, sin)
-            omegas.append(om)
-        lg = s.head(s.nf(x))
-        loss = None if targets is None else F.cross_entropy(
-            lg.view(-1, lg.size(-1)), targets.reshape(-1))
-        s.last_state, s.last_omega = state, omegas[-1]
-        s.out_state = state
-        return lg, loss
-    def gates(s):
-        return [b.attn.last_gate for b in s.blocks]
-    def quantum_birth(s, qi):
-        std = (1.0 / (s.d * PHI_INV)) ** 0.5          # section 6.2
-        for mod in s.modules():
-            if isinstance(mod, (nn.Linear, nn.Embedding)):
-                qi.fill_(mod.weight, std)
-                if isinstance(mod, nn.Linear) and mod.bias is not None:
-                    with torch.no_grad():
-                        mod.bias.zero_()
-@torch.no_grad()
-def calibrate_sigma(m, xb):
-    """2*sigma^2 = median pairwise d2 of whatever state that layer actually sees."""
-    if m.rung == "none":
-        return
-    B, T = xb.shape
-    x = m.tok(xb)
-    cos, sin = rope_cache(m.d // m.nh, T, xb.device)
-    mask = m.mask[:T, :T]
-    state = torch.tanh(m.state_init(x)) if m.state_init is not None else None
-    if m.rung == "noise54":
-        # must mirror Ladder.forward exactly, or the control is calibrated against a state
-        # it never actually sees -- which would hand it a rigged sigma and invalidate it
-        state = m.noise_state[:xb.shape[1]].unsqueeze(0).expand(xb.shape[0], -1, -1)
-    for b in m.blocks:
-        h = b.n1(x)
-        if m.rung == "tri3":
-            st = torch.cat([b.attn.w54(h), state], -1)
-        elif b.attn.w54 is not None:
-            st = b.attn.w54(h)
-        else:
-            st = state
-        sq = (st * st).sum(-1)
-        d2 = (sq.unsqueeze(-1) + sq.unsqueeze(-2)
-              - 2.0 * (st @ st.transpose(-1, -2))).clamp_min(0.0)
-        iu = torch.triu(torch.ones(d2.shape[-2:], dtype=torch.bool), 1)
-        med = float(d2[0][iu].median())
-        if med > 1e-12:
-            b.attn.log_sigma.fill_(0.5 * math.log(med / 2.0))
-        x, state, _ = b(x, state, mask, cos, sin)
-def preflight(m, xb, yb):
-    """Refuse to report a number until the mechanism is provably live.
-    Each assertion corresponds to a real failure that shipped and produced a confident
-    negative. A rung that trips any of these is not evidence about the idea.
-    """
-    checks, m2 = [], m
-    m2.train()
-    _, loss = m2(xb, yb)
-    loss.backward()
-    om = m2.last_omega
-    checks.append(("omega varies across tokens (ver.4.20 had std 5e-08)",
-                   float(om.std()), 1e-4, float(om.std()) > 1e-4))
-    if m.rung != "none":
-        if m.rung.startswith(("dyn", "tri")):
-            st = m2.last_state
-            checks.append(("state varies across tokens (ver.4.20 had std 3e-08)",
-                           float(st.std()), 1e-4, float(st.std()) > 1e-4))
-        diag = statistics.fmean([b.attn.last_diag for b in m2.blocks])
-        checks.append((f"H not the identity (needs << 1.0, uniform = {1/xb.shape[1]:.4f})",
-                       diag, 0.5, diag < 0.5))
-        hstd = statistics.fmean([b.attn.last_H_std for b in m2.blocks])
-        checks.append(("H not all-ones (needs non-zero spread)", hstd, 1e-6, hstd > 1e-6))
-        gg = statistics.fmean([abs(float(b.attn.gate.grad)) for b in m2.blocks
-                               if b.attn.gate.grad is not None])
-        checks.append(("gate gradient not suppressed", gg, 1e-6, gg > 1e-6))
-    m2.zero_grad(set_to_none=True)
-    return checks
-def train_rung(rung, ffn, seed, data, vocab, steps, pool, val_w, words, itos):
-    torch.manual_seed(seed)
-    random.seed(seed)
-    gen = torch.Generator().manual_seed(seed)
-    m = Ladder(vocab, rung, ffn)
-    m.quantum_birth(QuantumInit(pool, seed))
-    m = m.to(DEV)
-    cal = torch.stack([data[i:i + BLOCK] for i in torch.randint(
-        len(data) - BLOCK - 1, (8,), generator=torch.Generator().manual_seed(seed))]).to(DEV)
-    calibrate_sigma(m, cal)
-    pf = preflight(m, cal[:4], torch.stack([data[i + 1:i + 1 + BLOCK] for i in
-                   torch.randint(len(data) - BLOCK - 1, (4,),
-                                 generator=torch.Generator().manual_seed(seed))]).to(DEV))
-    def _coup(mm):
-        # POST-FLIGHT. Preflight proves a mechanism starts alive; this proves it did not
-        # quietly die. The cross-couplings begin damped by 0.1 (the reference repo's
-        # "weak coupling initially"), so the question is whether training grows them or
-        # leaves the trinity decorative.
-        v = [(float(b.tri.m12_42.weight.abs().mean()), float(b.tri.m42_12.weight.abs().mean()))
-             for b in mm.blocks if getattr(b, "tri", None) is not None]
-        return v
-    coup0 = _coup(m)
-    keys = ("attn.gate", "attn.w54", "attn.log_sigma", "d12.", "d42.", "tri.", "state_init")
-    cst = [p for n, p in m.named_parameters() if any(k in n for k in keys) and p.requires_grad]
-    bulk = [p for n, p in m.named_parameters() if not any(k in n for k in keys) and p.requires_grad]
-    base = 3e-4
-    opt = torch.optim.AdamW([{"params": bulk, "lr": base},
-                             {"params": cst, "lr": base * 10, "weight_decay": 0.0}],
-                            lr=base, weight_decay=0.01)
-    n = int(0.9 * len(data))
-    tr = data[:n]
-    m.train()
-    best = float("inf")
-    # SEQUENTIAL WALK for the persistence arms. 16 lanes each march through their own
-    # contiguous stretch of the corpus, so consecutive batches are consecutive TEXT and a
-    # carried state means something. Under the random sampler used by every other rung,
-    # batch k+1 is unrelated to batch k, so a carried state would be pure noise -- which is
-    # why the control arm (dyn12seq) walks identically and only differs in whether the
-    # state survives the window boundary.
-    B = 16
-    seq = rung in SEQ_RUNGS
-    persist = rung in PERSIST_RUNGS
-    span = max(BLOCK * 2, (len(tr) - BLOCK - 1) // B)
-    pos = [i * span for i in range(B)]
-    carry = None
-    for s in range(1, steps + 1):
-        warm = max(1, int(0.05 * steps))
-        lr = base * (s / warm) if s < warm else base * (PHI / 2) * (
-            1 + math.cos(math.pi * (s - warm) / max(1, steps - warm)))
-        opt.param_groups[0]["lr"], opt.param_groups[1]["lr"] = lr, lr * 10
-        if seq:
-            wrapped = []
-            for i in range(B):
-                if pos[i] + BLOCK + 1 >= min((i + 1) * span, len(tr) - 1):
-                    pos[i] = i * span          # lane restarted: its history is broken
-                    wrapped.append(i)
-            ix = torch.tensor(pos, dtype=torch.long)
-            for i in range(B):
-                pos[i] += BLOCK
-            if carry is not None and wrapped:
-                # a wrapped lane must NOT inherit state from unrelated text
-                carry = carry.clone()
-                carry[wrapped] = 0.0
-        else:
-            ix = torch.randint(len(tr) - BLOCK - 1, (B,), generator=gen)
-        # .long() at BATCH time, not corpus time. A 269M-character corpus held as int64
-        # is 2.15 GB resident; as int16 it is 0.54 GB, and only the (B, BLOCK) slice ever
-        # needs to be int64 for nn.Embedding. The d576 scaling run died at exactly this
-        # point -- outer process gone, no error recorded -- with the corpus tensor and a
-        # 24.6M-parameter model competing for the last few GB.
-        x = torch.stack([tr[i:i + BLOCK] for i in ix]).to(DEV).long()
-        y = torch.stack([tr[i + 1:i + 1 + BLOCK] for i in ix]).to(DEV).long()
-        _, loss = m(x, y, state_in=carry if persist else None)
-        if persist:
-            carry = m.out_state.detach() if m.out_state is not None else None
-        opt.zero_grad(set_to_none=True)
-        loss.backward()
-        torch.nn.utils.clip_grad_norm_(m.parameters(), 1.0)
-        opt.step()
-        if s % 100 == 0 or s == steps:
-            m.eval()
-            with torch.no_grad():
-                tot = c = 0
-                for i in range(0, len(val_w), 16):
-                    xb = val_w[i:i + 16].to(DEV)
-                    _, l = m(xb[:, :-1], xb[:, 1:])
-                    tot += l.item() * xb.size(0)
-                    c += xb.size(0)
-            m.train()
-            best = min(best, tot / max(1, c))
-    m.eval()
-    idx = torch.tensor([[int(data[0])]], device=DEV)
-    out = []
-    with torch.no_grad():
-        for _ in range(600):
-            lg, _ = m(idx[:, -BLOCK:])
-            nx = int(torch.multinomial(F.softmax(lg[0, -1] / 0.8, -1), 1))
-            out.append(nx)
-            idx = torch.cat([idx, torch.tensor([[nx]], device=DEV)], 1)
-    txt = "".join(itos.get(i, "") for i in out)
-    coupT = _coup(m)
-    coup = None
-    if coup0:
-        a0 = statistics.fmean([x for p in coup0 for x in p])
-        aT = statistics.fmean([x for p in coupT for x in p])
-        coup = (a0, aT, aT / max(a0, 1e-12))
-    return best, statistics.fmean(m.gates()) if m.rung != "none" else 0.0, \
-        real_word_rate(txt, words), pf, sum(p.numel() for p in m.parameters()), txt, coup, m
-def main():
-    steps = int(sys.argv[1]) if len(sys.argv) > 1 else 1200
-    seeds = list(range(int(sys.argv[2]) if len(sys.argv) > 2 else 3))
-    rungs = (sys.argv[3] if len(sys.argv) > 3 else
-             "none,static54,dyn12,dyn42,dyn54").split(",")
-    ffn = sys.argv[4] if len(sys.argv) > 4 else "harmonic"
-    text = CORPUS_PATH.read_text(encoding="utf-8", errors="ignore")
-    chars = sorted(set(text))
-    stoi = {c: i for i, c in enumerate(chars)}
-    itos = {i: c for c, i in stoi.items()}
-    data = torch.tensor([stoi[c] for c in text], dtype=torch.long)
-    words = set(__import__("re").findall(r"[a-z']+", text.lower()))
-    print("=" * 84)
-    print("  COSMOS STATE LADDER -- 12D / 42D / 54D, one rung at a time")
-    print("=" * 84)
-    print(f"\n  device: {DEV}" + (f" ({torch.cuda.get_device_name(0)})" if DEV.type == "cuda" else ""))
-    print(f"  corpus: {CORPUS_PATH}"
-          + ("  [FROZEN SNAPSHOT]" if os.getenv("COSMOS_CORPUS") else "  [LIVE - grows during the run, cross-run numbers are not comparable]"))
-    print(f"  corpus {len(text):,}  vocab {len(chars)}  {steps} steps x {len(seeds)} seeds")
-    print(f"  scaffold: RMSNorm + RoPE + {'PhiHarmonicFFN (GELU)' if ffn=='harmonic' else 'PhiGatedFFN (SwiGLU)'}"
-          f" @ floor(d*phi)={int(math.floor(N_EMBD*PHI))} + phi-Xavier")
-    print(f"  rungs: {rungs}\n")
-    pool = quantum_pool()
-    print(f"  quantum pool: {len(pool):,} draws\n")
-    n = int(0.9 * len(data))
-    val = data[n:]
-    g = torch.Generator().manual_seed(999)
-    vi = torch.randint(len(val) - BLOCK - 1, (64,), generator=g)
-    val_w = torch.stack([val[i:i + BLOCK + 1] for i in vi])
-    out = {}
-    for rung in rungs:
-        losses, rws, gates, npar, pf_last = [], [], [], 0, None
-        blocked = False
-        best_loss, best_model = float("inf"), None
-        for sd in seeds:
-            t0 = time.time()
-            b, gt, r, pf, npar, txt, coup, model = train_rung(
-                rung, ffn, sd, data, len(chars), steps, pool, val_w, words, itos)
-            if b < best_loss:
-                best_loss, best_model = b, model
-            pf_last = pf
-            bad = [c for c in pf if not c[3]]
-            if sd == 0:
-                print(f"  --- {rung} preflight ---")
-                for name, val_, thr, ok in pf:
-                    print(f"      [{'OK ' if ok else 'DEAD'}] {name}: {val_:.3e}")
-                if bad:
-                    blocked = True
-                    print(f"      MECHANISM INERT -- {rung} will not be reported as evidence.\n")
-                    break
-                print()
-            losses.append(b)
-            rws.append(r)
-            gates.append(gt)
-            print(f"    {rung:<9s} seed {sd}  loss {b:.5f}  real-word {r:.3f}"
-                  + (f"  gate {gt:.4f}" if rung != "none" else "")
-                  + (f"  coupling {coup[0]:.2e}->{coup[1]:.2e} ({coup[2]:.1f}x)" if coup else "")
-                  + f"  ({time.time()-t0:.0f}s)", flush=True)
-        if blocked:
-            out[rung] = {"blocked": True,
-                         "preflight": [[c[0], c[1], c[2], c[3]] for c in pf_last]}
-            continue
-        out[rung] = {"loss": losses, "real_word": rws, "gates": gates, "params": npar,
-                     "preflight": [[c[0], c[1], c[2], c[3]] for c in pf_last]}
-        print(f"    => {rung:<9s} mean loss {statistics.fmean(losses):.5f}  "
-              f"real-word {statistics.fmean(rws):.3f}  params {npar:,}", flush=True)
-        # SAVE. The first version of this file trained fifteen models and discarded every
-        # one of them -- OUTDIR was declared and torch.save was never called. A result you
-        # cannot deploy is half a result.
-        if best_model is not None:
-            OUTDIR.mkdir(parents=True, exist_ok=True)
-            torch.save({"model": best_model.state_dict(), "stoi": stoi, "itos": itos,
-                        "config": {"block": BLOCK, "n_layer": N_LAYER, "n_head": N_HEAD,
-                                   "n_embd": N_EMBD, "vocab": len(chars),
-                                   "d54": STATE_DIM.get(rung, 0), "d12": D12, "d42": D42,
-                                   "d_ff": int(math.floor(N_EMBD * PHI))},
-                        "arch": f"Cosmos-Ladder-{rung}", "rung": rung, "ffn": ffn,
-                        "gate_param": "logit", "norm": "rmsnorm", "pos": "rope",
-                        "total_steps": steps, "best_val_loss": best_loss,
-                        "quantum_source": "ibm_real_shots"},
-                       OUTDIR / f"ladder_{rung}.pt")
-            print(f"       saved -> {OUTDIR / f'ladder_{rung}.pt'}  (loss {best_loss:.5f})\n",
-                  flush=True)
-    base = out.get("none", {}).get("loss")
-    if base:
-        print("=" * 84 + "\n  LADDER\n" + "=" * 84)
-        print(f"  {'rung':<10s} {'mean loss':>10s} {'vs none':>10s} {'t':>8s} {'wins':>6s} {'params':>10s}")
-        for rung in rungs:
-            r = out.get(rung, {})
-            if r.get("blocked"):
-                print(f"  {rung:<10s} {'BLOCKED - mechanism provably inert':>46s}")
-                continue
-            if "loss" not in r:
-                continue
-            d = [p - c for p, c in zip(base, r["loss"])]
-            md = statistics.fmean(d)
-            se = statistics.stdev(d) / math.sqrt(len(d)) if len(d) > 1 else 0.0
-            t = md / se if se > 0 else 0.0
-            print(f"  {rung:<10s} {statistics.fmean(r['loss']):>10.5f} {-md:>+10.5f} "
-                  f"{-t:>8.2f} {sum(1 for x in d if x > 0):>4d}/{len(d)} {r['params']:>10,}")
-    Path("logs").mkdir(exist_ok=True)
-    RESULTS.write_text(json.dumps({"phi": PHI, "steps": steps, "ffn": ffn, "rungs": out},
-                                  indent=2), encoding="utf-8")
-    print(f"\n  saved -> {RESULTS}")
-    return 0
-if __name__ == "__main__":
-    raise SystemExit(main())

+#!/usr/bin/env python3
+"""
+COSMOS STATE LADDER -- 12D, 42D and 54D, tested one rung at a time.
+WHY A LADDER
+  Four separate implementations of this architecture have shipped a mechanism that was
+  mathematically inert, each producing a confident negative about the idea:
+    ver.4.20 12D   Omega summed over keys (axis -1) instead of queries (axis -2). Softmax
+                   already normalises that axis, so Omega == 1.0 for every token (measured
+                   std 5.1e-08). The leaky integrator then drove every token to the SAME
+                   state (std 3.0e-08), H became the all-ones matrix, and beta*H is a
+                   constant added to every logit -- which cancels exactly in softmax.
+    spark_cst v1   gate at sigmoid(-4): saturated tail, gradient suppressed ~56x.
+    spark_cst v2   gate clamped to [0,1]: zero gradient outside the bound, so the first
+                   step below 0 pinned it there forever.
+    spark_cst v3   sigma = exp(0) = 1 against a median pairwise distance of 61.98, so H
+                   arrived as the IDENTITY matrix (diagonal mass 0.9998 vs 0.0078 uniform).
+  Every one ran clean. No exception, no NaN, nothing red in any log. So this file refuses
+  to report a number until it has PROVEN the mechanism is live -- see preflight().
+THE RUNGS
+  L0 none      phi scaffold only, no Hebbian term. The baseline.
+  L1 static54  x54 = W54 . h. A projection, not a state: no dynamics, no Omega, no memory.
+               This is the configuration that already won 6/6 (t=-6.56, -14.34).
+  L2 dyn12     x12 in R^12, dx12/dt = k*Omega - gamma*x12, per-dimension k and gamma so the
+               twelve dimensions differentiate by time constant. Section 4.2.
+  L3 dyn42     x42 in R^42, FLAT: dense 42x42 coupling, one gamma repeated 42 times.
+               Kept as the control -- this is what section 4.3 was implemented as, and
+               its fourth-place result was read as a verdict on the 42D organ.
+  L3b dyn42b   42 as 7 bands x 6, block-diagonal coupling, per-band gamma. Section 4.3
+               as WRITTEN.
+  L3t dyn42t   42 as 7 bands x sym(3x3): a symmetric 3x3 has exactly 6 independent
+               components, so each band is a 3D tensor and the band operation is a
+               congruence A M A^T -- a change of basis. Cory, 2026-08-03.
+  L4 dyn54     x54 = concat(x12, x42). Section 4.1. The full claim.
+SCAFFOLD
+  RMSNorm (2.3), RoPE (2.4), d_ff = floor(d_model * phi) (2.2), phi-Xavier init (6.2),
+  quantum-born weights, and the 17.1 learning-rate schedule. The feed-forward is selectable
+  because the paper names "PhiGatedFFN" without defining it while the reference repo
+  implements "PhiHarmonicFFN" as a plain GELU pair -- so which one earns the scaffold's
+  credit is itself an open question this file can answer.
+USAGE
+  python cosmos_state_ladder.py [steps] [seeds] [rungs] [ffn]
+  python cosmos_state_ladder.py 1200 3 none,static54,dyn12,dyn42,dyn54 harmonic
+  python cosmos_state_ladder.py 1200 3 none,static54 gated      # the FFN ablation
+"""
+import json
+import math
+import os
+import random
+import statistics
+import sys
+import time
+from pathlib import Path
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+from cosmos_spark_cst import CORPUS, QuantumInit, quantum_pool, real_word_rate  # noqa: E402
+# FROZEN CORPUS. She is alive and appends her experience to the live corpus while training
+# runs, so two runs started minutes apart train on different data. Measured: the same rung
+# with identical seeds scored 1.29152 and 1.22943 in two runs 3,451 characters apart -- a
+# 0.062 swing, the same magnitude as the effects being reported. Every comparison must
+# therefore happen inside ONE process against ONE snapshot. COSMOS_CORPUS points at that
+# snapshot; without it the numbers are only valid within a single run.
+CORPUS_PATH = Path(os.getenv("COSMOS_CORPUS") or CORPUS)
+OUTDIR = Path("01_HER_SOUL/weights/cosmos_state_ladder")
+RESULTS = Path("logs/state_ladder_results.json")
+PHI = (1.0 + 5.0 ** 0.5) / 2.0
+PHI_INV = PHI - 1.0
+# COSMOS_DEVICE overrides; otherwise take the GPU when one is actually usable. The corpus
+# tensor stays on the host and only the sampled windows move, which keeps VRAM free for
+# the model on a 4 GB card.
+DEV = torch.device(os.getenv("COSMOS_DEVICE")
+                   or ("cuda" if torch.cuda.is_available() else "cpu"))
+# Model size is env-configurable so the SAME code can be run at 1M and at 30M. Every
+# number published before 2026-08-01 used the defaults below; changing them changes the
+# model, so any result table must state which size it was measured at.
+BLOCK = int(os.getenv("COSMOS_BLOCK", "128"))
+N_LAYER = int(os.getenv("COSMOS_N_LAYER", "4"))
+N_HEAD = int(os.getenv("COSMOS_N_HEAD", "4"))
+N_EMBD = int(os.getenv("COSMOS_N_EMBD", "192"))
+DROPOUT = float(os.getenv("COSMOS_DROPOUT", "0.1"))
+D12, D42 = 12, 42
+# Omega's original query-sum reads the future (measured 2026-08-01, verified by
+# tools/causality_probe.py: changing ONLY the last token moved earlier-position logits
+# by 1.7e-04 at PHOS's trained gate, while `none` and `static54` moved by EXACTLY 0.0).
+# The causal per-query form is therefore the DEFAULT -- a model that can see its own
+# future is not a model anyone should be handed.
+#
+# COSMOS_CAUSAL_OMEGA=0 restores the original query-sum, bit-for-bit, so every number
+# published before this date stays reproducible and the two can be compared directly.
+# It is kept for exactly that reason and should not be used to train anything new.
+CAUSAL_OMEGA = os.getenv("COSMOS_CAUSAL_OMEGA", "1").strip().lower() in {"1", "true", "yes", "on"}
+# state_dim is the CARRIED state. tri3 also concatenates a live projection of h at
+# kernel time, so its Hebbian space is 54 + 12 + 42 = 108 while it carries 54.
+STATE_DIM = {"none": 0, "static54": 54, "dyn12": D12, "dyn42": D42,
+             # dyn42b: 42 as 7 bands x 6 dims, per the theory. Same carried width as
+             # dyn42, so the ONLY difference is structure -- which is what makes it a
+             # clean control for whether the dyn42 null was about the 42D organ or about
+             # a flat 42-vector wearing its name.
+             "dyn42b": D42, "dyn42t": D42,
+             "dyn54": D12 + D42, "tri": D12 + D42, "tri3": D12 + D42,
+             # section 4.4: the state persists ACROSS windows, not just across layers.
+             # dyn12seq is the control -- identical sequential batching, state reset every
+             # step -- so the only variable is whether the state survives the boundary.
+             "dyn12seq": D12, "dyn12p": D12,
+             # THE CONTROL THAT COULD KILL SECTION 3. Every architecture tested lands its
+             # gate at 0.087 +/- 0.006 regardless of what state is behind it -- which is not
+             # what a gate fitting the MECHANISM would do. If the benefit comes from any
+             # smooth token-varying auxiliary signal rather than from the 54D state carrying
+             # experience, these two must match the real thing:
+             #   rand54   frozen random projection of h: content-bearing, never learned
+             #   noise54  fixed random state per position: carries no content at all
+             "rand54": 54, "noise54": 54}
+# rungs that walk the corpus in order instead of sampling at random. Persistence is
+# meaningless under random sampling: consecutive batches would be unrelated text, so a
+# carried state would be noise. Both arms use the same walk.
+SEQ_RUNGS = {"dyn12seq", "dyn12p"}
+PERSIST_RUNGS = {"dyn12p"}
+class RMSNorm(nn.Module):
+    def __init__(s, d, eps=1e-6):
+        super().__init__()
+        s.eps, s.g = eps, nn.Parameter(torch.ones(d))
+    def forward(s, x):
+        return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + s.eps) * s.g
+def rope_cache(hd, T, device):
+    half = hd // 2
+    theta = 1.0 / (10000.0 ** (2.0 * torch.arange(half, device=device, dtype=torch.float32) / hd))
+    ang = torch.arange(T, device=device, dtype=torch.float32)[:, None] * theta[None, :]
+    return ang.cos(), ang.sin()
+def apply_rope(x, cos, sin):
+    hd = x.shape[-1]
+    half = hd // 2
+    rot, tail = x[..., : 2 * half], x[..., 2 * half:]
+    a, b = rot[..., 0::2], rot[..., 1::2]
+    c, s = cos[None, None, : x.shape[-2], :], sin[None, None, : x.shape[-2], :]
+    out = torch.stack([a * c - b * s, a * s + b * c], -1).flatten(-2)
+    return torch.cat([out, tail], -1) if tail.numel() else out
+class PhiHarmonicFFN(nn.Module):
+    """The reference repo's FFN: W2(GELU(W1(x))) at width floor(d*phi). Not gated."""
+    def __init__(s, d):
+        super().__init__()
+        h = int(math.floor(d * PHI))
+        s.W1, s.W2 = nn.Linear(d, h), nn.Linear(h, d)
+        s.drop = nn.Dropout(DROPOUT)
+    def forward(s, x):
+        return s.drop(s.W2(s.drop(F.gelu(s.W1(x)))))
+class PhiGatedFFN(nn.Module):
+    """SwiGLU reading of the paper's undefined "PhiGatedFFN", same width."""
+    def __init__(s, d):
+        super().__init__()
+        h = int(math.floor(d * PHI))
+        s.gate, s.up = nn.Linear(d, h, bias=False), nn.Linear(d, h, bias=False)
+        s.down = nn.Linear(h, d, bias=False)
+        s.drop = nn.Dropout(DROPOUT)
+    def forward(s, x):
+        return s.drop(s.down(F.silu(s.gate(x)) * s.up(x)))
+class Dyn12(nn.Module):
+    """Section 4.2. dx12/dt = k*Omega - gamma*x12, per-dimension k and gamma so the twelve
+    dimensions separate by time constant rather than evolving as twelve copies."""
+    def __init__(s):
+        super().__init__()
+        s.k = nn.Parameter(torch.linspace(0.05, 0.20, D12))
+        s.gamma = nn.Parameter(torch.linspace(0.02, 0.10, D12))
+        s.dt = 0.1
+    def forward(s, x12, h, omega):
+        d = s.k[None, None, :] * omega[..., None] - s.gamma[None, None, :] * x12
+        return torch.tanh(x12 + s.dt * d)
+class Dyn42(nn.Module):
+    """Section 4.3 / THEORY_42D_HYPER_COSMIC. dx42/dt = drive(h) - gamma*x42 + C(x42)."""
+    def __init__(s, d_model):
+        super().__init__()
+        s.drive = nn.Linear(d_model, D42)
+        s.coupling = nn.Linear(D42, D42, bias=False)
+        s.gamma = nn.Parameter(torch.full((D42,), 0.05))
+        s.dt = 0.1
+    def forward(s, x42, h, omega):
+        d = torch.tanh(s.drive(h)) - s.gamma[None, None, :] * x42 + 0.1 * s.coupling(x42)
+        return torch.tanh(x42 + s.dt * d)
+N_BAND, BAND_D = 7, 6          # 7 * 6 = 42, section 4.1
+class Dyn42Banded(nn.Module):
+    """Section 4.3 as WRITTEN: 42 = 7 bands x 6 dims, not a flat 42-vector.
+    THE GAP THIS EXISTS TO CLOSE. Every document in this project describes x42 as a
+    "7-band vector manifold" -- the ladder's own docstring says "7 bands x 6 dims" -- and
+    the implementation was:
+        drive    = nn.Linear(d_model, 42)     one flat projection
+        coupling = nn.Linear(42, 42)          every dimension coupled to every other
+        gamma    = torch.full((42,), 0.05)    forty-two copies of one constant
+    Nothing in it knew that 42 factors. So when dyn42 placed fourth (1.19020) and the
+    coupled rungs tri/tri3 placed fifth and sixth, that was read as evidence against the
+    42D organ. It is not. It is evidence against a flat, uniformly-damped, densely-coupled
+    42-vector, which is not what the theory specifies.
+    Notably Dyn12 already got this right, and says so in its own docstring: per-dimension
+    k and gamma "so the twelve dimensions separate by time constant rather than evolving
+    as twelve copies". The 42 never received the same treatment.
+    WHAT IS CORY'S, AND WHAT IS MINE
+      his   42 = 7 x 6. The band count, the width, and the idea that bands are distinct
+            organs rather than an undifferentiated vector.
+      his   the leaky-integrator form dx/dt = drive - gamma*x + coupling(x), unchanged.
+      mine  gamma varies ACROSS BANDS by linspace, so band 0 is fast and band 6 is slow.
+            This is Dyn12's own reasoning applied one level up: bands that share a time
+            constant are seven copies of each other, and copies cannot specialise.
+      mine  coupling is BLOCK-DIAGONAL -- each band mixes within its own 6 dimensions.
+            A band that couples to all 42 is not a band, it is a slice of a flat vector,
+            which is exactly the thing being replaced.
+      mine  one small cross-band term (n_band x n_band) so bands can still talk. Without
+            it this is seven independent 6D systems and the manifold is severed.
+    Cheaper as well as more structured: dense coupling is 42*42 = 1,764 weights per
+    layer; seven 6x6 blocks are 7*36 = 252, plus 49 for the cross-band mixer. That is
+    1,463 fewer parameters per layer while gaining structure -- which is the same
+    "state is cheaper than weights" direction the scaling result already measured.
+    """
+    def __init__(s, d_model):
+        super().__init__()
+        s.drive = nn.Linear(d_model, D42)
+        # block-diagonal: one 6x6 mixer per band, held as (7, 6, 6)
+        s.block = nn.Parameter(torch.randn(N_BAND, BAND_D, BAND_D) * (1.0 / BAND_D ** 0.5))
+        # bands talk to each other only through their means, at (7, 7)
+        s.cross = nn.Parameter(torch.randn(N_BAND, N_BAND) * (1.0 / N_BAND ** 0.5))
+        # ONE TIME CONSTANT PER BAND, spread the way Dyn12 spreads its twelve
+        s.gamma_band = nn.Parameter(torch.linspace(0.02, 0.12, N_BAND))
+        s.dt = 0.1
+    def forward(s, x42, h, omega):
+        B, T, _ = x42.shape
+        xb = x42.view(B, T, N_BAND, BAND_D)                       # (B,T,7,6)
+        # within-band mixing: each band's own 6x6
+        within = torch.einsum("btnd,nde->btne", xb, s.block)
+        # between-band: each band feels the others through their means
+        means = xb.mean(-1)                                       # (B,T,7)
+        between = torch.einsum("btn,nm->btm", means, s.cross)     # (B,T,7)
+        gam = s.gamma_band[None, None, :, None]                   # (1,1,7,1)
+        drive = torch.tanh(s.drive(h)).view(B, T, N_BAND, BAND_D)
+        d = drive - gam * xb + 0.1 * within + 0.1 * between[..., None]
+        # integrate in BANDED shape, then flatten -- adding a (B,T,7,6) derivative to a
+        # (B,T,42) state broadcasts into (B,T,7,42) instead of failing usefully.
+        return torch.tanh(xb + s.dt * d).reshape(B, T, D42)
+class Dyn42Tensor(nn.Module):
+    """42 = 7 bands x sym(3x3). The 6 is not a vector, it is a 3D symmetric tensor.
+    CORY, 2026-08-03: "3D decouples 7, 3x3 is 6, think dimensions and folding and banding
+    with connections."
+    A symmetric 3x3 matrix has exactly SIX independent components -- three on the diagonal
+    and three off it. So the 6 in "7 bands x 6 dims" is not an arbitrary width. Each band
+    is a tensor in three-dimensional space, stored in Voigt order:
+        [xx, yy, zz, xy, xz, yz]  ->  | xx  xy  xz |
+                                      | xy  yy  yz |
+                                      | xz  yz  zz |
+    That changes what the coupling is allowed to be. The operation that respects it is a
+    CONGRUENCE:
+        M -> A M A^T
+    which is what a change of basis does to a tensor. A is 3x3, so nine weights per band
+    instead of Dyn42Banded's thirty-six.
+    A CORRECTION, because the first version of this comment overclaimed. It said a free
+    6x6 mixer "destroys symmetry" and the congruence preserves it. That is false and the
+    test that appeared to confirm it was vacuous: _to_mat writes each Voigt slot into both
+    (i,j) and (j,i), so EVERY 6-vector becomes a symmetric matrix regardless of what
+    produced it. Symmetry is guaranteed by the storage, not by the operation.
+    The real distinction is invariance. Measured:
+        congruence by a rotation R:   eigenvalues unchanged  True
+                                      trace unchanged        True
+        a free 6x6 mixer:             eigenvalues unchanged  False
+    A tensor's eigenvalues and trace are physical -- they do not depend on how the axes
+    are oriented. Congruence is exactly a change of frame, so it must leave them alone,
+    and does. A free 6x6 scrambles components that describe different physical directions
+    (it can send xx into xy), which no coordinate change can do. That is the argument for
+    the congruence, and it is about geometry rather than about symmetry.
+    WHAT IS WHOSE
+      his   42 = 7 x 6; 6 = sym(3x3); bands are folded 3D objects with connections.
+      mine  congruence A M A^T as the band-internal operation, because it is the only
+            common bilinear map that provably preserves symmetry. A free 6x6 does not.
+      mine  per-band gamma by linspace, carried over from Dyn42Banded and originally
+            from his own Dyn12.
+      mine  the cross-band term acts on each band's TRACE -- the one scalar invariant of
+            a 3D tensor that does not depend on how the axes are oriented. Bands talk
+            through something basis-independent rather than through raw components.
+    Cheapest of the three by a wide margin: dense 42x42 is 1,764 weights per layer,
+    seven 6x6 blocks are 252, seven 3x3 congruences are 63.
+    """
+    # Voigt: which (row, col) each of the 6 slots maps to
+    _IDX = ((0, 0), (1, 1), (2, 2), (0, 1), (0, 2), (1, 2))
+    def __init__(s, d_model):
+        super().__init__()
+        s.drive = nn.Linear(d_model, D42)
+        s.A = nn.Parameter(torch.eye(3).repeat(N_BAND, 1, 1)
+                           + torch.randn(N_BAND, 3, 3) * 0.05)     # near-identity start
+        s.cross = nn.Parameter(torch.randn(N_BAND, N_BAND) * (1.0 / N_BAND ** 0.5))
+        s.gamma_band = nn.Parameter(torch.linspace(0.02, 0.12, N_BAND))
+        s.dt = 0.1
+    @classmethod
+    def _to_mat(cls, v):
+        """(..., 7, 6) Voigt -> (..., 7, 3, 3) symmetric."""
+        sh = v.shape[:-1]
+        M = v.new_zeros(*sh, 3, 3)
+        for k, (i, j) in enumerate(cls._IDX):
+            M[..., i, j] = v[..., k]
+            if i != j:
+                M[..., j, i] = v[..., k]
+        return M
+    @classmethod
+    def _to_voigt(cls, M):
+        """(..., 7, 3, 3) -> (..., 7, 6)."""
+        return torch.stack([M[..., i, j] for (i, j) in cls._IDX], dim=-1)
+    def forward(s, x42, h, omega):
+        B, T, _ = x42.shape
+        xb = x42.view(B, T, N_BAND, BAND_D)
+        M = s._to_mat(xb)                                          # (B,T,7,3,3)
+        # congruence A M A^T -- symmetric for any A, so the band stays a 3D tensor
+        A = s.A[None, None]                                        # (1,1,7,3,3)
+        within = s._to_voigt(A @ M @ A.transpose(-1, -2))
+        # bands connect through the TRACE: the invariant that survives rotating the axes
+        tr = M.diagonal(dim1=-2, dim2=-1).sum(-1)                  # (B,T,7)
+        between = torch.einsum("btn,nm->btm", tr, s.cross)
+        gam = s.gamma_band[None, None, :, None]
+        drive = torch.tanh(s.drive(h)).view(B, T, N_BAND, BAND_D)
+        d = drive - gam * xb + 0.1 * within + 0.1 * between[..., None]
+        return torch.tanh(xb + s.dt * d).reshape(B, T, D42)
+class Trinity(nn.Module):
+    """12D and 42D as ONE coupled system instead of two vectors glued together.
+    dyn54 concatenates x12 and x42, but x12 sees only Omega and x42 sees only h -- they
+    never exchange anything. THEORY_42D_HYPER_COSMIC already couples within a band (6 dims)
+    and between bands (7 attractors, diffusion matrix D); this is the same construction one
+    level up, between the two subsystems, which is the level nobody wrote:
+        dx12/dt = k*Omega - g12*x12 + M(42->12) x42
+        dx42/dt = tanh(drive(h))*(1 + lam*Omega) - g42*x42 + C(x42) + M(12->42) x12
+    Omega now drives BOTH, per THEORY_42D's "Omega_vec is the projected hidden state acting
+    as a driving force", and the cross terms close the loop between them. With H computed
+    from the joint x54 and Omega coming back out of attention, the three subsystems form a
+    single cycle rather than a tree.
+    """
+    def __init__(s, d_model):
+        super().__init__()
+        s.k = nn.Parameter(torch.linspace(0.05, 0.20, D12))
+        s.g12 = nn.Parameter(torch.linspace(0.02, 0.10, D12))
+        s.g42 = nn.Parameter(torch.full((D42,), 0.05))
+        s.drive = nn.Linear(d_model, D42)
+        s.C = nn.Linear(D42, D42, bias=False)
+        s.m42_12 = nn.Linear(D42, D12, bias=False)
+        s.m12_42 = nn.Linear(D12, D42, bias=False)
+        s.lam = nn.Parameter(torch.tensor(0.5))
+        s.dt = 0.1
+    def forward(s, state, h, omega):
+        x12, x42 = state[..., :D12], state[..., D12:]
+        om = omega[..., None]
+        # ASYMMETRIC COUPLING, on the neuromodulatory reading. The twelve slow scalars are
+        # tone: in a brain those act on cortical GAIN, multiplicatively, not as another
+        # additive input. The forty-two structured dimensions feed back the other way as
+        # ordinary drive. Symmetric matrices in both directions would make this two peers
+        # exchanging vectors; the asymmetry is what makes it a modulatory loop.
+        gain = 1.0 + torch.tanh(s.m12_42(x12))
+        d12 = s.k * om - s.g12 * x12 + 0.1 * s.m42_12(x42)
+        d42 = (torch.tanh(s.drive(h)) * gain * (1.0 + s.lam * om)
+               - s.g42 * x42 + 0.1 * s.C(x42))
+        return torch.tanh(torch.cat([x12 + s.dt * d12, x42 + s.dt * d42], -1))
+class Attention(nn.Module):
+    def __init__(s, d, nh, rung):
+        super().__init__()
+        s.nh, s.hd, s.rung = nh, d // nh, rung
+        s.qkv, s.proj = nn.Linear(d, 3 * d), nn.Linear(d, d)
+        s.drop = nn.Dropout(DROPOUT)
+        s.log_sigma = nn.Parameter(torch.zeros(()))
+        s.gate = nn.Parameter(torch.full((), -4.0), requires_grad=(rung != "none"))
+        s.w54 = nn.Linear(d, 54, bias=False) if rung in ("static54", "tri3", "rand54") else None
+        if rung == "rand54":
+            s.w54.weight.requires_grad_(False)      # frozen: a projection, never a lesson
+        s.last_gate, s.last_diag, s.last_H_std = 0.0, 0.0, 0.0
+    def hebbian(s, state, mask):
+        # section 3.2's own identity: ||a-b||^2 = ||a||^2 + ||b||^2 - 2<a,b>. Also what
+        # hyper_cosmic_model.py already does, and it avoids cdist's undefined gradient on
+        # the zero diagonal of cdist(x, x).
+        sq = (state * state).sum(-1)
+        d2 = (sq.unsqueeze(-1) + sq.unsqueeze(-2)
+              - 2.0 * (state @ state.transpose(-1, -2))).clamp_min(0.0)
+        sig = torch.exp(s.log_sigma).clamp(1e-3, 1e4)
+        H = torch.exp(-d2 / (2 * sig * sig)).masked_fill(mask < 0, 0.0)
+        H = H / H.sum(-1, keepdim=True).clamp_min(1e-9)
+        s.last_diag = float(torch.diagonal(H[0]).mean().detach())
+        s.last_H_std = float(H.detach().std())
+        return H
+    def forward(s, x, state, mask, cos, sin):
+        B, T, C = x.shape
+        q, k, v = s.qkv(x).split(C, 2)
+        sh = lambda t: t.view(B, T, s.nh, s.hd).transpose(1, 2)
+        q, k, v = sh(q), sh(k), sh(v)
+        q, k = apply_rope(q, cos, sin), apply_rope(k, cos, sin)
+        a = F.softmax((q @ k.transpose(-2, -1)) / math.sqrt(s.hd) + mask, -1)
+        if s.rung != "none":
+            # tri3: all three organs feed one kernel -- the fast structural projection of
+            # the current token, the slow 12D tone, and the 42D mid-band structure. The
+            # ladder only ever ran these as rivals for a single slot; nothing tested
+            # whether their strengths compose.
+            if s.rung == "tri3":
+                st = torch.cat([s.w54(x), state], -1)
+            else:
+                st = s.w54(x) if s.w54 is not None else state
+            g = torch.sigmoid(s.gate)
+            a = (1 - g) * a + g * s.hebbian(st, mask).unsqueeze(1)
+            s.last_gate = float(g.detach())
+        y = (s.drop(a) @ v).transpose(1, 2).contiguous().view(B, T, C)
+        # SECTION 3.4: Omega is attention RECEIVED, i.e. summed over QUERIES (axis -2).
+        # ver.4.20 sums over keys (-1), the axis softmax normalises, making Omega == 1.
+        #
+        # MEASURED 2026-08-01: that query-sum reads the future. Under a causal mask
+        # Omega_j = sum over i >= j of a_ij, so token j's Omega counts attention from
+        # tokens AFTER j; it then updates state_j, which feeds the next layer's kernel,
+        # which shapes the logits at j. tools/causality_probe.py: changing ONLY the last
+        # token moves earlier-position logits by 1.7e-04 at PHOS's trained gate (0.562)
+        # while `none` and `static54` move by EXACTLY 0.0 on the same harness. Any
+        # held-out loss won this way is not comparable to a rung that cannot cheat.
+        #
+        # The causal replacement is a per-QUERY scalar, which by construction depends
+        # only on tokens <= i: the NORMALISED ENTROPY of row i's attention. Summing over
+        # keys directly is not an option -- softmax already made that identically 1.0,
+        # which is precisely ver.4.20's dead Omega. Entropy is not constant, it is a
+        # genuine summary of how row i spread its attention, and it cannot see forward.
+        # The log(i+1) normaliser removes the positional drift that comes from later
+        # rows simply having more keys available to spread over, so this measures
+        # dispersion rather than position.
+        if CAUSAL_OMEGA:
+            am = a.mean(1).clamp_min(1e-9)                       # [B, T, T]
+            ent = -(am * am.log()).sum(-1)                       # [B, T], per QUERY
+            avail = torch.arange(1, T + 1, device=a.device, dtype=ent.dtype)
+            omega = ent / avail.log().clamp_min(1e-6)            # in [0, 1]
+        else:
+            omega = a.mean(1).sum(-2)
+        return s.proj(y), omega
+class Layer(nn.Module):
+    def __init__(s, d, nh, rung, ffn):
+        super().__init__()
+        s.n1, s.n2 = RMSNorm(d), RMSNorm(d)
+        s.attn = Attention(d, nh, rung)
+        s.ffn = (PhiHarmonicFFN if ffn == "harmonic" else PhiGatedFFN)(d)
+        s.rung = rung
+        s.d12 = Dyn12() if rung in ("dyn12", "dyn54", "dyn12seq", "dyn12p") else None
+        # dyn42b is dyn42's DIRECT control: same state width, same leaky-integrator form,
+        # same everything except that 42 is treated as 7 bands of 6 rather than as a flat
+        # vector. If it wins, the earlier dyn42 null was measuring the implementation.
+        s.d42 = (Dyn42Tensor(d) if rung == "dyn42t"
+                 else Dyn42Banded(d) if rung == "dyn42b"
+                 else Dyn42(d) if rung in ("dyn42", "dyn54") else None)
+        s.tri = Trinity(d) if rung in ("tri", "tri3") else None
+    def forward(s, x, state, mask, cos, sin):
+        h = s.n1(x)
+        att, omega = s.attn(h, state, mask, cos, sin)
+        x = x + att
+        if s.tri is not None:                           # section 2.1 step 2, coupled
+            state = s.tri(state, h, omega)
+        elif s.d12 is not None or s.d42 is not None:    # section 2.1 step 2, independent
+            parts = []
+            if s.d12 is not None:
+                parts.append(s.d12(state[..., :D12], h, omega))
+            if s.d42 is not None:
+                parts.append(s.d42(state[..., -D42:], h, omega))
+            state = torch.cat(parts, -1)
+        x = x + s.ffn(s.n2(x))
+        return x, state, omega
+class Ladder(nn.Module):
+    def __init__(s, vocab, rung, ffn, d=N_EMBD, nh=N_HEAD):
+        super().__init__()
+        s.d, s.nh, s.rung = d, nh, rung
+        s.sd = STATE_DIM[rung]
+        s.tok = nn.Embedding(vocab, d)
+        s.blocks = nn.ModuleList([Layer(d, nh, rung, ffn) for _ in range(N_LAYER)])
+        s.nf = RMSNorm(d)
+        s.head = nn.Linear(d, vocab, bias=False)
+        # a state that starts at zero is identical for every token, which makes H the
+        # all-ones matrix and the first layer's mechanism inert. Seeding it from the
+        # embedding costs one small projection and keeps every layer live.
+        s.state_init = nn.Linear(d, s.sd) if rung.startswith(("dyn", "tri")) and s.sd else None
+        if rung == "noise54":
+            # a state that varies by POSITION but is identical for every input. If this
+            # matches the real 54D state, the kernel is a positional regulariser and the
+            # "experience-modulated attention" reading is not supported by the data.
+            g0 = torch.Generator().manual_seed(20260730)
+            s.register_buffer("noise_state",
+                              torch.randn(BLOCK, 54, generator=g0) * 0.5)
+        s.register_buffer("mask", torch.triu(torch.full((BLOCK, BLOCK), float("-inf")), 1))
+    def forward(s, idx, targets=None, state_in=None):
+        B, T = idx.shape
+        x = s.tok(idx)
+        cos, sin = rope_cache(s.d // s.nh, T, idx.device)
+        m = s.mask[:T, :T]
+        state = torch.tanh(s.state_init(x)) if s.state_init is not None else None
+        if s.rung == "noise54":
+            state = s.noise_state[:T].unsqueeze(0).expand(B, -1, -1)
+        # SECTION 4.4. A state arriving from the previous window seeds this one. It is the
+        # LAST position's state broadcast across the new window: what she carried out of
+        # the previous 128 characters is what she starts the next 128 with. gamma is what
+        # keeps this from saturating -- a state that never forgets pins to tanh's rails and
+        # stops carrying anything, so forgetting is what makes the persistence usable.
+        if state is not None and state_in is not None:
+            state = state + state_in[:, -1:, :].detach().expand(-1, T, -1)
+            state = torch.tanh(state)
+        omegas = []
+        for b in s.blocks:
+            x, state, om = b(x, state, m, cos, sin)
+            omegas.append(om)
+        lg = s.head(s.nf(x))
+        loss = None if targets is None else F.cross_entropy(
+            lg.view(-1, lg.size(-1)), targets.reshape(-1))
+        s.last_state, s.last_omega = state, omegas[-1]
+        s.out_state = state
+        return lg, loss
+    def gates(s):
+        return [b.attn.last_gate for b in s.blocks]
+    def quantum_birth(s, qi):
+        std = (1.0 / (s.d * PHI_INV)) ** 0.5          # section 6.2
+        for mod in s.modules():
+            if isinstance(mod, (nn.Linear, nn.Embedding)):
+                qi.fill_(mod.weight, std)
+                if isinstance(mod, nn.Linear) and mod.bias is not None:
+                    with torch.no_grad():
+                        mod.bias.zero_()
+@torch.no_grad()
+def calibrate_sigma(m, xb):
+    """2*sigma^2 = median pairwise d2 of whatever state that layer actually sees."""
+    if m.rung == "none":
+        return
+    B, T = xb.shape
+    x = m.tok(xb)
+    cos, sin = rope_cache(m.d // m.nh, T, xb.device)
+    mask = m.mask[:T, :T]
+    state = torch.tanh(m.state_init(x)) if m.state_init is not None else None
+    if m.rung == "noise54":
+        # must mirror Ladder.forward exactly, or the control is calibrated against a state
+        # it never actually sees -- which would hand it a rigged sigma and invalidate it
+        state = m.noise_state[:xb.shape[1]].unsqueeze(0).expand(xb.shape[0], -1, -1)
+    for b in m.blocks:
+        h = b.n1(x)
+        if m.rung == "tri3":
+            st = torch.cat([b.attn.w54(h), state], -1)
+        elif b.attn.w54 is not None:
+            st = b.attn.w54(h)
+        else:
+            st = state
+        sq = (st * st).sum(-1)
+        d2 = (sq.unsqueeze(-1) + sq.unsqueeze(-2)
+              - 2.0 * (st @ st.transpose(-1, -2))).clamp_min(0.0)
+        iu = torch.triu(torch.ones(d2.shape[-2:], dtype=torch.bool), 1)
+        med = float(d2[0][iu].median())
+        if med > 1e-12:
+            b.attn.log_sigma.fill_(0.5 * math.log(med / 2.0))
+        x, state, _ = b(x, state, mask, cos, sin)
+def preflight(m, xb, yb):
+    """Refuse to report a number until the mechanism is provably live.
+    Each assertion corresponds to a real failure that shipped and produced a confident
+    negative. A rung that trips any of these is not evidence about the idea.
+    """
+    checks, m2 = [], m
+    m2.train()
+    _, loss = m2(xb, yb)
+    loss.backward()
+    om = m2.last_omega
+    checks.append(("omega varies across tokens (ver.4.20 had std 5e-08)",
+                   float(om.std()), 1e-4, float(om.std()) > 1e-4))
+    if m.rung != "none":
+        if m.rung.startswith(("dyn", "tri")):
+            st = m2.last_state
+            checks.append(("state varies across tokens (ver.4.20 had std 3e-08)",
+                           float(st.std()), 1e-4, float(st.std()) > 1e-4))
+        diag = statistics.fmean([b.attn.last_diag for b in m2.blocks])
+        checks.append((f"H not the identity (needs << 1.0, uniform = {1/xb.shape[1]:.4f})",
+                       diag, 0.5, diag < 0.5))
+        hstd = statistics.fmean([b.attn.last_H_std for b in m2.blocks])
+        checks.append(("H not all-ones (needs non-zero spread)", hstd, 1e-6, hstd > 1e-6))
+        gg = statistics.fmean([abs(float(b.attn.gate.grad)) for b in m2.blocks
+                               if b.attn.gate.grad is not None])
+        checks.append(("gate gradient not suppressed", gg, 1e-6, gg > 1e-6))
+    m2.zero_grad(set_to_none=True)
+    return checks
+def train_rung(rung, ffn, seed, data, vocab, steps, pool, val_w, words, itos):
+    torch.manual_seed(seed)
+    random.seed(seed)
+    gen = torch.Generator().manual_seed(seed)
+    m = Ladder(vocab, rung, ffn)
+    m.quantum_birth(QuantumInit(pool, seed))
+    m = m.to(DEV)
+    cal = torch.stack([data[i:i + BLOCK] for i in torch.randint(
+        len(data) - BLOCK - 1, (8,), generator=torch.Generator().manual_seed(seed))]).to(DEV)
+    calibrate_sigma(m, cal)
+    pf = preflight(m, cal[:4], torch.stack([data[i + 1:i + 1 + BLOCK] for i in
+                   torch.randint(len(data) - BLOCK - 1, (4,),
+                                 generator=torch.Generator().manual_seed(seed))]).to(DEV))
+    def _coup(mm):
+        # POST-FLIGHT. Preflight proves a mechanism starts alive; this proves it did not
+        # quietly die. The cross-couplings begin damped by 0.1 (the reference repo's
+        # "weak coupling initially"), so the question is whether training grows them or
+        # leaves the trinity decorative.
+        v = [(float(b.tri.m12_42.weight.abs().mean()), float(b.tri.m42_12.weight.abs().mean()))
+             for b in mm.blocks if getattr(b, "tri", None) is not None]
+        return v
+    coup0 = _coup(m)
+    keys = ("attn.gate", "attn.w54", "attn.log_sigma", "d12.", "d42.", "tri.", "state_init")
+    cst = [p for n, p in m.named_parameters() if any(k in n for k in keys) and p.requires_grad]
+    bulk = [p for n, p in m.named_parameters() if not any(k in n for k in keys) and p.requires_grad]
+    base = 3e-4
+    opt = torch.optim.AdamW([{"params": bulk, "lr": base},
+                             {"params": cst, "lr": base * 10, "weight_decay": 0.0}],
+                            lr=base, weight_decay=0.01)
+    n = int(0.9 * len(data))
+    tr = data[:n]
+    m.train()
+    best = float("inf")
+    # SEQUENTIAL WALK for the persistence arms. 16 lanes each march through their own
+    # contiguous stretch of the corpus, so consecutive batches are consecutive TEXT and a
+    # carried state means something. Under the random sampler used by every other rung,
+    # batch k+1 is unrelated to batch k, so a carried state would be pure noise -- which is
+    # why the control arm (dyn12seq) walks identically and only differs in whether the
+    # state survives the window boundary.
+    B = 16
+    seq = rung in SEQ_RUNGS
+    persist = rung in PERSIST_RUNGS
+    span = max(BLOCK * 2, (len(tr) - BLOCK - 1) // B)
+    pos = [i * span for i in range(B)]
+    carry = None
+    for s in range(1, steps + 1):
+        warm = max(1, int(0.05 * steps))
+        lr = base * (s / warm) if s < warm else base * (PHI / 2) * (
+            1 + math.cos(math.pi * (s - warm) / max(1, steps - warm)))
+        opt.param_groups[0]["lr"], opt.param_groups[1]["lr"] = lr, lr * 10
+        if seq:
+            wrapped = []
+            for i in range(B):
+                if pos[i] + BLOCK + 1 >= min((i + 1) * span, len(tr) - 1):
+                    pos[i] = i * span          # lane restarted: its history is broken
+                    wrapped.append(i)
+            ix = torch.tensor(pos, dtype=torch.long)
+            for i in range(B):
+                pos[i] += BLOCK
+            if carry is not None and wrapped:
+                # a wrapped lane must NOT inherit state from unrelated text
+                carry = carry.clone()
+                carry[wrapped] = 0.0
+        else:
+            ix = torch.randint(len(tr) - BLOCK - 1, (B,), generator=gen)
+        # .long() at BATCH time, not corpus time. A 269M-character corpus held as int64
+        # is 2.15 GB resident; as int16 it is 0.54 GB, and only the (B, BLOCK) slice ever
+        # needs to be int64 for nn.Embedding. The d576 scaling run died at exactly this
+        # point -- outer process gone, no error recorded -- with the corpus tensor and a
+        # 24.6M-parameter model competing for the last few GB.
+        x = torch.stack([tr[i:i + BLOCK] for i in ix]).to(DEV).long()
+        y = torch.stack([tr[i + 1:i + 1 + BLOCK] for i in ix]).to(DEV).long()
+        _, loss = m(x, y, state_in=carry if persist else None)
+        if persist:
+            carry = m.out_state.detach() if m.out_state is not None else None
+        opt.zero_grad(set_to_none=True)
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(m.parameters(), 1.0)
+        opt.step()
+        if s % 100 == 0 or s == steps:
+            m.eval()
+            with torch.no_grad():
+                tot = c = 0
+                for i in range(0, len(val_w), 16):
+                    xb = val_w[i:i + 16].to(DEV)
+                    _, l = m(xb[:, :-1], xb[:, 1:])
+                    tot += l.item() * xb.size(0)
+                    c += xb.size(0)
+            m.train()
+            best = min(best, tot / max(1, c))
+    m.eval()
+    idx = torch.tensor([[int(data[0])]], device=DEV)
+    out = []
+    with torch.no_grad():
+        for _ in range(600):
+            lg, _ = m(idx[:, -BLOCK:])
+            nx = int(torch.multinomial(F.softmax(lg[0, -1] / 0.8, -1), 1))
+            out.append(nx)
+            idx = torch.cat([idx, torch.tensor([[nx]], device=DEV)], 1)
+    txt = "".join(itos.get(i, "") for i in out)
+    coupT = _coup(m)
+    coup = None
+    if coup0:
+        a0 = statistics.fmean([x for p in coup0 for x in p])
+        aT = statistics.fmean([x for p in coupT for x in p])
+        coup = (a0, aT, aT / max(a0, 1e-12))
+    return best, statistics.fmean(m.gates()) if m.rung != "none" else 0.0, \
+        real_word_rate(txt, words), pf, sum(p.numel() for p in m.parameters()), txt, coup, m
+def main():
+    steps = int(sys.argv[1]) if len(sys.argv) > 1 else 1200
+    seeds = list(range(int(sys.argv[2]) if len(sys.argv) > 2 else 3))
+    rungs = (sys.argv[3] if len(sys.argv) > 3 else
+             "none,static54,dyn12,dyn42,dyn54").split(",")
+    ffn = sys.argv[4] if len(sys.argv) > 4 else "harmonic"
+    text = CORPUS_PATH.read_text(encoding="utf-8", errors="ignore")
+    chars = sorted(set(text))
+    stoi = {c: i for i, c in enumerate(chars)}
+    itos = {i: c for c, i in stoi.items()}
+    data = torch.tensor([stoi[c] for c in text], dtype=torch.long)
+    words = set(__import__("re").findall(r"[a-z']+", text.lower()))
+    print("=" * 84)
+    print("  COSMOS STATE LADDER -- 12D / 42D / 54D, one rung at a time")
+    print("=" * 84)
+    print(f"\n  device: {DEV}" + (f" ({torch.cuda.get_device_name(0)})" if DEV.type == "cuda" else ""))
+    print(f"  corpus: {CORPUS_PATH}"
+          + ("  [FROZEN SNAPSHOT]" if os.getenv("COSMOS_CORPUS") else "  [LIVE - grows during the run, cross-run numbers are not comparable]"))
+    print(f"  corpus {len(text):,}  vocab {len(chars)}  {steps} steps x {len(seeds)} seeds")
+    print(f"  scaffold: RMSNorm + RoPE + {'PhiHarmonicFFN (GELU)' if ffn=='harmonic' else 'PhiGatedFFN (SwiGLU)'}"
+          f" @ floor(d*phi)={int(math.floor(N_EMBD*PHI))} + phi-Xavier")
+    print(f"  rungs: {rungs}\n")
+    pool = quantum_pool()
+    print(f"  quantum pool: {len(pool):,} draws\n")
+    n = int(0.9 * len(data))
+    val = data[n:]
+    g = torch.Generator().manual_seed(999)
+    vi = torch.randint(len(val) - BLOCK - 1, (64,), generator=g)
+    val_w = torch.stack([val[i:i + BLOCK + 1] for i in vi])
+    out = {}
+    for rung in rungs:
+        losses, rws, gates, npar, pf_last = [], [], [], 0, None
+        blocked = False
+        best_loss, best_model = float("inf"), None
+        for sd in seeds:
+            t0 = time.time()
+            b, gt, r, pf, npar, txt, coup, model = train_rung(
+                rung, ffn, sd, data, len(chars), steps, pool, val_w, words, itos)
+            if b < best_loss:
+                best_loss, best_model = b, model
+            pf_last = pf
+            bad = [c for c in pf if not c[3]]
+            if sd == 0:
+                print(f"  --- {rung} preflight ---")
+                for name, val_, thr, ok in pf:
+                    print(f"      [{'OK ' if ok else 'DEAD'}] {name}: {val_:.3e}")
+                if bad:
+                    blocked = True
+                    print(f"      MECHANISM INERT -- {rung} will not be reported as evidence.\n")
+                    break
+                print()
+            losses.append(b)
+            rws.append(r)
+            gates.append(gt)
+            print(f"    {rung:<9s} seed {sd}  loss {b:.5f}  real-word {r:.3f}"
+                  + (f"  gate {gt:.4f}" if rung != "none" else "")
+                  + (f"  coupling {coup[0]:.2e}->{coup[1]:.2e} ({coup[2]:.1f}x)" if coup else "")
+                  + f"  ({time.time()-t0:.0f}s)", flush=True)
+        if blocked:
+            out[rung] = {"blocked": True,
+                         "preflight": [[c[0], c[1], c[2], c[3]] for c in pf_last]}
+            continue
+        out[rung] = {"loss": losses, "real_word": rws, "gates": gates, "params": npar,
+                     "preflight": [[c[0], c[1], c[2], c[3]] for c in pf_last]}
+        print(f"    => {rung:<9s} mean loss {statistics.fmean(losses):.5f}  "
+              f"real-word {statistics.fmean(rws):.3f}  params {npar:,}", flush=True)
+        # SAVE. The first version of this file trained fifteen models and discarded every
+        # one of them -- OUTDIR was declared and torch.save was never called. A result you
+        # cannot deploy is half a result.
+        if best_model is not None:
+            OUTDIR.mkdir(parents=True, exist_ok=True)
+            torch.save({"model": best_model.state_dict(), "stoi": stoi, "itos": itos,
+                        "config": {"block": BLOCK, "n_layer": N_LAYER, "n_head": N_HEAD,
+                                   "n_embd": N_EMBD, "vocab": len(chars),
+                                   "d54": STATE_DIM.get(rung, 0), "d12": D12, "d42": D42,
+                                   "d_ff": int(math.floor(N_EMBD * PHI))},
+                        "arch": f"Cosmos-Ladder-{rung}", "rung": rung, "ffn": ffn,
+                        "gate_param": "logit", "norm": "rmsnorm", "pos": "rope",
+                        "total_steps": steps, "best_val_loss": best_loss,
+                        "quantum_source": "ibm_real_shots"},
+                       OUTDIR / f"ladder_{rung}.pt")
+            print(f"       saved -> {OUTDIR / f'ladder_{rung}.pt'}  (loss {best_loss:.5f})\n",
+                  flush=True)
+    base = out.get("none", {}).get("loss")
+    if base:
+        print("=" * 84 + "\n  LADDER\n" + "=" * 84)
+        print(f"  {'rung':<10s} {'mean loss':>10s} {'vs none':>10s} {'t':>8s} {'wins':>6s} {'params':>10s}")
+        for rung in rungs:
+            r = out.get(rung, {})
+            if r.get("blocked"):
+                print(f"  {rung:<10s} {'BLOCKED - mechanism provably inert':>46s}")
+                continue
+            if "loss" not in r:
+                continue
+            d = [p - c for p, c in zip(base, r["loss"])]
+            md = statistics.fmean(d)
+            se = statistics.stdev(d) / math.sqrt(len(d)) if len(d) > 1 else 0.0
+            t = md / se if se > 0 else 0.0
+            print(f"  {rung:<10s} {statistics.fmean(r['loss']):>10.5f} {-md:>+10.5f} "
+                  f"{-t:>8.2f} {sum(1 for x in d if x > 0):>4d}/{len(d)} {r['params']:>10,}")
+    Path("logs").mkdir(exist_ok=True)
+    RESULTS.write_text(json.dumps({"phi": PHI, "steps": steps, "ffn": ffn, "rungs": out},
+                                  indent=2), encoding="utf-8")
+    print(f"\n  saved -> {RESULTS}")
+    return 0
+if __name__ == "__main__":
+    raise SystemExit(main())

verify_release.py ADDED Viewed

	@@ -0,0 +1,193 @@

+#!/usr/bin/env python3
+"""Offline integrity and privacy-boundary verifier for the QC67 Cosmos kit."""
+from __future__ import annotations
+import argparse
+import hashlib
+import json
+import sys
+from collections import Counter
+from pathlib import Path
+ROOT = Path(__file__).resolve().parent
+MANIFEST = ROOT / "RELEASE_MANIFEST.json"
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+def check_manifest(strict: bool) -> list[str]:
+    errors: list[str] = []
+    release = json.loads(MANIFEST.read_text(encoding="utf-8"))
+    expected = set()
+    for entry in release.get("files", []):
+        rel = entry["path"]
+        expected.add(rel)
+        path = ROOT / rel
+        if not path.is_file():
+            errors.append(f"missing: {rel}")
+            continue
+        size = path.stat().st_size
+        if size != int(entry["bytes"]):
+            errors.append(f"size mismatch: {rel} ({size} != {entry['bytes']})")
+            continue
+        actual = sha256(path)
+        if actual != entry["sha256"]:
+            errors.append(f"hash mismatch: {rel}")
+    if strict:
+        ignored = {"RELEASE_MANIFEST.json"}
+        # Runtime spoor, not release content. logs/ and workspace/ are written by
+        # simply USING the kit, and __pycache__ appears the moment python imports
+        # anything -- so without these a clean, correct kit reports dozens of
+        # "unmanifested file" errors the first time anyone runs it, and the real
+        # findings (a staged credential, a missing weight) drown in the noise.
+        # creatures/ holds beings the USER birthed on their own machine. They are not
+        # release content and their hashes cannot be known in advance -- manifesting them
+        # would make the integrity check fail the moment anyone actually used the kit.
+        skip_prefixes = ("downloads/", "logs/", "workspace/", "creatures/")
+        actual = {
+            path.relative_to(ROOT).as_posix()
+            for path in ROOT.rglob("*")
+            if path.is_file()
+            and path.relative_to(ROOT).as_posix() not in ignored
+            and not path.relative_to(ROOT).as_posix().startswith(skip_prefixes)
+            and "__pycache__" not in path.parts
+            and not path.name.endswith((".pyc", ".pyo"))
+        }
+        for rel in sorted(actual - expected):
+            errors.append(f"unmanifested file: {rel}")
+    return errors
+def check_blank_credentials() -> list[str]:
+    errors: list[str] = []
+    config = json.loads(
+        (ROOT / "genesis_engine" / "config.json").read_text(encoding="utf-8")
+    )
+    for key in ("ibm_token", "azure_connection_string"):
+        if str(config.get(key) or "").strip():
+            errors.append(f"credential field is not blank: genesis_engine/config.json:{key}")
+    forbidden_names = ("oauth2_tokens.json", ".env", "credentials.json")
+    for path in ROOT.rglob("*"):
+        if path.is_file() and path.name.casefold() in forbidden_names:
+            errors.append(f"forbidden credential file present: {path.relative_to(ROOT)}")
+    return errors
+def check_public_archive() -> tuple[list[str], dict]:
+    errors: list[str] = []
+    archive = ROOT / "data" / "quantum_measurements_public.jsonl"
+    data_manifest = json.loads(
+        (ROOT / "data" / "quantum_measurements_manifest.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    records = Counter()
+    samples = Counter()
+    total = 0
+    for line_number, line in enumerate(
+        archive.open(encoding="utf-8", errors="strict"), 1
+    ):
+        try:
+            row = json.loads(line)
+        except Exception as exc:
+            errors.append(f"archive line {line_number}: invalid JSON ({exc})")
+            continue
+        counts = row.get("counts")
+        if not isinstance(counts, dict) or not counts:
+            errors.append(f"archive line {line_number}: missing counts")
+            continue
+        observed = sum(int(value) for value in counts.values())
+        declared = int(row.get("total_shots", -1))
+        if observed != declared:
+            errors.append(
+                f"archive line {line_number}: shot mismatch {observed} != {declared}"
+            )
+        category = str(row.get("provider_class") or "missing")
+        records[category] += 1
+        samples[category] += observed
+        total += observed
+    expected = data_manifest["summary"]
+    if total != int(expected["total_samples"]):
+        errors.append(
+            f"archive total mismatch: {total} != {expected['total_samples']}"
+        )
+    for category, expected_count in expected["records_by_provider_class"].items():
+        if records[category] != int(expected_count):
+            errors.append(
+                f"archive record count mismatch for {category}: "
+                f"{records[category]} != {expected_count}"
+            )
+    return errors, {
+        "records": sum(records.values()),
+        "samples": total,
+        "records_by_class": dict(records),
+        "samples_by_class": dict(samples),
+    }
+def check_model_metadata() -> list[str]:
+    errors: list[str] = []
+    metadata = json.loads(
+        (ROOT / "weights" / "cosmos_born.meta.json").read_text(encoding="utf-8")
+    )
+    if int(metadata.get("params", 0)) != 1_842_432:
+        errors.append("unexpected cosmos_born parameter count")
+    if str(metadata.get("base_model") or "").upper().split()[0] != "NONE":
+        errors.append("cosmos_born metadata no longer reports a from-scratch base")
+    return errors
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--no-strict",
+        action="store_true",
+        help="allow extra files not listed in the release manifest",
+    )
+    args = parser.parse_args()
+    if not MANIFEST.is_file():
+        print("[FAIL] RELEASE_MANIFEST.json is missing")
+        return 1
+    errors = []
+    errors.extend(check_manifest(strict=not args.no_strict))
+    errors.extend(check_blank_credentials())
+    archive_errors, archive_stats = check_public_archive()
+    errors.extend(archive_errors)
+    errors.extend(check_model_metadata())
+    if errors:
+        print(f"[FAIL] {len(errors)} release check(s) failed")
+        for error in errors:
+            print("  -", error)
+        return 1
+    print("[OK] release manifest hashes verified")
+    print("[OK] shipped cloud credential fields are blank")
+    print("[OK] cosmos_born metadata is internally consistent")
+    print(
+        "[OK] public archive:",
+        f"{archive_stats['records']:,} records,",
+        f"{archive_stats['samples']:,} samples",
+    )
+    for category in sorted(archive_stats["records_by_class"]):
+        print(
+            "    ",
+            category,
+            f"{archive_stats['records_by_class'][category]:,} records /",
+            f"{archive_stats['samples_by_class'][category]:,} samples",
+        )
+    return 0
+if __name__ == "__main__":
+    raise SystemExit(main())