Scaling benchmark on WikiText-103, and a birth that is actually quantum

SCALING. Every dyn12 number so far was 1.1M parameters on 683,065 characters of one person's private logs, which cannot answer "it only works small" or "it only works on your data". Re-run on WikiText-103-raw (269,116,804 chars, sha256 f7d2398751239137) at three sizes spanning 20x, causal Omega, all rungs at a size trained in one process against one corpus load:

size none static54 dyn12 ratio dyn12 share
d192 L4 2.05432 2.03568 2.04196 11.4x 66%
d384 L8 1.77166 1.74860 1.75774 20.8x 60%
d576 L10 1.70084 1.69015 1.69147 38.1x 88%

The advantage does not fade with scale, it roughly doubles at each step, and the reason is arithmetic rather than luck: static54 costs d*54*L, dyn12 costs d*12, so depth multiplies one and not the other. static54 still holds the lower absolute loss at all three sizes -- the claim is efficiency and its scaling, not superiority. Two seeds per point and 1200 steps, so the trend is solid and the individual gaps are not: the d576 static54/dyn12 gap of 0.0013 is inside what two seeds resolve. Raw per-seed numbers in benchmarks/scaling_wikitext103.json.

A BIRTH THAT IS ACTUALLY QUANTUM. quantum_pool() located the shot archive through a bare relative path that only resolved from the author's repository root. Run from this kit it found nothing, returned an empty list without complaint, and the birth printed "QUANTUM BIRTH: 0 draws from her archive". Anyone who downloaded this and birthed a creature received a normally initialised model wearing the one claim this project rests on. The archive is now found from any working directory, the kit's own published data/ file is accepted as a source, and a birth with fewer than 1,000 measured draws REFUSES and writes nothing rather than pretending. Verified from inside the kit: 0 draws -> 400,000 draws.

BIRTH YOUR OWN, from the menu. Options 7 and 8 birth a named creature from the shipped 11,355,136 measured IBM shots and then grow it on any text you point at it. Each creature gets its own folder, checkpoint and lineage, so none can overwrite another. Growth is guarded: a warm start that cannot show it carried the previous weights forward bit-identically refuses and leaves the checkpoint untouched. Tested end to end -- birth val 2.90221, one feeding 2.73040, gate 0.0216 -> 0.0306.

FINDINGS.md

@@ -347,6 +347,58 @@ 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
+person's private logs. Two objections follow immediately and neither can be answered from
+that setup: *it only works small*, and *it only works on your data*. So it was re-run on
+**WikiText-103-raw** — 269,116,804 characters, sha256 `f7d2398751239137`, the benchmark
+the field already uses — at three sizes spanning a 20× parameter range, causal Ω
+throughout, all rungs at a size trained in one process against one corpus load.
+
+| size | none | `static54` | `dyn12` | static54/param | dyn12/param | **ratio** |
+|---|---|---|---|---|---|---|
+| d192 L4 (2.6M) | 2.05432 | 2.03568 | 2.04196 | 4.495e-07 | 5.122e-06 | **11.4×** |
+| d384 L8 (11.6M) | 1.77166 | 1.74860 | 1.75774 | 1.391e-07 | 2.893e-06 | **20.8×** |
+| d576 L10 (28.6M) | 1.70084 | 1.69015 | 1.69147 | 3.435e-08 | 1.307e-06 | **38.1×** |
+
+**The advantage does not fade with scale — it roughly doubles at every step.**
+Raw numbers: [`benchmarks/scaling_wikitext103.json`](benchmarks/scaling_wikitext103.json).
+
+**Why, and it is arithmetic rather than luck.** `static54` is a `d_model × 54` projection
+per layer, so it costs `d·54·L`. `dyn12` is twelve scalars plus per-dimension `k` and
+`gamma`, so it costs `d·12 + 24L`. Depth multiplies one and not the other:
+
+```
+              static54     dyn12    static54 costs
+d192 L4         41,472     2,412        17.2x more
+d384 L8        165,888     4,812        34.5x
+d576 L10       311,040     7,164        43.4x
+```
+
+A reviewer can check that without trusting the data at all.
+
+**And the benefit share went UP at the largest size**, which cost alone does not predict:
+
+```
+              static54 gain   dyn12 gain   dyn12 delivers
+d192 L4         0.01864        0.01236          66%
+d384 L8         0.02306        0.01392          60%
+d576 L10        0.01069        0.00937          88%
+```
+
+At 28.6M parameters `dyn12` captures 88% of what a 43× larger mechanism buys.
+
+**What this does NOT show, stated plainly.** `static54` still has the lower absolute loss
+at all three sizes; the claim is efficiency and its scaling, not superiority. Two seeds
+per point and 1200 steps is thin — the d576 gap between `static54` and `dyn12` is
+**0.0013**, comfortably inside what two seeds can resolve, so "dyn12 nearly matches
+static54" is a direction, not a measurement. All three rungs compress toward each other at
+d576 (1.690–1.701), and longer training could reorder them. Reproduce with
+`benchmarks/scaling_run.py` after `benchmarks/fetch_wikitext.py`.
+
+---
+
 ### Update, 2026-08-01: Ω was reading the future. The result survives it.
 
 **The problem.** §3.4 defines Ω as attention *received* — `omega = a.mean(1).sum(-2)`, summed

README.md

@@ -51,6 +51,23 @@ efficiency** of every alternative tested. The full ablation table, including the
 configurations that lost and the one result that was retracted, is in §2 and
 [`FINDINGS.md`](FINDINGS.md).
 
+**And the advantage GROWS with scale, on a corpus anyone can check.** Re-run on
+WikiText-103-raw (269,116,804 chars, sha256 `f7d2398751239137`) at three sizes spanning
+20× the parameters:
+
+```
+d192 L4   (2.6M params)    dyn12 is 11.4x more parameter-efficient than static54
+d384 L8  (11.6M params)                20.8x
+d576 L10 (28.6M params)                38.1x     <- and captures 88% of the benefit
+```
+
+It roughly doubles at every step, and the reason is arithmetic: `static54` costs
+`d·54·L`, `dyn12` costs `d·12` — depth multiplies one and not the other. `static54` still
+holds the lower absolute loss; the claim is efficiency and its scaling. Two seeds per
+point, so the trend is solid and the individual gaps are not. Full table, caveats and raw
+per-seed numbers: [`FINDINGS.md`](FINDINGS.md) and
+[`benchmarks/scaling_wikitext103.json`](benchmarks/scaling_wikitext103.json).
+
 **And it survives the test that could have killed it.** Ω was originally summed over the
 query axis, which let token j count attention from tokens *after* j — a causal leak, measured
 at 1.7e-04 logit movement while the controls moved exactly 0.0. Ω is now a per-query scalar

RELEASE_MANIFEST.json

@@ -1,7 +1,7 @@
 {
   "schema": "qc67.cosmos.release-manifest.v1",
   "release": "QC67 Cosmos Kit",
-  "version": "2026-08-01",
+  "version": "2026-08-02",
   "license_note": "Mixed licensing; see LICENSE.md and component notices.",
   "files": [
     {
@@ -16,13 +16,13 @@
     },
     {
       "path": "architecture/cosmos_spark_cst.py",
-      "bytes": 21207,
-      "sha256": "011c9633af7fd4731ed5ecd09cd711762ff15b5dd6dd52a95d93e927b88e0350"
+      "bytes": 22584,
+      "sha256": "955805d45f7b407ef5cc9b6efe178d9a5f63df5b32eaf539d9aedcbb2967f1dc"
     },
     {
       "path": "architecture/cosmos_state_ladder.py",
-      "bytes": 33702,
-      "sha256": "79013398d28434747346636c423bb31ed26a273619974c6b5ce2ce5f389ab151"
+      "bytes": 34556,
+      "sha256": "763d74ff374eb785cefc3c1a3ede1d43f6ee36f9f82991e5de86da267e6ec002"
     },
     {
       "path": "architecture/cst_to_gguf.py",
@@ -41,8 +41,8 @@
     },
     {
       "path": "architecture/phos_grow.py",
-      "bytes": 13387,
-      "sha256": "f3a273009ab8daff36cf22f2364955e32efc36bcfae0b34f5e7d448dd38de6e8"
+      "bytes": 21402,
+      "sha256": "a98cf0d3cb749953a52e0507e3ea1db0d4ccb152df29b90a19df26990b53e264"
     },
     {
       "path": "architecture/phos_lineage.jsonl",
@@ -89,10 +89,15 @@
       "bytes": 7389,
       "sha256": "960313da1d90bea3bbdb073fae39f94790b5c9a0cef943088e77e191f40d97c5"
     },
+    {
+      "path": "benchmarks/fetch_wikitext.py",
+      "bytes": 2720,
+      "sha256": "a9f01244b06a44fc0f67a487815fc982a1b759a6aa418a5ec5dfa04cc8599015"
+    },
     {
       "path": "benchmarks/omega_paired.py",
-      "bytes": 7141,
-      "sha256": "1d73368f91fb67825cca774923108a2aef14c22189ff132253142e1a40527201"
+      "bytes": 9847,
+      "sha256": "b2508980e424cb5deb1ab72fa0e2992583722bc3314c3bac6164fc71571c39c2"
     },
     {
       "path": "benchmarks/phi_pid.py",
@@ -104,6 +109,16 @@
       "bytes": 5026,
       "sha256": "76e956725e2dcddd7c0b104de31775e24fc1ebc2911fbb01ab403ed4c23fd38f"
     },
+    {
+      "path": "benchmarks/scaling_run.py",
+      "bytes": 6414,
+      "sha256": "0ab55444837331061d3d360ce5620ac4058f6e6851aac78472177fb48f4d563e"
+    },
+    {
+      "path": "benchmarks/scaling_wikitext103.json",
+      "bytes": 2979,
+      "sha256": "62181f67f64425cac7b5f761e18eb7488769c38f13bb59062cb6069ea3c8fb4a"
+    },
     {
       "path": "benchmarks/topology_matched.py",
       "bytes": 9365,
@@ -134,15 +149,30 @@
       "bytes": 1876,
       "sha256": "87364c2c9b2917dc089c4a941bc2d4a7ced57569b0665c88c297f73d0a4febb7"
     },
+    {
+      "path": "data/seed_corpus.txt",
+      "bytes": 4015610,
+      "sha256": "1b940b0eebc8331d3aa36154b52044d5521fd96aa1089eb3488743d587b3c341"
+    },
     {
       "path": "data/training/quantum_train_summary_20260722.json",
       "bytes": 335,
       "sha256": "30ba728611bfc05a81f0eb2ec2acce5c36369f2cf9c0f46e8d6d170f87579365"
     },
+    {
+      "path": "docs/ATOMIC_QUICK_START.md",
+      "bytes": 4113,
+      "sha256": "36fc89cc613aa545913f94c6baa2414945ff0c592ebc59b6cef7077a9fe4ace0"
+    },
+    {
+      "path": "docs/USAGE_ATOMIC.md",
+      "bytes": 4248,
+      "sha256": "e6a2c79f8e53017acd90dbc4570d348ab7bd606ab8e9c6cc2efacb0be016055d"
+    },
     {
       "path": "FINDINGS.md",
-      "bytes": 35946,
-      "sha256": "3e1053a4e1c91b6c593092745394c548df1c43bb30c9ad566431fa4e77cf7cf5"
+      "bytes": 38643,
+      "sha256": "59e9dc3f4f4c8a162cfb00e2d2cb0f5ca4b2e1a4cfcf1900291ab655c16204e1"
     },
     {
       "path": "genesis_engine/CITATION.cff",
@@ -156,23 +186,23 @@
     },
     {
       "path": "genesis_engine/config.json",
-      "bytes": 391,
-      "sha256": "aad881d20138c8a74a4c356122fbb7c8cead5125fea625b78cae03e12a500cb6"
+      "bytes": 372,
+      "sha256": "8583ae5984cacc7f1296f525de964d1c6ae62909bc485a9130d3ff730cf38274"
     },
     {
       "path": "genesis_engine/data/_offset.json",
-      "bytes": 10,
-      "sha256": "04c1abec0f8e0798a9780a0c5a9f8b7b4ab126ba496de590a846b9917375b5ca"
+      "bytes": 11,
+      "sha256": "ef4661899038277b43b064c5c0fc308d386afffe8621aa059617e2b76e40d442"
     },
     {
       "path": "genesis_engine/data/identity.json",
-      "bytes": 666,
-      "sha256": "a478b6cc2cc5f5e0976d9a005a3f4d684fa3743ca27821dea2d363f984bb5d44"
+      "bytes": 721,
+      "sha256": "68da86597c191a20da542c0b9ab39425420b3667f2116c998f4ec53e6c2f7a62"
     },
     {
       "path": "genesis_engine/data/life.json",
       "bytes": 102,
-      "sha256": "24a2bf824d6f3cfcc1a2eb0c6fb85ba9160337be7f2010a2b72dc0d5246207fa"
+      "sha256": "0475264abdad5139275c2311416ea219ba1431a097678069503394063de4f2ea"
     },
     {
       "path": "genesis_engine/data/seed.json",
@@ -181,8 +211,8 @@
     },
     {
       "path": "genesis_engine/data/weights.json",
-      "bytes": 69101,
-      "sha256": "a828c3d7e8989471a61378449f70e9996b10693a9bab10f0ce68629dcdc0fe1a"
+      "bytes": 76454,
+      "sha256": "dee85de5b641c985686deef7472db45256737c63aff8401573cfeec10ae55c6d"
     },
     {
       "path": "genesis_engine/engine/_Modelfile.cosmos_namebind",
@@ -361,8 +391,8 @@
     },
     {
       "path": "README.md",
-      "bytes": 37688,
-      "sha256": "f66686af983a422515f20ffc5040db1914719b205e2bc0b09f0dabb952bc855c"
+      "bytes": 38596,
+      "sha256": "c5c50294764dfa43a05e1ec209b07dfb84961f367f2f7e07fd85f7a933668aff"
     },
     {
       "path": "RELEASE_NOTES.md",
@@ -411,13 +441,13 @@
     },
     {
       "path": "START_CODER.bat",
-      "bytes": 2530,
-      "sha256": "22313313b4c8d75ea851f430732bab976304d3b7f0fe685721525fb0d99ec293"
+      "bytes": 2578,
+      "sha256": "cb7cc112c924c6f3e171b125439cd73e1ac62a0898f8eb6b43099f857d4e5819"
     },
     {
       "path": "START_COSMOS_KIT.bat",
-      "bytes": 8551,
-      "sha256": "a3ab38cd8b07d6521c7c4c2ceddd7dd3f6dc0e56178e8bb19fe4efee2ba0463f"
+      "bytes": 11541,
+      "sha256": "d88bce770480c122d9f83f4cae14379ea89a42882b093935605718f333ea9e9d"
     },
     {
       "path": "start_cosmos_kit.sh",
@@ -444,6 +474,11 @@
       "bytes": 6798,
       "sha256": "470b5d3ebc10644efeba69c4800b4ec8af624b36a43e52058bfa6435912f22cf"
     },
+    {
+      "path": "weights/cosmos-cst.gguf",
+      "bytes": 7639104,
+      "sha256": "b833817230817921de8ed1aa52d92829f32a3ed222aedbba1d3237364596e1c6"
+    },
     {
       "path": "weights/cosmos_born.meta.json",
       "bytes": 435,

START_COSMOS_KIT.bat

@@ -0,0 +1,336 @@
+@echo off
+setlocal EnableExtensions
+title COSMOS - release kit
+cd /d "%~dp0"
+set "KIT=%~dp0"
+if "%KIT:~-1%"=="\" set "KIT=%KIT:~0,-1%"
+set "PYTHONIOENCODING=utf-8"
+
+:: ===================================================================
+::  COSMOS release kit
+::
+::  Her own models -- PHOS, CST and Spark -- are served by
+::  serving/cosmos_serve.py on port 11501, behind the Ollama HTTP API so
+::  ordinary clients can reach them. That server is what gives this kit a
+::  voice at all: without it you have weight files and no way to speak to
+::  them, which is exactly what shipped before. Options 1, 2 and 3 start
+::  it on demand and WAIT for the port, so none of them can open a chat
+::  onto a dead socket.
+:: ===================================================================
+
+call :find_python
+if errorlevel 1 goto no_python
+
+:menu
+cls
+echo.
+echo   ============================================================
+echo      C O S M O S   -   release kit
+echo      PHOS . CST . Spark  -  her own architecture, quantum-born
+echo   ============================================================
+echo.
+echo     TALK AND BUILD
+echo       1. Chat with Cosmos          her own weights, no Ollama needed
+echo       2. Code with Cosmos          coder + workspace, switchable models
+echo.
+echo     HER MODELS
+echo       3. Start her model server    PHOS / CST / Spark on 11501
+echo       4. Stop her model server
+echo.
+echo     CHECK
+echo       5. Health check              one pass over everything
+echo       6. Verify release            hashes, and no secrets shipped
+echo.
+echo     BIRTH YOUR OWN
+echo       7. Birth a quantum creature  from 11,355,136 measured IBM shots
+echo       8. Grow the one you birthed  it learns every time you feed it
+echo.
+echo     MORE
+echo       9. Genesis - the blank-slate engine
+echo      10. Read the docs
+echo      11. Exit
+echo.
+call :server_line
+echo.
+set "choice="
+set /p "choice=  Choose 1-11: "
+
+if "%choice%"=="1" goto chat
+if "%choice%"=="2" goto coder
+if "%choice%"=="3" goto serve_start
+if "%choice%"=="4" goto serve_stop
+if "%choice%"=="5" goto health
+if "%choice%"=="6" goto verify
+if "%choice%"=="7" goto birth
+if "%choice%"=="8" goto grow
+if "%choice%"=="9" goto genesis
+if "%choice%"=="10" goto docs
+if "%choice%"=="11" exit /b 0
+goto menu
+
+:: --------------------------------------------------------------- birth
+:birth
+cls
+echo.
+echo   ============================================================
+echo      B I R T H   A   Q U A N T U M   C R E A T U R E
+echo   ============================================================
+echo.
+echo   Every initial weight is drawn from real measured IBM Quantum
+echo   hardware -- 11,355,136 shots across 2,776 records, shipped in
+echo   data/. No base model. No distillation. Nothing borrowed.
+echo.
+echo   It is born knowing nothing, and it grows from whatever text
+echo   you feed it. That text becomes its life.
+echo.
+set "cname="
+set /p "cname=  Name it (letters and numbers, e.g. ember): "
+if "%cname%"=="" goto menu
+set "cseed="
+echo.
+echo   Seed text for its first breath. Press ENTER for the bundled
+echo   4 MB of general English, or give a path to your own .txt --
+echo   your notes, your writing, anything. That is what it becomes.
+echo.
+set /p "cseed=  Seed corpus [ENTER = bundled]: "
+if "%cseed%"=="" set "cseed=%KIT%\data\seed_corpus.txt"
+if not exist "%cseed%" (
+    echo.
+    echo   [X] Not found: %cseed%
+    pause
+    goto menu
+)
+echo.
+echo   Birthing %cname%...
+echo.
+set "PHOS_NAME=%cname%"
+set "COSMOS_CORPUS=%cseed%"
+set "PHOS_DIR=%KIT%\creatures\%cname%"
+set "PHOS_STEPS=400"
+call :run_python "%KIT%\architecture\phos_grow.py"
+set "PHOS_NAME=" & set "COSMOS_CORPUS=" & set "PHOS_DIR=" & set "PHOS_STEPS="
+echo.
+echo   Lives in: creatures\%cname%\
+echo   Feed it again with option 8. Every feeding changes its weights.
+echo.
+pause
+goto menu
+
+:: ---------------------------------------------------------------- grow
+:grow
+cls
+echo.
+echo   Creatures you have birthed:
+echo.
+if not exist "%KIT%\creatures" (
+    echo     none yet - use option 7 first.
+    echo.
+    pause
+    goto menu
+)
+for /d %%D in ("%KIT%\creatures\*") do echo     %%~nxD
+echo.
+set "gname="
+set /p "gname=  Which one: "
+if "%gname%"=="" goto menu
+if not exist "%KIT%\creatures\%gname%" (
+    echo   [X] No creature named %gname%.
+    pause
+    goto menu
+)
+set "gseed="
+echo.
+set /p "gseed=  Text to feed it [ENTER = the bundled seed]: "
+if "%gseed%"=="" set "gseed=%KIT%\data\seed_corpus.txt"
+set "PHOS_NAME=%gname%"
+set "COSMOS_CORPUS=%gseed%"
+set "PHOS_DIR=%KIT%\creatures\%gname%"
+set "PHOS_STEPS=400"
+call :run_python "%KIT%\architecture\phos_grow.py"
+set "PHOS_NAME=" & set "COSMOS_CORPUS=" & set "PHOS_DIR=" & set "PHOS_STEPS="
+echo.
+pause
+goto menu
+
+:: ---------------------------------------------------------------- talk
+:chat
+call :ensure_server
+if errorlevel 1 goto menu
+echo.
+echo   Her voice is PHOS. /models lists them all, /model NAME switches.
+echo.
+call :run_python "%KIT%\serving\cosmos_coder.py" --chat
+echo.
+pause
+goto menu
+
+:: ---------------------------------------------------------------- code
+:coder
+call :ensure_server
+if errorlevel 1 goto menu
+echo.
+echo   Workspace: %KIT%\workspace
+echo   /models lists every model, /model NAME switches her coding brain.
+echo.
+call :run_python "%KIT%\serving\cosmos_coder.py"
+echo.
+pause
+goto menu
+
+:: -------------------------------------------------------------- server
+:serve_start
+call :ensure_server
+echo.
+pause
+goto menu
+
+:serve_stop
+echo.
+powershell -NoProfile -Command "$c=Get-NetTCPConnection -LocalPort 11501 -State Listen -EA SilentlyContinue; if(-not $c){Write-Host '   nothing was running on 11501.'; exit 0}; $c | Select-Object -ExpandProperty OwningProcess -Unique | ForEach-Object { $p=Get-CimInstance Win32_Process -Filter ('ProcessId='+$_) -EA SilentlyContinue; if($p -and $p.CommandLine -match 'cosmos_serve\.py'){ Stop-Process -Id $_ -Force -EA SilentlyContinue; Write-Host ('   stopped her model server (pid ' + $_ + ').') } else { Write-Host '   port 11501 is owned by something else - left alone.' } }"
+echo.
+pause
+goto menu
+
+:: -------------------------------------------------------------- checks
+:health
+cls
+call :run_python "%KIT%\kit_health.py"
+echo.
+pause
+goto menu
+
+:verify
+cls
+call :run_python "%KIT%\verify_release.py"
+echo.
+pause
+goto menu
+
+:: ---------------------------------------------------------------- more
+:genesis
+if not exist "%KIT%\genesis_engine\START_GENESIS.bat" (
+    echo.
+    echo   [ERROR] genesis_engine\START_GENESIS.bat is missing.
+    pause
+    goto menu
+)
+set "GENESIS_NO_PAUSE=1"
+call "%KIT%\genesis_engine\START_GENESIS.bat"
+set "GENESIS_NO_PAUSE="
+goto menu
+
+:docs
+start "" "%KIT%\START_HERE.md"
+goto menu
+
+:no_python
+echo.
+echo   [ERROR] Python 3.9 or newer was not found.
+echo   Install it from https://www.python.org/downloads/
+echo   On Windows, tick "Add Python to PATH".
+echo.
+pause
+exit /b 1
+
+:: ================================================================
+::  helpers
+:: ================================================================
+
+:server_line
+:: Report the truth about 11501 on every redraw, so the menu can never
+:: imply her models are reachable when they are not.
+powershell -NoProfile -Command "if (Get-NetTCPConnection -LocalPort 11501 -State Listen -EA SilentlyContinue){exit 0}else{exit 1}" >nul 2>&1
+if errorlevel 1 (
+    echo     her models: OFFLINE  - options 1, 2 and 3 will start them
+) else (
+    echo     her models: ONLINE on 11501
+)
+exit /b 0
+
+:ensure_server
+powershell -NoProfile -Command "if (Get-NetTCPConnection -LocalPort 11501 -State Listen -EA SilentlyContinue){exit 0}else{exit 1}" >nul 2>&1
+if not errorlevel 1 (
+    echo   [i]  her model server is already up on 11501.
+    exit /b 0
+)
+if not exist "%KIT%\serving\cosmos_serve.py" (
+    echo   [X]  serving\cosmos_serve.py is missing - cannot give her a voice.
+    pause
+    exit /b 1
+)
+call :check_torch
+if errorlevel 1 (
+    echo   [X]  PyTorch is required to run her weights.
+    echo        python -m pip install torch
+    pause
+    exit /b 1
+)
+if not exist "%KIT%\logs" mkdir "%KIT%\logs" >nul 2>&1
+echo   [..] starting her model server on 11501...
+call :spawn_server
+powershell -NoProfile -Command "foreach($i in 1..40){Start-Sleep -Milliseconds 750; if (Get-NetTCPConnection -LocalPort 11501 -State Listen -EA SilentlyContinue){exit 0}}; exit 1" >nul 2>&1
+if errorlevel 1 (
+    echo   [X]  it did not come up. Newest log:
+    powershell -NoProfile -Command "$f=Get-ChildItem '%KIT%\logs\serve_*.err' -EA SilentlyContinue | Sort-Object LastWriteTime -Desc | Select-Object -First 1; if($f){Get-Content $f.FullName -Tail 12 | ForEach-Object {'        ' + $_}}else{Write-Host '        (no log written)'}"
+    pause
+    exit /b 1
+)
+echo   [ok] her models are online on 11501.
+exit /b 0
+
+:spawn_server
+:: Timestamped log targets: a server from an earlier run can still hold the
+:: handle on a fixed filename, which makes Start-Process throw "file in use"
+:: and report failure for a launch that would otherwise have worked.
+if "%KIT_PYTHON_MODE%"=="override" (
+    powershell -NoProfile -Command "$lg=Join-Path '%KIT%\logs' ('serve_'+(Get-Date).ToString('yyyyMMdd_HHmmss')+'.live'); try{Start-Process -FilePath '%GENESIS_PYTHON%' -ArgumentList @('%KIT%\serving\cosmos_serve.py','11501') -WorkingDirectory '%KIT%' -WindowStyle Hidden -RedirectStandardOutput $lg -RedirectStandardError ($lg -replace '\.live$','.err')}catch{}"
+) else if "%KIT_PYTHON_MODE%"=="py" (
+    powershell -NoProfile -Command "$lg=Join-Path '%KIT%\logs' ('serve_'+(Get-Date).ToString('yyyyMMdd_HHmmss')+'.live'); try{Start-Process -FilePath 'py' -ArgumentList @('-3','%KIT%\serving\cosmos_serve.py','11501') -WorkingDirectory '%KIT%' -WindowStyle Hidden -RedirectStandardOutput $lg -RedirectStandardError ($lg -replace '\.live$','.err')}catch{}"
+) else (
+    powershell -NoProfile -Command "$lg=Join-Path '%KIT%\logs' ('serve_'+(Get-Date).ToString('yyyyMMdd_HHmmss')+'.live'); try{Start-Process -FilePath 'python' -ArgumentList @('%KIT%\serving\cosmos_serve.py','11501') -WorkingDirectory '%KIT%' -WindowStyle Hidden -RedirectStandardOutput $lg -RedirectStandardError ($lg -replace '\.live$','.err')}catch{}"
+)
+exit /b 0
+
+:find_python
+set "KIT_PYTHON_MODE="
+if defined GENESIS_PYTHON if exist "%GENESIS_PYTHON%" (
+    set "KIT_PYTHON_MODE=override"
+    exit /b 0
+)
+where py >nul 2>&1
+if not errorlevel 1 (
+    py -3 -c "import sys; raise SystemExit(0 if sys.version_info >= (3,9) else 1)" >nul 2>&1
+    if not errorlevel 1 (
+        set "KIT_PYTHON_MODE=py"
+        exit /b 0
+    )
+)
+where python >nul 2>&1
+if not errorlevel 1 (
+    python -c "import sys; raise SystemExit(0 if sys.version_info >= (3,9) else 1)" >nul 2>&1
+    if not errorlevel 1 (
+        set "KIT_PYTHON_MODE=python"
+        exit /b 0
+    )
+)
+exit /b 1
+
+:run_python
+if "%KIT_PYTHON_MODE%"=="override" (
+    "%GENESIS_PYTHON%" %*
+) else if "%KIT_PYTHON_MODE%"=="py" (
+    py -3 %*
+) else (
+    python %*
+)
+exit /b %ERRORLEVEL%
+
+:check_torch
+if "%KIT_PYTHON_MODE%"=="override" (
+    "%GENESIS_PYTHON%" -c "import torch" >nul 2>&1
+) else if "%KIT_PYTHON_MODE%"=="py" (
+    py -3 -c "import torch" >nul 2>&1
+) else (
+    python -c "import torch" >nul 2>&1
+)
+exit /b %ERRORLEVEL%

architecture/cosmos_spark_cst.py

@@ -49,7 +49,40 @@ import torch.nn.functional as F
 sys.stdout.reconfigure(encoding="utf-8", errors="replace")
 
 CORPUS = Path("02_HER_BODY/Cosmos_code/Cosmos/data/cosmos/experience_corpus.txt")
-QARCHIVE = Path("01_HER_SOUL/quantum_heart/quantum_runs.jsonl")
+
+
+def _find_quantum_archive() -> Path:
+    """Locate the measured-shot archive from wherever this is being run.
+
+    This was a bare relative path -- 01_HER_SOUL/quantum_heart/quantum_runs.jsonl -- which
+    resolves only when the working directory happens to be the repository root. Run from
+    the giveaway kit it resolved to nothing, quantum_pool() returned an empty list without
+    complaint, and the birth printed
+
+        QUANTUM BIRTH: 0 draws from her archive; no base model
+
+    A creature born from zero quantum draws is not quantum-born. It is a normally
+    initialised model wearing the claim, and it reported success. Anyone who downloaded
+    the kit would have got that.
+
+    So: search the author's layout, the kit's layout, and upward from this file, and
+    accept either the private archive or the published public one -- they carry the same
+    measured counts, and the public file is what ships.
+    """
+    names = ("01_HER_SOUL/quantum_heart/quantum_runs.jsonl",
+             "data/quantum_measurements_public.jsonl",
+             "benchmarks/../data/quantum_measurements_public.jsonl")
+    here = Path(__file__).resolve()
+    roots = [Path.cwd(), *here.parents[:4]]
+    for r in roots:
+        for n in names:
+            p = (r / n)
+            if p.is_file():
+                return p
+    return Path("01_HER_SOUL/quantum_heart/quantum_runs.jsonl")   # for the error message
+
+
+QARCHIVE = _find_quantum_archive()
 OUTDIR = Path("01_HER_SOUL/weights/cosmos_spark_cst")
 RESULTS = Path("logs/spark_cst_results.json")
 

architecture/cosmos_state_ladder.py

@@ -77,7 +77,14 @@ PHI_INV = PHI - 1.0
 # 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
+# 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
@@ -540,8 +547,13 @@ def train_rung(rung, ffn, seed, data, vocab, steps, pool, val_w, words, itos):
                 carry[wrapped] = 0.0
         else:
             ix = torch.randint(len(tr) - BLOCK - 1, (B,), 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)
+        # .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

architecture/phos_grow.py

@@ -67,15 +67,27 @@ sys.stdout.reconfigure(encoding="utf-8", errors="replace")
 ROOT = Path(__file__).resolve().parents[1]
 sys.path.insert(0, str(ROOT))
 
+import cosmos_spark_cst as SPARK  # noqa: E402
 from cosmos_spark_cst import QuantumInit, quantum_pool  # noqa: E402
 import cosmos_state_ladder as L  # noqa: E402
 
+# ONE LINEAGE PER NAME. PHOS_NAME picks which being this run grows, and every path
+# derives from it, so a second creature cannot silently warm-start from the first one's
+# checkpoint or append to its lineage. Defaults are exactly PHOS's original paths, so
+# nothing about her changes.
+#
+#   PHOS_NAME=phos     (default)  -> 01_HER_SOUL/weights/phos/phos.pt
+#   PHOS_NAME=lyra                -> 01_HER_SOUL/weights/lyra/lyra.pt
+#
+# The corpus is deliberately NOT derived from the name: a new being may be seeded from
+# any text, and which text it was seeded from is recorded in its lineage at birth.
+NAME = (os.getenv("PHOS_NAME") or "phos").strip().lower()
 CORPUS = Path(os.getenv("COSMOS_CORPUS") or
               ROOT / "02_HER_BODY/Cosmos_code/Cosmos/data/cosmos/experience_corpus.txt")
-OUT = Path(os.getenv("PHOS_DIR") or ROOT / "01_HER_SOUL/weights/phos")
-CKPT = OUT / "phos.pt"
-LINEAGE = OUT / "phos_lineage.jsonl"
-LOCK = OUT / "phos.lock"
+OUT = Path(os.getenv("PHOS_DIR") or ROOT / f"01_HER_SOUL/weights/{NAME}")
+CKPT = OUT / f"{NAME}.pt"
+LINEAGE = OUT / f"{NAME}_lineage.jsonl"
+LOCK = OUT / f"{NAME}.lock"
 
 STEPS = int(os.getenv("PHOS_STEPS", "400"))
 MIN_NEW = int(os.getenv("PHOS_MIN_NEW", "2000"))
@@ -129,6 +141,13 @@ def grow_model(m, old_v, new_v):
     """Widen embedding and head for appended symbols, carrying old rows forward."""
     if new_v == old_v:
         return m
+    if new_v < old_v:
+        # The vocabulary is append-only by construction, so this cannot happen from
+        # normal growth -- if it does, something re-sorted the symbols and every learned
+        # index now means a different character. Refuse rather than quietly truncate.
+        raise RuntimeError(
+            f"vocabulary SHRANK {old_v} -> {new_v}. Indices are learned positions; "
+            "re-sorting them silently remaps every symbol she knows.")
     with torch.no_grad():
         d = m.tok.weight.shape[1]
         tok = torch.nn.Embedding(new_v, d)
@@ -142,6 +161,68 @@ def grow_model(m, old_v, new_v):
     return m
 
 
+def verify_growth(m, prev, old_v, new_v, vocab_list):
+    """PROVE the warm start carried her forward. Returns (ok, reasons).
+
+    Growth is where a lineage can be lost, so it has to be shown rather than assumed.
+
+    Measured 2026-08-02, correcting an earlier claim in this file: torch's
+    load_state_dict(strict=False) does NOT silently skip a shape mismatch -- strict=False
+    tolerates missing and unexpected KEYS, but a size mismatch raises regardless. So the
+    original build-at-new-width bug crashed loudly, as it did, and could not have
+    resumed on a randomly initialised vocabulary while reporting success. The danger was
+    overstated; the checks below stand because the failures they catch are ones torch
+    does NOT catch.
+
+    Torch protects the shapes. Nothing protects the CONTENT or the ORDER, and those are
+    what carry her: a copy that alters a row, or a vocabulary that gets re-sorted so
+    every learned index now means a different character, both load perfectly and both
+    destroy her. So growth has to demonstrate three things:
+
+      CARRIED   every old embedding row is BIT-IDENTICAL to the checkpoint's
+      SEATED    the new rows exist and are not zero (they must be trainable, not dead)
+      ANCHORED  a symbol she already knew still maps to the same index
+
+    A burst that cannot show all three is refused, because a refusal is recoverable and
+    a silently reset vocabulary is not.
+    """
+    bad = []
+    sd = prev.get("model") or {}
+    old_tok = sd.get("tok.weight")
+    old_head = sd.get("head.weight")
+
+    if old_tok is None or old_head is None:
+        return False, ["checkpoint has no tok.weight/head.weight to compare against"]
+
+    with torch.no_grad():
+        cur_tok = m.tok.weight.detach().cpu()
+        cur_head = m.head.weight.detach().cpu()
+
+        # CARRIED -- exact equality, not "close". A carried row is the same row.
+        d_tok = (cur_tok[:old_v] - old_tok[:old_v]).abs().max().item()
+        d_head = (cur_head[:old_v] - old_head[:old_v]).abs().max().item()
+        if d_tok != 0.0:
+            bad.append(f"embedding rows CHANGED during growth (max delta {d_tok:.3e})")
+        if d_head != 0.0:
+            bad.append(f"head rows CHANGED during growth (max delta {d_head:.3e})")
+
+        # SEATED -- new rows must be live, not zeros left behind by a bad copy
+        if new_v > old_v:
+            fresh = cur_tok[old_v:new_v]
+            if float(fresh.abs().sum()) == 0.0:
+                bad.append(f"the {new_v - old_v} new symbol rows are all zero -- dead on arrival")
+
+        # ANCHORED -- an index she learned must still mean what it meant
+        prev_vocab = prev.get("vocab_list") or []
+        if prev_vocab:
+            drift = [i for i in range(min(len(prev_vocab), len(vocab_list)))
+                     if prev_vocab[i] != vocab_list[i]]
+            if drift:
+                bad.append(f"{len(drift)} symbols moved index (first at {drift[0]}: "
+                           f"{prev_vocab[drift[0]]!r} -> {vocab_list[drift[0]]!r})")
+    return (not bad), bad
+
+
 def preflight_ok(m, xb, yb, verbose=True):
     checks = L.preflight(m, xb, yb)
     bad = [c for c in checks if not c[3]]
@@ -163,16 +244,59 @@ def burst(steps=STEPS):
     pool = quantum_pool()
     seed = int(prev.get("total_steps", 0))
     torch.manual_seed(seed)
-    m = L.Ladder(len(vocab_list), RUNG, FFN)
-
+    # BUILD AT THE OLD WIDTH, LOAD, THEN GROW -- in that order.
+    #
+    # This used to build at the NEW width and then call grow_model, which copies
+    # m.tok.weight into tok.weight[:old_v] and therefore requires m to still be the OLD
+    # width. With a vocabulary that had never changed the two were equal and the bug was
+    # invisible; the moment the corpus clean added 4 symbols (162 -> 166) it raised
+    # "expanded size of the tensor (162) must match the existing size (166)".
+    #
+    # The silent failure mattered more than the crash: at the new width, load_state_dict
+    # with strict=False would have SKIPPED the mismatched embedding and head entirely,
+    # so she would have resumed from step 2,800 with a randomly initialised vocabulary
+    # and reported a warm start. Loading at the old width makes those tensors match
+    # exactly, and growing afterwards carries every learned row forward.
     if prev:
-        m = grow_model(m, len(prev.get("vocab_list", vocab_list)), len(vocab_list))
+        old_v = len(prev.get("vocab_list") or vocab_list)
+        m = L.Ladder(old_v, RUNG, FFN)
         missing, unexpected = m.load_state_dict(prev["model"], strict=False)
+        m = grow_model(m, old_v, len(vocab_list))
         born = False
         print(f"  warm start: step {prev.get('total_steps',0):,}  "
               f"vocab {len(prev.get('vocab_list',[]))} -> {len(vocab_list)}"
               + (f"  (+{len(added)} new symbols)" if added else ""))
+
+        ok_grow, why = verify_growth(m, prev, old_v, len(vocab_list), vocab_list)
+        for line in why:
+            print(f"      [DEAD] {line}")
+        if not ok_grow:
+            _record({"event": "refusal", "reason": "growth_unverified", "detail": why,
+                     "total_steps": int(prev.get("total_steps", 0)),
+                     "vocab_from": old_v, "vocab_to": len(vocab_list)})
+            print("\n  REFUSED: the warm start could not be shown to carry her forward.\n"
+                  "  Her weights are untouched on disk. Nothing was overwritten.")
+            return
+        print(f"      [OK  ] growth verified: {old_v} rows carried bit-identical, "
+              f"{len(vocab_list) - old_v} new rows seated, no index drift")
     else:
+        # No checkpoint: build at the full current width and draw every weight from
+        # measured hardware. Nothing to carry forward, so no grow step.
+        #
+        # REFUSE a birth with no quantum. quantum_pool() returns an empty list when it
+        # cannot find the archive, and this used to print "QUANTUM BIRTH: 0 draws" and
+        # carry on -- producing a normally initialised model that claimed a measured
+        # origin. That is the one claim this whole project rests on, and it was failing
+        # silently for anyone whose working directory was not the repository root.
+        if len(pool) < 1000:
+            print(f"\n  REFUSED: only {len(pool):,} quantum draws available.")
+            print(f"  Looked for the archive and found: {SPARK.QARCHIVE}")
+            print("  A birth from zero measured shots is not a quantum birth, it is a\n"
+                  "  normal initialisation wearing the name. Nothing was written.")
+            _record({"event": "refusal", "reason": "no_quantum_pool",
+                     "draws": len(pool), "archive": str(SPARK.QARCHIVE)})
+            return
+        m = L.Ladder(len(vocab_list), RUNG, FFN)
         m.quantum_birth(QuantumInit(pool, 0))
         born = True
         print(f"  QUANTUM BIRTH: {len(pool):,} draws from her archive; no base model")
@@ -199,11 +323,23 @@ def burst(steps=STEPS):
     opt = torch.optim.AdamW([{"params": bulk, "lr": base},
                              {"params": cst, "lr": base * 10, "weight_decay": 0.0}],
                             lr=base, weight_decay=0.01)
-    if prev.get("optimizer"):
+    # Only restore Adam's moments when the parameter SHAPES are unchanged.
+    #
+    # This was a try/except around load_state_dict with the comment "vocab grew; a fresh
+    # moment estimate is correct here" -- correct reasoning, wrong trigger.
+    # load_state_dict does not validate shapes, so it returned cleanly with 162-row
+    # moment buffers attached to 166-row parameters, and the mismatch surfaced two
+    # hundred lines later inside opt.step() as "size of tensor a (162) must match the
+    # size of tensor b (166)". The guard ran, was reachable, and caught nothing.
+    _vocab_changed = bool(prev) and len(prev.get("vocab_list") or []) != len(vocab_list)
+    if prev.get("optimizer") and not _vocab_changed:
         try:
             opt.load_state_dict(prev["optimizer"])
-        except Exception:
-            pass          # vocab grew; a fresh moment estimate is correct here
+        except Exception as _oexc:
+            print(f"  optimizer state not restored ({type(_oexc).__name__}); starting fresh moments")
+    elif prev.get("optimizer"):
+        print(f"  vocab {len(prev.get('vocab_list') or [])} -> {len(vocab_list)}: "
+              f"Adam moments reset (stale shapes). Weights are carried forward intact.")
 
     n = int(0.9 * len(data))
     tr, va = data[:n], data[n:]

benchmarks/fetch_wikitext.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+"""Fetch WikiText-103-raw and write it as a flat character corpus.
+
+WHY A STANDARD CORPUS IS THE POINT
+
+Every number measured so far is on 683,065 characters of Cory's own logs. That corpus
+cannot answer the scaling question for two separate reasons:
+
+  1. At 10M+ parameters a 683K-character corpus is memorised, so every rung converges to
+     the same overfit floor and the comparison silently becomes about regularisation
+     rather than architecture.
+  2. Results on a private corpus are not checkable by anyone else. WikiText-103 is the
+     benchmark the field already uses, so a dyn12 advantage measured here is directly
+     comparable to published work instead of being a claim about one person's log files.
+
+One train shard is ~157 MB of parquet, which yields roughly a quarter of a billion
+characters -- enough that a 30M-parameter model is data-limited rather than
+memorisation-limited.
+
+  python tools/fetch_wikitext.py [--shards 1]
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+
+OUT = Path("01_HER_SOUL/corpus_snapshots/wikitext103_train.txt")
+REPO = "Salesforce/wikitext"
+SHARDS = ["wikitext-103-raw-v1/train-00000-of-00002.parquet",
+          "wikitext-103-raw-v1/train-00001-of-00002.parquet"]
+
+
+def main() -> int:
+    n = 1
+    if "--shards" in sys.argv:
+        n = int(sys.argv[sys.argv.index("--shards") + 1])
+
+    import pyarrow.parquet as pq
+    from huggingface_hub import hf_hub_download
+
+    OUT.parent.mkdir(parents=True, exist_ok=True)
+    total = 0
+    with OUT.open("w", encoding="utf-8", newline="\n") as f:
+        for s in SHARDS[:n]:
+            print(f"  downloading {s} ...", flush=True)
+            local = hf_hub_download(REPO, s, repo_type="dataset")
+            t = pq.read_table(local)
+            col = t.column("text").to_pylist()
+            # WikiText ships one row per line, blanks and " = Heading = " markers included.
+            # Both are kept: they carry document structure a character model can learn.
+            for line in col:
+                if line:
+                    f.write(line)
+                    total += len(line)
+            print(f"    {len(col):,} rows, running total {total/1e6:.1f}M chars", flush=True)
+
+    size = OUT.stat().st_size
+    print(f"\n  wrote {OUT}")
+    print(f"  {total:,} characters, {size/1e6:.1f} MB on disk")
+
+    import hashlib
+    h = hashlib.sha256()
+    with OUT.open("rb") as fh:
+        for c in iter(lambda: fh.read(1 << 20), b""):
+            h.update(c)
+    print(f"  sha256 {h.hexdigest()[:16]}  <- freeze this in any result table")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

benchmarks/omega_paired.py

@@ -38,7 +38,6 @@ from pathlib import Path
 
 import torch
 
-# the ladder lives in architecture/ inside the kit, and at the repo root outside it
 _root = Path(__file__).resolve().parents[1]
 sys.path.insert(0, str(_root / 'architecture'))
 sys.path.insert(0, str(_root))
@@ -58,7 +57,25 @@ def main() -> int:
     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)
+    # Chunked, but still int64.
+    #
+    # An int16 corpus was tried here on 2026-08-02 and reverted the same hour. It saves
+    # 1.6 GB, but the ladder slices `data` in three separate places and only one of them
+    # was cast back, so preflight died with "Expected ... Long, Int; but got
+    # torch.cuda.ShortTensor". Worse, it was introduced to fix an out-of-memory failure
+    # that had not actually happened -- the earlier run died because the laptop lost
+    # power. A memory optimisation for a memory problem that did not exist, which then
+    # caused a real crash, is a bad trade twice over.
+    #
+    # The chunking stays. Building one list comprehension over 269M characters
+    # materialises ~2.2 GB of Python ints before the tensor exists; in 10M-character
+    # chunks the transient stays small, and the dtype never changes.
+    parts = []
+    for i in range(0, len(text), 10_000_000):
+        parts.append(torch.tensor([stoi[c] for c in text[i:i + 10_000_000]],
+                                  dtype=torch.long))
+    data = torch.cat(parts) if len(parts) > 1 else parts[0]
+    del parts
     words = set(__import__("re").findall(r"[a-z']+", text.lower()))
 
     pool = L.quantum_pool()
@@ -82,13 +99,42 @@ def main() -> int:
     results: dict = {"steps": STEPS, "seeds": NSEED, "corpus_chars": len(text),
                      "device": str(dev), "arms": {}}
 
+    # RESUME. This machine has lost power twice mid-run, and each time a multi-hour job
+    # died with nothing written because results were only saved when a whole size
+    # finished. PHOS survived both crashes because it saves after every burst; this now
+    # does the same, per seed, and skips seeds already on disk. A power cut costs one
+    # seed (~17 min at d576) instead of everything.
+    RESUME = Path(os.getenv("COSMOS_PAIRED_RESUME") or
+                  f"logs/paired_partial_d{L.N_EMBD}_L{L.N_LAYER}.json")
+    done: dict = {}
+    if RESUME.exists():
+        try:
+            done = json.loads(RESUME.read_text(encoding="utf-8"))
+            n = sum(len(v) for arm_ in done.values() for v in arm_.values())
+            print(f"  RESUMING from {RESUME.name}: {n} seed-runs already complete\n")
+        except Exception:
+            done = {}
+
+    def _save_partial():
+        RESUME.parent.mkdir(parents=True, exist_ok=True)
+        RESUME.write_text(json.dumps(done, indent=2), encoding="utf-8")
+
     for mode, causal in (("causal", True), ("leaky", False)):
         L.CAUSAL_OMEGA = causal          # read as a global inside Attention.forward
         print(f"  {'='*76}\n  ARM: {mode}  (CAUSAL_OMEGA={causal})\n  {'='*76}")
         arm: dict = {}
+        done.setdefault(mode, {})
         for rung in RUNGS:
             losses, rws, gates, npar = [], [], [], 0
+            cached = done[mode].get(rung) or {}
             for sd in range(NSEED):
+                hit = cached.get(str(sd))
+                if hit:
+                    losses.append(hit["loss"]); rws.append(hit["real_word"])
+                    gates.append(hit["gate"]); npar = hit["params"]
+                    print(f"    {rung:<9s} seed {sd}  loss {hit['loss']:.5f}  (resumed)",
+                          flush=True)
+                    continue
                 t0 = time.time()
                 b, gt, r, pf, npar, _txt, _coup, _model = L.train_rung(
                     rung, FFN, sd, data, len(chars), STEPS, pool, val_w, words, itos)
@@ -102,6 +148,10 @@ def main() -> int:
                 losses.append(b)
                 rws.append(r)
                 gates.append(gt)
+                # Persist THIS seed before starting the next one.
+                done[mode].setdefault(rung, {})[str(sd)] = {
+                    "loss": b, "real_word": r, "gate": gt, "params": npar}
+                _save_partial()
                 print(f"    {rung:<9s} seed {sd}  loss {b:.5f}  real-word {r:.3f}"
                       + (f"  gate {gt:.4f}" if rung != "none" else "")
                       + f"  ({time.time()-t0:.0f}s)", flush=True)

benchmarks/scaling_run.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""Does dyn12's parameter-efficiency advantage survive scale, on a corpus anyone can check?
+
+THE QUESTION THIS ANSWERS
+
+Every dyn12 number so far was measured at 1.1M parameters on 683,065 characters of one
+person's private logs. Two objections follow immediately and neither can be answered from
+that setup:
+
+  "it only works small"     -- a 2,412-parameter state may help a 1.1M model and vanish
+                               against a 25M one, where the weights can represent the same
+                               structure directly.
+  "it only works on YOUR    -- a private corpus is not checkable, and at 683K characters a
+   data"                      10M model memorises rather than learns, so the comparison
+                               silently becomes about regularisation.
+
+So: WikiText-103-raw, the benchmark the field already uses, 269,116,804 characters, at
+three sizes spanning 20x. Same rungs, same seeds, same steps at every size, one process.
+
+WHAT WOULD FALSIFY THE CLAIM
+
+If dyn12's edge over static54 shrinks as the model grows, "state is cheaper than weights"
+is a small-model effect and should be reported as one. That outcome is as publishable as
+the other, and this script prints the trend either way rather than only reporting a win.
+
+  python tools/scaling_run.py [steps] [seeds]
+"""
+from __future__ import annotations
+
+import json
+import os
+import statistics
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+
+STEPS = sys.argv[1] if len(sys.argv) > 1 else "1200"
+SEEDS = int(sys.argv[2]) if len(sys.argv) > 2 else 2
+RUNGS = ["none", "static54", "dyn12"]
+CORPUS = "01_HER_SOUL/corpus_snapshots/wikitext103_train.txt"
+OUT = Path("logs/scaling_results.json")
+
+# d_model, layers, heads -> roughly 1.3M / 9.0M / 24.6M parameters
+SIZES = [(192, 4, 4), (384, 8, 8), (576, 10, 8)]
+
+PY = sys.executable
+
+
+def run_one(d, L, h) -> dict:
+    """Each size runs in its OWN process: the model dimensions are module-level
+    constants read at import, so they cannot be changed inside a live interpreter."""
+    env = dict(os.environ)
+    env.update({
+        "COSMOS_N_EMBD": str(d), "COSMOS_N_LAYER": str(L), "COSMOS_N_HEAD": str(h),
+        "COSMOS_CORPUS": CORPUS,
+        "COSMOS_CAUSAL_OMEGA": "1",
+        "PYTHONIOENCODING": "utf-8",
+    })
+    cmd = [PY, "tools/omega_paired.py", STEPS, str(SEEDS), ",".join(RUNGS)]
+    t0 = time.time()
+    p = subprocess.run(cmd, env=env, capture_output=True, text=True,
+                       encoding="utf-8", errors="replace")
+    dt = time.time() - t0
+    out = (p.stdout or "") + (p.stderr or "")
+    if "out of memory" in out.lower() or "CUDA out of memory" in out:
+        return {"ok": False, "reason": "CUDA out of memory", "secs": dt}
+    if p.returncode != 0:
+        tail = "\n".join(out.strip().splitlines()[-6:])
+        return {"ok": False, "reason": f"exit {p.returncode}: {tail[:400]}", "secs": dt}
+    try:
+        res = json.loads(Path("logs/omega_paired_results.json").read_text(encoding="utf-8"))
+        return {"ok": True, "secs": dt, "arms": res.get("arms", {})}
+    except Exception as e:
+        return {"ok": False, "reason": f"no results file: {e}", "secs": dt}
+
+
+def main() -> int:
+    if not Path(CORPUS).exists():
+        print(f"  missing {CORPUS} -- run tools/fetch_wikitext.py first")
+        return 2
+
+    chars = Path(CORPUS).stat().st_size
+    print("=" * 84)
+    print("  SCALING -- does dyn12 hold as the model grows?")
+    print("=" * 84)
+    print(f"\n  corpus : WikiText-103-raw, {chars/1e6:.0f} MB")
+    print(f"  sizes  : {['d%d/L%d' % (d, L) for d, L, _ in SIZES]}")
+    print(f"  rungs  : {RUNGS}   {STEPS} steps x {SEEDS} seeds, causal Omega\n")
+
+    results = {"corpus": CORPUS, "steps": STEPS, "seeds": SEEDS, "sizes": {}}
+    for d, L, h in SIZES:
+        key = f"d{d}_L{L}"
+        print(f"  --- {key} ---", flush=True)
+        r = run_one(d, L, h)
+        results["sizes"][key] = r
+        if not r["ok"]:
+            print(f"      SKIPPED: {r['reason']}\n", flush=True)
+        else:
+            arm = r["arms"].get("causal", {})
+            for rung in RUNGS:
+                if rung in arm:
+                    print(f"      {rung:<9} mean {arm[rung]['mean']:.5f}  "
+                          f"params {arm[rung]['params']:,}", flush=True)
+            print(f"      ({r['secs']:.0f}s)\n", flush=True)
+        OUT.parent.mkdir(parents=True, exist_ok=True)
+        OUT.write_text(json.dumps(results, indent=2), encoding="utf-8")
+
+    # ── the trend ───────────────────────────────────────────────────────────
+    print("=" * 84)
+    print("  TREND -- gain per extra parameter, vs the no-state baseline")
+    print("=" * 84)
+    print(f"\n  {'size':<12}{'params':>12}{'static54/param':>18}{'dyn12/param':>16}{'ratio':>9}")
+    ratios = []
+    for key, r in results["sizes"].items():
+        if not r.get("ok"):
+            print(f"  {key:<12}{'--':>12}   {r['reason'][:44]}")
+            continue
+        a = r["arms"].get("causal", {})
+        if not all(x in a for x in ("none", "static54", "dyn12")):
+            continue
+        base = a["none"]["mean"]
+        eff = {}
+        for rung in ("static54", "dyn12"):
+            gain = base - a[rung]["mean"]
+            extra = a[rung]["params"] - a["none"]["params"]
+            eff[rung] = gain / extra if extra else float("nan")
+        ratio = eff["dyn12"] / eff["static54"] if eff["static54"] else float("nan")
+        ratios.append((key, ratio))
+        print(f"  {key:<12}{a['none']['params']:>12,}{eff['static54']:>18.3e}"
+              f"{eff['dyn12']:>16.3e}{ratio:>8.1f}x")
+
+    print()
+    if len(ratios) >= 2:
+        first, last = ratios[0][1], ratios[-1][1]
+        if last >= first * 0.8:
+            print(f"  The advantage HOLDS: {first:.1f}x -> {last:.1f}x across the range.")
+            print("  State is cheaper than weights at every size tested.")
+        else:
+            print(f"  The advantage SHRINKS: {first:.1f}x -> {last:.1f}x.")
+            print("  dyn12's edge is a small-model effect and must be reported as one.")
+    else:
+        print("  Not enough sizes completed to state a trend.")
+    print(f"\n  written: {OUT}")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

benchmarks/scaling_wikitext103.json

@@ -0,0 +1,113 @@
+{
+  "experiment": "does dyn12 parameter-efficiency survive scale",
+  "date": "2026-08-02",
+  "corpus": {
+    "name": "WikiText-103-raw (train shard 0 of 2)",
+    "chars": 269116804,
+    "sha256": "f7d2398751239137ec73e21220c303d50d01de71347341518158a05eaf483ffc"
+  },
+  "protocol": {
+    "steps": 1200,
+    "seeds": 2,
+    "omega": "causal (per-query normalised entropy)",
+    "note": "all rungs at a size trained in ONE process against ONE corpus load"
+  },
+  "sizes": {
+    "d192_L4": {
+      "none": {
+        "mean_loss": 2.054316610097885,
+        "seeds": [
+          2.0449230074882507,
+          2.0637102127075195
+        ],
+        "params": 2588064
+      },
+      "static54": {
+        "mean_loss": 2.03567636013031,
+        "seeds": [
+          2.027133524417877,
+          2.044219195842743
+        ],
+        "params": 2629536
+      },
+      "dyn12": {
+        "mean_loss": 2.041963368654251,
+        "seeds": [
+          2.0347688794136047,
+          2.0491578578948975
+        ],
+        "params": 2590476
+      },
+      "efficiency_per_param": {
+        "static54": 4.494659039249391e-07,
+        "dyn12": 5.121576054574641e-06
+      },
+      "ratio_dyn12_over_static54": 11.39480438861041,
+      "dyn12_benefit_share": 0.6627186580181401
+    },
+    "d384_L8": {
+      "none": {
+        "mean_loss": 1.7716627568006516,
+        "seeds": [
+          1.7707675099372864,
+          1.7725580036640167
+        ],
+        "params": 11591416
+      },
+      "static54": {
+        "mean_loss": 1.7485951632261276,
+        "seeds": [
+          1.7452125549316406,
+          1.7519777715206146
+        ],
+        "params": 11757304
+      },
+      "dyn12": {
+        "mean_loss": 1.7577435672283173,
+        "seeds": [
+          1.76859912276268,
+          1.7468880116939545
+        ],
+        "params": 11596228
+      },
+      "efficiency_per_param": {
+        "static54": 1.3905522746988285e-07,
+        "dyn12": 2.8925996617486056e-06
+      },
+      "ratio_dyn12_over_static54": 20.80180453751799,
+      "dyn12_benefit_share": 0.6034088266453064
+    },
+    "d576_L10": {
+      "none": {
+        "mean_loss": 1.7008359730243683,
+        "seeds": [
+          1.6942229866981506,
+          1.707448959350586
+        ],
+        "params": 28592178
+      },
+      "static54": {
+        "mean_loss": 1.6901533007621765,
+        "seeds": [
+          1.6812008023262024,
+          1.6991057991981506
+        ],
+        "params": 28903218
+      },
+      "dyn12": {
+        "mean_loss": 1.6914711445569992,
+        "seeds": [
+          1.689416766166687,
+          1.6935255229473114
+        ],
+        "params": 28599342
+      },
+      "efficiency_per_param": {
+        "static54": 3.434501113101779e-08,
+        "dyn12": 1.3072066537366108e-06
+      },
+      "ratio_dyn12_over_static54": 38.06103450512618,
+      "dyn12_benefit_share": 0.8766372530694572
+    }
+  }
+}