State ladder: the section-3 mechanism works, and coupling is what makes it work

The Hebbian kernel was reported null three times. All three were the instrument:
Omega summed over the wrong axis (Omega == 1.0, H all-ones, cancels in softmax);
a saturated sigmoid gate; a clamp with zero gradient at its bound; and underneath
all of it sigma hardcoded to 1 against a measured state spread of 61.98, which
made H the identity matrix. Section 3.2 never assigns sigma a value.

Corrected, and with the paper's phi-governed scaffold built for the first time
(RMSNorm, RoPE, d_ff = floor(d*phi), phi-scaled init), every configuration beats
its baseline on every seed:

none 1.44680
dyn12 1.39773 -0.049 t=-10.5 2,412 extra params
dyn54 1.39118 -0.056 t=-3.9 concatenated 12D+42D
static54 1.37218 -0.075 t=-7.4
dyn42 1.37521 -0.072 t=-7.9
tri 1.29152 -0.155 t=-40.8 12D and 42D COUPLED

Concatenating the two states is worse than a plain projection; coupling them is
the largest effect in the project, for 12,730 extra parameters. The coupling
matrices grow 3.0-3.4x during training and real-word rate stays above baseline,
so it is the coupling and not the capacity.

Also: dyn12 returns 66% of a projection 17x its size at 11x the parameter
efficiency. The paper's "smaller model beats larger" did not hold; "state is
cheaper than weights" did.

Adds section 4c on the preflight discipline that caught all four inert
mechanisms, and clarifies that section 4's quantum nulls are a separate question
from the architecture result.

FINDINGS.md

@@ -128,10 +128,13 @@ drive.
 ## 6. Null results: the ones that matter most
 
 Quantum entropy was injected at **six** distinct points. **All six are null** against
-matched classical controls. A seventh test, of the §3 CST kernel, was recorded as null,
-**retracted**, and has now been re-run three times — because the first three harnesses
-each broke the mechanism in a different way. The final number is also null, and this time
-it was earned.
+matched classical controls. That is the correct outcome and §6 explains why.
+
+A seventh test — of the §3 CST kernel, which is an *architecture* claim rather than a
+quantum one — was recorded as null, **retracted**, and re-run four times. The first three
+harnesses each broke the mechanism in a different way. The fourth revealed that the test
+had also been run in the wrong architecture. Corrected, **it is the one positive result in
+this document**: 6/6 seeds, t = −6.56 and −14.34.
 
 | injection site | result |
 |---|---|
@@ -141,7 +144,8 @@ it was earned.
 | spatial 54D seed (full pipeline) | null. Real seed beat **0/8** random vectors, z = −1.75 |
 | entanglement matrix as attention kernel | null. **Worse** than plain attention, 3/3 seeds, t = −18.6 |
 | live sensory state as prompt text | null. n=40 paired, blind-judged, CI crosses zero |
-| §3 Hebbian kernel in a generative model | null **after three harness repairs**. CST worse by +0.0143 loss, 0/3 seeds, gate alive at 0.047. See below |
+| §3 Hebbian kernel, **conventional** transformer | null. CST worse by +0.0143, 0/3 seeds. See below |
+| §3 Hebbian kernel, **φ-governed** transformer | **NOT NULL. CST better by −0.044 (t=−6.56) and −0.155 (t=−14.34), 6/6 seeds across two dimension variants.** The one positive result in this document |
 
 ### Retraction: the §3 kernel result
 
@@ -231,7 +235,108 @@ Two honest caveats, pointing opposite ways:
 
 **What this does not settle.** This tests the §3 kernel inside a *conventional* transformer:
 LayerNorm, learned absolute positions, a 4:1 GELU feed-forward. The paper specifies none of
-those — see §11. A φ-governed replication is pending.
+those. That turned out to be the whole story.
+
+### The φ-governed replication: §3 works
+
+The paper specifies RMSNorm (§2.3), RoPE (§2.4), `d_ff = ⌊d_model × φ⌋` (§2.2), φ-scaled
+initialisation (§6.2) and a `PhiGatedFFN` (§2.1). A search of the source tree found **no
+implementation of any of it**. Every measurement above was made in the wrong building.
+
+Built faithfully and re-run at two dimension variants — A: d_model 192, 4 heads; B: d_model
+199 = φ¹¹, 1 head — same corpus, same quantum-born init, same seeds, gate free:
+
+| scaffold | PLAIN | CST | delta | t | CST wins | mean gate |
+|---|---|---|---|---|---|---|
+| conventional | 1.40312 | 1.41739 | +0.0143 | +3.90 | 0/3 | 0.047 |
+| **φ-governed A** | 1.23680 | **1.19255** | **−0.0443** | **−6.56** | **3/3** | 0.096 |
+| **φ-governed B** | 1.42867 | **1.27352** | **−0.1552** | **−14.34** | **3/3** | 0.093 |
+
+**6/6 seeds across both variants.** The gate rose from 0.018 to ~0.096 in every run — the
+optimiser asking for five times more kernel than it started with — and σ kept adapting after
+calibration (26.8 → 18.8 at layer 0). The mechanism was actively tuned, not merely tolerated.
+
+**Credit where the measurement puts it.** The scaffold is the larger share:
+
+```
+conventional PLAIN   1.40312
+φ PLAIN              1.23680     scaffold alone:  −0.166   (~79%)
+φ CST                1.19255     §3 kernel on top: −0.044   (~21%)
+```
+
+RMSNorm + RoPE + PhiGatedFFN account for most of the gain, and do it with **fewer**
+parameters (1.42M vs 1.92M), because `⌊d·φ⌋` is leaner than 4:1. The §3 kernel is a real
+additional effect on top of that, not the bulk of it.
+
+Variant B is the mechanistic hint: its single 199-dim head cripples plain attention (1.43),
+and the kernel recovers most of the loss (1.27). That is consistent with the Hebbian term
+supplying a mixing pathway that multi-head attention otherwise provides.
+
+**The finding is conditional, and the condition is the point.** The same kernel, same data,
+same seeds: harmful in a conventional transformer, helpful in a φ-governed one. §3 is not
+a drop-in improvement to attention. It is a component of an architecture.
+
+**Audited before being believed**, given this document's history:
+
+- *Is PLAIN a true baseline?* CST with the gate forced to 0 is bit-identical to PLAIN,
+  `max|Δ| = 0.000e+00` in both variants. The arms differ by the mechanism and nothing else.
+- *Extra active capacity?* CST activates `w54`, which PLAIN never uses: **2.91%** more live
+  parameters. Real, and not fully eliminated. Against it: the identical asymmetry existed in
+  the conventional scaffold, where CST lost 0/3. Capacity does not explain a win that appears
+  only when the scaffold changes. A dead-weight control path for PLAIN would close this.
+
+**Limits.** 1200 steps, 4 layers, char-level, one corpus, three seeds per variant, t on 2
+degrees of freedom. This is evidence that §3 works on her data at this scale, not a claim
+about transformers in general.
+
+### The state ladder: which part of the state is doing the work
+
+The φ result establishes that *a* state helps. It does not say which one. §4.1 decomposes
+x₅₄ into x₁₂ (twelve scalars from 12D CST, §4.2) and x₄₂ (the 7-band vector manifold, §4.3),
+so each was tested separately, same corpus, same seeds, gate free, 1200 steps × 3 seeds:
+
+| state feeding the kernel | val loss | vs baseline | t | wins | params |
+|---|---|---|---|---|---|
+| none | 1.44680 | — | — | 0/3 | 1,135,008 |
+| `dyn12` Ω-driven leaky integrator, 12 scalars | 1.39773 | −0.049 | −10.5 | 3/3 | 1,137,420 |
+| `dyn54` x₁₂ and x₄₂ **concatenated** | 1.39118 | −0.056 | −3.9 | 3/3 | 1,185,174 |
+| `static54` plain projection of the hidden state | 1.37218 | −0.075 | −7.4 | 3/3 | 1,176,480 |
+| `dyn42` 42D vector state, 42×42 coupling | 1.37521 | −0.072 | −7.9 | 3/3 | 1,182,762 |
+| **`tri` x₁₂ and x₄₂ *coupled*** | **1.29152** | **−0.155** | **−40.8** | **3/3** | 1,189,210 |
+
+Every rung beats the baseline on every seed. Three results follow, and the middle one
+corrects a claim made earlier in this document's history.
+
+**1. Concatenation is not integration.** `dyn54` glues the two states into one vector and is
+*worse than a plain static projection*. On that evidence alone the honest conclusion was
+"state dimensionality pays, dynamics do not" — and that conclusion was recorded. It was
+wrong. The two subsystems had never been allowed to exchange anything: x₁₂ saw only Ω, x₄₂
+saw only the hidden state.
+
+**2. Coupling them is the largest effect in this document.** Following the same construction
+`THEORY_42D_HYPER_COSMIC.md` already uses *within* a band and *between* bands, applied one
+level up between the subsystems — the 12D tone modulating the 42D's gain multiplicatively,
+the 42D feeding back additively — beats the previous best by −0.081 (t = −10.9, 3/3) for
+**12,730 extra parameters**. Two checks that this is the coupling rather than capacity: the
+cross-coupling matrices **grew 3.0–3.4× during training** in all three seeds (they start
+damped at 0.1), and real-word rate is **0.839 against a 0.831 baseline**, so it is not
+buying cross-entropy by degrading language the way `dyn42` alone does (0.755, 0/3).
+
+**3. State is far cheaper than weights.** Per parameter:
+
+```
+dyn12      2,412 extra params  ->  -0.04907   =  2.03e-5 nats/param
+static54  41,472 extra params  ->  -0.07462   =  1.80e-6
+dyn42     47,754 extra params  ->  -0.07159   =  1.50e-6
+dyn54     50,166 extra params  ->  -0.05562   =  1.11e-6
+```
+
+Twelve scalars and a leaky integrator return **66% of a projection 17× larger**, with the
+highest consistency on the board, at **11× the parameter efficiency of anything else**. The
+paper's §5 Singularity Hypothesis states this as *"a smaller model can beat a larger
+one"* — which did **not** hold; `static54` beat `dyn54` outright. The form that did hold is
+*"internal state is dramatically cheaper than parameters"*. Those are different claims and
+only the second is supported here.
 
 *The retraction above is kept rather than deleted because it is the clearest example in this
 document of the failure mode described in §8: a confident negative that was entirely about
@@ -409,9 +514,13 @@ weights whose every initial value came from measured IBM Quantum hardware. What
 it: the φ-governed scaffold the paper specifies — RMSNorm, RoPE, `d_ff = ⌊d·φ⌋`, φ-scaled
 initialisation. The shipped architecture implements §3's kernel inside a conventional
 transformer. A grep of the source tree found no implementation of the φ scaffold at all,
-which means every §3 measurement in §6 was made in the wrong building. That replication is
-pending, and until it lands the §6 result should be read as *"the kernel does not help in a
-conventional transformer"*, not as a verdict on the paper.
+which means every §3 measurement in §6 was made in the wrong building.
+
+That replication has since been run, and it reverses the result: the kernel loses 0/3 in a
+conventional transformer and wins 6/6 across two φ-governed variants (§6). **The shipped
+`llama_cpp_cosmos.cpp` therefore implements the weaker of the two architectures.** Bringing
+it up to the paper — RMSNorm, RoPE, `d_ff = ⌊d·φ⌋` — is the obvious next step and is
+*less* custom C++ than what is there now, since llama.cpp provides all three natively.
 
 ---
 

README.md

@@ -158,14 +158,66 @@ H(x₅₄)ᵢⱼ = exp( −‖x₅₄ᵢ − x₅₄ⱼ‖² / 2σ² )        Ga
 A_final  = (1 − g)·A_std + g·H(x₅₄)             learned gate g = sigmoid(param)
 ```
 
-**Measured result** (5 seeds, paired, control = `g` forced to 0, i.e. exactly standard attention):
+### It took four attempts to test this honestly
 
-| arm | best val loss |
-|---|---|
-| control (standard attention) | 1.2885 |
-| **spatial-injection trajectory** | **1.2629** |
+The mechanism was reported as **null** three times. Every one of those was the instrument,
+not the idea, and each fix revealed the next fault underneath:
 
-**Δ = +0.0256 versus control, reproduced across six independent seed vectors and 39 training runs.** The mechanism works.
+| attempt | what shipped | why it was inert |
+|---|---|---|
+| reference repo, 12D | `Ω` summed over keys instead of queries | softmax already normalises that axis, so **Ω ≡ 1.0** for every token (measured std 5.1e-08). Every token converged to the same state, `H` became the all-ones matrix, and `β·H` is a constant added to every logit — which cancels **exactly** in softmax |
+| v1 | gate at `sigmoid(−4)` | saturated tail, gradient suppressed ~56× |
+| v2 | gate clamped to `[0,1]` | `torch.clamp` has *zero* gradient outside its bounds, so the first step below 0 pinned it there permanently |
+| v3 | σ hardcoded to `exp(0) = 1` | measured median pairwise `‖x₅₄ᵢ−x₅₄ⱼ‖²` is **61.98**, so `exp(−31)` underflows and **H arrives as the identity matrix** (diagonal mass 0.9998 vs 0.0078 for uniform). Blending in the identity says "attend only to yourself", so descent was *correct* to kill the gate |
+
+**§3.2 of the paper never assigns σ a value.** That is not a deviation from the spec, it is a
+hole in it, and any implementation leaving σ at 1 reproduces the identity-matrix failure.
+Calibrating it per layer from the data (`2σ² = median(d²)`) raised the gradient reaching the
+54D projection by **124×**.
+
+### The measured result
+
+Once the mechanism could actually be used, and once the paper's φ-governed scaffold was
+built (RMSNorm, RoPE, `d_ff = ⌊d·φ⌋`, φ-scaled init — **none of which had ever been
+implemented**), the kernel was tested one component at a time. Same corpus, same
+quantum-born init, same seeds, gate free to move, 1200 steps × 3 seeds:
+
+| state feeding the kernel | val loss | vs baseline | t | wins | params |
+|---|---|---|---|---|---|
+| none (baseline) | 1.44680 | — | — | 0/3 | 1,135,008 |
+| `dyn12` — 12 scalars, Ω-driven leaky integrator | 1.39773 | −0.049 | −10.5 | 3/3 | 1,137,420 |
+| `dyn54` — 12D and 42D concatenated | 1.39118 | −0.056 | −3.9 | 3/3 | 1,185,174 |
+| `static54` — plain projection of the hidden state | 1.37218 | −0.075 | −7.4 | 3/3 | 1,176,480 |
+| `dyn42` — 42D vector state, 42×42 coupling | 1.37521 | −0.072 | −7.9 | 3/3 | 1,182,762 |
+| **`tri` — 12D and 42D *coupled*** | **1.29152** | **−0.155** | **−40.8** | **3/3** | 1,189,210 |
+
+**Every configuration beats the baseline on every seed.** The mechanism is real.
+
+**The ordering is the finding.** Concatenating the 12D and 42D states (`dyn54`) is *worse*
+than a plain static projection. **Coupling** them — the 12D tone modulating the 42D's gain
+multiplicatively, the 42D feeding back additively — beats everything by roughly double the
+next best, for **12,730 extra parameters**. The organs had to talk to each other; gluing
+their vectors together achieved nothing.
+
+Two independent checks that this is the coupling and not extra capacity:
+
+- the cross-coupling matrices **grew 3.0–3.4× during training** in all three seeds. They
+  start damped at 0.1; the optimiser reached for them.
+- real-word rate is **0.839, above the 0.831 baseline** — it is not buying cross-entropy by
+  degrading language, which is exactly what `dyn42` alone does (0.755, 0/3 seeds).
+
+**And on cost:** `dyn12` — twelve scalars and a leaky integrator, **2,412 parameters** — buys
+66% of what a projection 17× larger buys, at the *highest* consistency on the board. Per
+parameter it is **11× more efficient than anything else tested**. The defensible form of the
+paper's "Singularity Hypothesis" is not *"a smaller model beats a larger one"* but
+***"internal state is dramatically cheaper than weights."*** The second one held.
+
+**Limits, plainly:** 1.2M parameters, character-level, one corpus, three seeds per arm,
+t-tests on 2 degrees of freedom, 1200 steps. This is evidence the mechanism works on this
+data at this scale. It is not a claim about transformers in general.
+
+Reproduce with `architecture/cosmos_state_ladder.py`, which refuses to report any rung until
+it has proven the mechanism is live — see §4c.
 
 ---
 
@@ -184,6 +236,11 @@ Scripts are in the Genesis Engine kit. All use fixed seeds and deterministic hel
 
 ## 4. Null results, please read before citing
 
+**Scope: this section is about the *quantum* claims only.** The architecture claim in §2 is a
+separate question with a separate answer — the Hebbian mechanism is **not** null, it beats
+its baseline on every seed of every configuration tested. Quantum entropy buys provenance;
+the architecture buys accuracy. Do not read these two results as one.
+
 This project's quantum claims were tested at **five** distinct injection points. **All five are null** against matched classical controls:
 
 | injection site | result |
@@ -236,6 +293,41 @@ nomic-embed-text ranked it correctly (0.7128 vs 0.3717).
 
 ---
 
+## 4c. The preflight discipline (the most reusable thing here)
+
+Four separate implementations of this architecture shipped a mechanism that was
+**mathematically inert** — across two codebases and several years, in different languages,
+by different means. Every one compiled, trained, produced plausible text, and logged nothing
+red. Three of them produced a confident *negative* about the idea.
+
+This is not a class of bug ordinary engineering catches, because there is nothing to catch:
+no exception, no NaN, no failing test. A modulatory mechanism can be complete,
+correct-looking and a no-op. The only way to know is to measure whether its own quantity is
+degenerate.
+
+So `cosmos_state_ladder.py` refuses to report a number until it has proven the mechanism is
+alive. Five assertions, each corresponding to a real failure that shipped:
+
+```
+Omega varies across tokens      caught Omega == 1.0        (std 5.1e-08)
+state varies across tokens      caught the collapsed state (std 3.0e-08)
+H is not the identity           caught sigma = 1           (diag mass 0.9998)
+H is not all-ones               caught the uniform kernel
+gate gradient is unsuppressed   caught sigmoid saturation  (grad / 56)
+```
+
+And a **post-flight** check, because starting alive is not the same as staying alive: report
+each coupling's magnitude before and after training with the growth ratio. A mechanism that
+ends at 1.0× was decorative regardless of what the loss column says. The trinity coupling
+ends at **3.0–3.4×**, which is how we know the result is the coupling and not the parameters.
+
+Two more bugs of exactly this shape were found *while writing the telemetry logger for this
+release* — a schema locked from the first sample that silently dropped 42% of the channels,
+and a column re-sort that would have quietly changed the meaning of every previously written
+row. The failure mode is not rare. Assume your mechanism is inert until it proves otherwise.
+
+---
+
 ## 5. The Genesis Engine (kit)
 
 Birth your own quantum-seeded companion, entirely local:

architecture/cosmos_state_ladder.py

@@ -0,0 +1,582 @@
+#!/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
+
+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"))
+BLOCK, N_LAYER, N_HEAD, N_EMBD, DROPOUT = 128, 4, 4, 192, 0.1
+D12, D42 = 12, 42
+# 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}
+
+
+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") else None
+        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.
+        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") 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
+        s.register_buffer("mask", torch.triu(torch.full((BLOCK, BLOCK), float("-inf")), 1))
+
+    def forward(s, idx, targets=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
+        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]
+        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
+    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")
+    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
+        ix = torch.randint(len(tr) - BLOCK - 1, (16,), generator=gen)
+        x = torch.stack([tr[i:i + BLOCK] for i in ix]).to(DEV)
+        y = torch.stack([tr[i + 1:i + 1 + BLOCK] for i in ix]).to(DEV)
+        _, loss = m(x, y)
+        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.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 {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())

architecture/ladder_results.json

@@ -0,0 +1,227 @@
+{
+  "phi": 1.618033988749895,
+  "steps": 1200,
+  "ffn": "harmonic",
+  "rungs": {
+    "none": {
+      "loss": [
+        1.489819049835205,
+        1.4292490482330322,
+        1.4213251769542694
+      ],
+      "real_word": [
+        0.7980769230769231,
+        0.8301886792452831,
+        0.8660714285714286
+      ],
+      "gates": [
+        0.0,
+        0.0,
+        0.0
+      ],
+      "params": 1135008,
+      "preflight": [
+        [
+          "omega varies across tokens (ver.4.20 had std 5e-08)",
+          1.0457755327224731,
+          0.0001,
+          true
+        ]
+      ]
+    },
+    "static54": {
+      "loss": [
+        1.4319630861282349,
+        1.3560499548912048,
+        1.328529804944992
+      ],
+      "real_word": [
+        0.8504672897196262,
+        0.8636363636363636,
+        0.6902654867256637
+      ],
+      "gates": [
+        0.09207762125879526,
+        0.07932951115071774,
+        0.09114700683858246
+      ],
+      "params": 1176480,
+      "preflight": [
+        [
+          "omega varies across tokens (ver.4.20 had std 5e-08)",
+          1.0790070295333862,
+          0.0001,
+          true
+        ],
+        [
+          "H not the identity (needs << 1.0, uniform = 0.0078)",
+          0.08235120587050915,
+          0.5,
+          true
+        ],
+        [
+          "H not all-ones (needs non-zero spread)",
+          0.018231534399092197,
+          1e-06,
+          true
+        ],
+        [
+          "gate gradient not suppressed",
+          0.0005416385520220501,
+          1e-06,
+          true
+        ]
+      ]
+    },
+    "dyn12": {
+      "loss": [
+        1.4314345121383667,
+        1.3857606947422028,
+        1.3759903013706207
+      ],
+      "real_word": [
+        0.7641509433962265,
+        0.8557692307692307,
+        0.8785046728971962
+      ],
+      "gates": [
+        0.09719929983839393,
+        0.08815469185356051,
+        0.079276381758973
+      ],
+      "params": 1137420,
+      "preflight": [
+        [
+          "omega varies across tokens (ver.4.20 had std 5e-08)",
+          1.0405222177505493,
+          0.0001,
+          true
+        ],
+        [
+          "state varies across tokens (ver.4.20 had std 3e-08)",
+          0.23312585055828094,
+          0.0001,
+          true
+        ],
+        [
+          "H not the identity (needs << 1.0, uniform = 0.0078)",
+          0.08387190662324429,
+          0.5,
+          true
+        ],
+        [
+          "H not all-ones (needs non-zero spread)",
+          0.018558258656412363,
+          1e-06,
+          true
+        ],
+        [
+          "gate gradient not suppressed",
+          0.0004660986942326417,
+          1e-06,
+          true
+        ]
+      ]
+    },
+    "dyn42": {
+      "loss": [
+        1.4255140125751495,
+        1.3684590756893158,
+        1.3316525220870972
+      ],
+      "real_word": [
+        0.7387387387387387,
+        0.7767857142857143,
+        0.75
+      ],
+      "gates": [
+        0.07997925241943449,
+        0.08405673876404762,
+        0.08927735965698957
+      ],
+      "params": 1182762,
+      "preflight": [
+        [
+          "omega varies across tokens (ver.4.20 had std 5e-08)",
+          1.0265097618103027,
+          0.0001,
+          true
+        ],
+        [
+          "state varies across tokens (ver.4.20 had std 3e-08)",
+          0.2613561451435089,
+          0.0001,
+          true
+        ],
+        [
+          "H not the identity (needs << 1.0, uniform = 0.0078)",
+          0.08344549313187599,
+          0.5,
+          true
+        ],
+        [
+          "H not all-ones (needs non-zero spread)",
+          0.018301507458090782,
+          1e-06,
+          true
+        ],
+        [
+          "gate gradient not suppressed",
+          0.00041668380163173424,
+          1e-06,
+          true
+        ]
+      ]
+    },
+    "dyn54": {
+      "loss": [
+        1.4351611733436584,
+        1.397896021604538,
+        1.340474545955658
+      ],
+      "real_word": [
+        0.8468468468468469,
+        0.8290598290598291,
+        0.8363636363636363
+      ],
+      "gates": [
+        0.07990668143611401,
+        0.08107478066813201,
+        0.08647420140914619
+      ],
+      "params": 1185174,
+      "preflight": [
+        [
+          "omega varies across tokens (ver.4.20 had std 5e-08)",
+          1.0531880855560303,
+          0.0001,
+          true
+        ],
+        [
+          "state varies across tokens (ver.4.20 had std 3e-08)",
+          0.26182109117507935,
+          0.0001,
+          true
+        ],
+        [
+          "H not the identity (needs << 1.0, uniform = 0.0078)",
+          0.08133717067539692,
+          0.5,
+          true
+        ],
+        [
+          "H not all-ones (needs non-zero spread)",
+          0.018136915285140276,
+          1e-06,
+          true
+        ],
+        [
+          "gate gradient not suppressed",
+          0.00032850746356416494,
+          1e-06,
+          true
+        ]
+      ]
+    }
+  }
+}

architecture/trinity_results.json

@@ -0,0 +1,57 @@
+{
+  "phi": 1.618033988749895,
+  "steps": 1200,
+  "ffn": "harmonic",
+  "rungs": {
+    "tri": {
+      "loss": [
+        1.342146247625351,
+        1.2697823345661163,
+        1.2626399397850037
+      ],
+      "real_word": [
+        0.7798165137614679,
+        0.8504672897196262,
+        0.8857142857142857
+      ],
+      "gates": [
+        0.08206335990689695,
+        0.08856846345588565,
+        0.09198464138898998
+      ],
+      "params": 1189210,
+      "preflight": [
+        [
+          "omega varies across tokens (ver.4.20 had std 5e-08)",
+          1.0595414638519287,
+          0.0001,
+          true
+        ],
+        [
+          "state varies across tokens (ver.4.20 had std 3e-08)",
+          0.28298282623291016,
+          0.0001,
+          true
+        ],
+        [
+          "H not the identity (needs << 1.0, uniform = 0.0078)",
+          0.08863257616758347,
+          0.5,
+          true
+        ],
+        [
+          "H not all-ones (needs non-zero spread)",
+          0.01890878053382039,
+          1e-06,
+          true
+        ],
+        [
+          "gate gradient not suppressed",
+          0.00061029166681692,
+          1e-06,
+          true
+        ]
+      ]
+    }
+  }
+}

serving/log_paired_state.py

@@ -0,0 +1,156 @@
+#!/usr/bin/env python3
+"""
+PAIRED STATE LOGGER -- record her body so it can be joined to what she says.
+
+WHY
+  Her memories carry created_at timestamps and her turn events carry event_id timestamps,
+  but neither carries a physics snapshot: the archival record's metadata field is empty.
+  The only physics recording on disk is logs/live_state_trajectory.json -- 2,400 rows at
+  8.73 Hz, which is 275 SECONDS. Her speech spans 13 days. So the two streams cannot be
+  joined today, not because the data model forbids it but because nobody was recording
+  both at once.
+
+  This starts that clock. Physics goes here with wall-clock timestamps; her utterances are
+  already timestamped in data/runtime/turn_events/events.jsonl. The join is offline and
+  trivial once both cover the same window.
+
+WHY IT MATTERS
+  If conditioning on her body state lowers held-out loss on what she actually said, then
+  "experience-modulated attention" (paper section 3.2) is a measurable claim rather than an
+  interpretation. That test needs paired data, and paired data needs someone to press
+  record. Text and physics are two recordings of one moment -- that is what makes held-out
+  loss a legitimate scorer here.
+
+FORMAT
+  header.json   field names, once, in column order
+  YYYYMMDD.jsonl  {"t": <epoch seconds>, "v": [...]}  one row per sample
+
+  Only numeric fields that actually vary are kept (42 of the 53 in the reference
+  trajectory), rounded to 5 decimals. Roughly 35 MB/day at 1 Hz.
+
+  Writes OUTSIDE OneDrive by default: a file appended once a second inside a synced folder
+  produces constant upload churn and was the source of the WinError 5 replace failures
+  earlier in this project. Override with COSMOS_TELEMETRY_DIR.
+
+USAGE
+  python tools/log_paired_state.py [hz] [state_url]
+"""
+import json
+import os
+import sys
+import time
+import urllib.request
+from datetime import datetime, timezone
+from pathlib import Path
+
+sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+
+HZ = float(sys.argv[1]) if len(sys.argv) > 1 else 1.0
+URL = sys.argv[2] if len(sys.argv) > 2 else "http://127.0.0.1:8765/state"
+OUT = Path(os.getenv("COSMOS_TELEMETRY_DIR", r"C:\cosmos_telemetry"))
+
+
+def flatten(o, prefix=""):
+    """Nested dict -> {dotted.path: value} for scalar leaves only."""
+    out = {}
+    if isinstance(o, dict):
+        for k, v in o.items():
+            out.update(flatten(v, f"{prefix}.{k}" if prefix else str(k)))
+    elif isinstance(o, (int, float, bool)) and not isinstance(o, bool):
+        out[prefix] = float(o)
+    elif isinstance(o, bool):
+        out[prefix] = 1.0 if o else 0.0
+    return out
+
+
+def poll():
+    with urllib.request.urlopen(URL, timeout=4) as r:
+        return flatten(json.loads(r.read()))
+
+
+def main():
+    OUT.mkdir(parents=True, exist_ok=True)
+    print(f"  polling {URL} at {HZ} Hz -> {OUT}")
+
+    # SCHEMA WARM-UP. /state does not return a stable key set: cosmos_packet.* is present
+    # in some polls and absent in others. Locking the column order to the first sample
+    # would drop every channel that happens to be missing at that instant, permanently and
+    # silently -- the same shape of bug as everything else this project has been chasing.
+    # Union the keys over a warm-up window instead, then fix the order.
+    seen, t_end = set(), time.time() + 30.0
+    while not seen or time.time() < t_end:
+        try:
+            seen |= set(poll().keys())
+        except Exception as e:
+            if not seen:
+                print(f"  waiting for sensory server ({type(e).__name__}) ...", flush=True)
+                t_end = time.time() + 30.0
+            time.sleep(2)
+            continue
+        time.sleep(0.5)
+    fields = sorted(seen)
+    grew = []
+    (OUT / "header.json").write_text(json.dumps(
+        {"fields": fields, "hz": HZ, "url": URL, "grew": grew,
+         "note": "columns are append-only; a row shorter than fields is missing its tail",
+         "started": datetime.now(timezone.utc).isoformat()}, indent=2), encoding="utf-8")
+    print(f"  {len(fields)} numeric channels; header written", flush=True)
+
+    period = 1.0 / max(HZ, 1e-6)
+    day, fh, n, miss = None, None, 0, 0
+    try:
+        while True:
+            t0 = time.time()
+            try:
+                s = poll()
+                new = set(s) - set(fields)
+                if new:
+                    # A channel appeared after warm-up. APPEND it -- never re-sort. Sorting
+                    # the union would insert new names in the middle of the column order,
+                    # which does not merely make old rows short, it silently changes what
+                    # every previously written number MEANS. Appending keeps every existing
+                    # index valid forever; short rows are simply missing their tail.
+                    fields = fields + sorted(new)
+                    grew.append({"t": round(t0, 3), "n_fields": len(fields),
+                                 "added": sorted(new)})
+                    print(f"  NEW CHANNELS (appended): {sorted(new)}", flush=True)
+                    (OUT / "header.json").write_text(json.dumps(
+                        {"fields": fields, "hz": HZ, "url": URL, "grew": grew,
+                         "note": "columns are append-only; a row shorter than fields is "
+                                 "missing its tail, indices never shift"},
+                        indent=2), encoding="utf-8")
+                row = [None if k not in s else round(s[k], 5) for k in fields]
+                d = datetime.now().strftime("%Y%m%d")
+                if d != day:
+                    if fh:
+                        fh.close()
+                    fh = open(OUT / f"{d}.jsonl", "a", encoding="utf-8")
+                    day = d
+                    print(f"  -> {OUT / (d + '.jsonl')}", flush=True)
+                fh.write(json.dumps({"t": round(t0, 3), "v": row},
+                                    separators=(",", ":")) + "\n")
+                n += 1
+                # flush often: this runs for days, and an unflushed buffer is data that
+                # only exists until something crashes
+                if n % 20 == 0:
+                    fh.flush()
+                if n % 600 == 0:
+                    print(f"  {n} samples, {miss} misses, {time.strftime('%H:%M:%S')}",
+                          flush=True)
+            except Exception:
+                # her voice must never be blocked by telemetry; a dropped sample is fine
+                miss += 1
+                if miss % 60 == 1:
+                    print(f"  sensory server unreachable ({miss} misses)", flush=True)
+            time.sleep(max(0.0, period - (time.time() - t0)))
+    except KeyboardInterrupt:
+        pass
+    finally:
+        if fh:
+            fh.close()
+        print(f"  stopped after {n} samples")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())