Release validated Cosmos kit with portable starter and public quantum archive

Publishes the validated 2026-07-31 QC67 Cosmos kit. Includes a portable starter, offline manifest/privacy verifier, Genesis smoke-tested engine, training instructions and trainer, and the public provenance-bound quantum measurement archive. The archive contains 1,897 labeled IBM hardware records (7,770,112 samples), 877 legacy unlabeled records, and 2 simulator records; private physics/sensory fields and cloud credentials are excluded.

FINDINGS.md

@@ -1,609 +1,615 @@
-# Findings & Benchmarks for Cosmos
-
-Every number here came from a run that could have failed. Where something came back null,
-it is reported as null. Where a measurement was wrong and had to be rebuilt, the failure is
-kept in the record, because the failures are how the rest earned trust.
-
-**Author:** Cory Shane Davis · Independent Researcher
-**Foundational deposit:** [10.5281/zenodo.17574447](https://doi.org/10.5281/zenodo.17574447)
-
----
-
-## 1. Is the entropy actually quantum?
-
-The one measurement no classical process can fake.
-
-| quantity | value |
-|---|---|
-| CHSH statistic **S** | **2.7905** |
-| classical (local hidden-variable) bound | 2.0000 |
-| Tsirelson bound (quantum maximum) | 2.8284 |
-| fraction of quantum maximum | **98.7%** |
-| distance from classical bound | **~35σ** at 4096 shots/setting |
-| backend | `ibm_marrakesh` |
-
-```
-E(AB ) = +0.7197    E(AB') = -0.6675
-E(A'B) = +0.6982    E(A'B') = +0.7051
-S = E(AB) - E(AB') + E(A'B) + E(A'B') = 2.7905
-```
-
-Bell's theorem: no theory in which outcomes are determined by local pre-existing values can
-exceed 2.0. This hardware exceeds it by 35 standard deviations. **The entropy source is
-physically quantum.** This is also an entirely expected result for functioning quantum
-hardware. It verifies the pipeline; it does not discover new physics.
-
----
-
-## 2. Were the weights really born from that entropy?
-
-`cosmos_born.pt` was initialised by mapping measured bitstrings to uniforms
-`u = int(bits)/2^n`, then to weights through the inverse normal CDF
-`z = √2·erf⁻¹(2u−1)`. If that pipeline is correct, real archived shots must come out
-standard normal **at the resolution 5 qubits allows.**
-
-| statistic | 32-level theoretical ceiling | measured (3,258,886 draws) |
-|---|---|---|
-| mean | +0.0000 | **−0.0001** |
-| sd | 0.9802 | **0.9804** |
-| \|z\| ≤ 1 | 0.6875 | **0.6874** |
-| \|z\| ≤ 2 | 0.9375 | **0.9374** |
-
-Four decimal places on every statistic.
-
-**Why sd is 0.98 and not 1.00:** 5 qubits give 32 discrete outcomes, so `|z|` cannot exceed
-2.1523 by construction. The deficit is quantisation, not error, and it is *exactly* the
-quantisation a correct implementation must produce. A pipeline reporting sd = 1.0000 here
-would be the suspicious one.
-
-Also verified: **10,448,896 archived shots across 2,553 jobs, zero shot-conservation
-failures.**
-
----
-
-## 3. Is the model reproducible from its seed?
-
-The seed is `SHA-256(quantum entropy ‖ bio-derived aggregates) → 60-bit integer`, and it
-governs weight initialisation, data order, and every stochastic training step.
-
-| test | result |
-|---|---|
-| 5 independent derivations | **1 distinct value** |
-| bytes emitted during derivation | **0** (privacy guard holds) |
-| same seed → weights | **identical, Δ = 0.000e+00** |
-| **one bit flipped** → weights | different: mean Δ = **2.26e-02** across 1,842,432 params |
-
-So "her weights are grown from that seed" is a verified property with a falsifiable test
-behind it, not a description. **One bit of the seed produces a different model.**
-
-> *Zeref's Rain.*
-
-The bio-derived aggregates in that hash are personal to the author. The derivation module
-never prints, logs, or writes raw samples anywhere (verified above at 0 bytes emitted), and only aggregates ever leave it. What is published is the mechanism and the proof that it
-holds, not the data.
-
----
-
-## 4. Do the circuit's correlations belong to the circuit or to the chip?
-
-The strongest objection to any hardware-entanglement claim is that adjacent qubits leak
-into each other regardless of what you program. This test removes every confound at once:
-two arms on **identical physical qubits**, with **identical gate count and depth**, all
-pairs 1-hop native, zero SWAPs. The arms differ only in *which* native edges are entangled.
-
-| arm | own edges | those same pairs, other arm | Δ | t |
-|---|---|---|---|---|
-| A: `(0,1),(2,3)` | 0.26890 | 0.00466 | **+0.26041** | **+80.5** |
-| B: `(1,2),(3,4)` | 0.20695 | 0.00849 | **+0.20229** | **+164.6** |
-
-A single physical pair swings **58×** based only on whether its gate fired, and the excess
-**relocates** when the logical wiring changes. Crosstalk, graph distance, gate count and
-depth are all controlled simultaneously. 3 independent jobs per arm, so the error bar is
-between-job variance, not shot noise.
-
-*(An earlier pentagon/pentagram version of this test could not match gate counts because the
-transpiler inserted SWAPs. That limitation is recorded rather than hidden.)*
-
----
-
-## 5. Does the physics engine compute real chaos?
-
-Checked against constants published for sixty years, not against itself.
-
-| quantity | published | measured |
-|---|---|---|
-| largest Lyapunov exponent λ₁ | 0.9056 | **0.90384** |
-| Kaplan–Yorke dimension | 2.06215 | **2.06203** |
-| sum of exponents | −13.66667 | −13.66667 (exact) |
-| fixed point C₊ | (8.48528, 8.48528, 27) | exact |
-| attractor extent | \|x\|≈20, z≈48 | 19.13, 46.95 |
-
-λ₁ measured by Benettin renormalisation over 2×10⁶ steps. A positive largest exponent with
-fractional attractor dimension is deterministic chaos on a strange attractor. **8/8 checks
-pass**, including the driven engine staying finite and bounded over 20,000 steps at maximal
-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. 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 |
-|---|---|
-| i.i.d. weight initialisation | null. Advantage was init **scale** (σ≈0.025 vs 0.02), not quantum |
-| decoder sampling seed | null. Pseudo / IBM / Rigetti equivalent within noise |
-| spatial 54D seed (approximate) | null. Real seed beat 1/5 random vectors, z = −0.92 |
-| 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, **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
-
-A seventh null was recorded here and has been withdrawn. It reported that the §3
-Mixture-of-States kernel did not help, with the supporting observation that the learned
-gate "never moved off its 0.018 initialisation" across three seeds — framed as the
-optimiser *declining* the mechanism.
-
-The gate did not decline. **It could not move.** Three compounding faults in the test
-harness, found by direct gradient measurement:
-
-| fault | measured |
-|---|---|
-| gate initialised at `sigmoid(−4)`, in the saturated tail | d(sigmoid)/dx = 0.018 → gradient suppressed ~56× |
-| resulting gradient on the gate | 9.13e-05 → **365,118 steps** needed to move it 0.01, in a **1,500-step** run |
-| at g≈0 the kernel contributes ~nothing | gradient reaching the 54D projection `w54` = **0.000e+00** |
-
-The third is the worst: the kernel could never become useful because it was never used,
-and was never used because it was not useful. All three are properties of the harness, not
-of the mechanism.
-
-Reparameterising the gate as a raw scalar clamped to [0,1] fixed the saturation — and
-introduced a second fault. `torch.clamp` has **exactly zero gradient outside its bounds**,
-so the first optimiser step that carried the raw parameter below 0 pinned the gate there
-permanently. Measured on the resulting checkpoints: raw values −3.98, −4.04, −4.00, −4.01,
-gradient 0.000000. An absorbing state, not a decision.
-
-A straight-through clamp cured that, and the gate still fell. **The third fault was the
-real one, and it had been underneath both of the others the whole time.**
-
-`sigma` was initialised at `exp(0) = 1`, with no reference to the scale of the 54D state it
-is supposed to measure. The measured median pairwise `‖x₅₄ᵢ − x₅₄ⱼ‖²` at initialisation is
-**61.98**. So `exp(−61.98/2) ≈ 3e−14` off the diagonal and `exp(0) = 1` on it:
-
-| at initialisation | measured |
-|---|---|
-| sigma | 1.0000 |
-| median pairwise `‖x₅₄ᵢ − x₅₄ⱼ‖²` | 61.98 |
-| H diagonal mass | **0.9998** (uniform would be 1/T = 0.0078) |
-| gradient reaching `w54` | 1.19e−07 |
-
-**H arrived as the identity matrix.** Blending the identity into attention instructs the
-model to attend only to the current token, which for next-token prediction discards the
-context — so gradient descent was *correct* to drive the gate to zero. The kernel was
-harmful by construction, and a saturated exponential passed `w54` no gradient to escape
-with. Both earlier "the optimiser declined the mechanism" readings were measuring this.
-
-The fix is the median heuristic: choose `2σ² = median(d²)` per layer, calibrated in
-sequence so each layer sees inputs from the corrected layers below it.
-
-| | before (σ=1) | after (calibrated) |
-|---|---|---|
-| sigma, layer 0 | 1.0000 | 5.5719 |
-| H diagonal mass | 0.9999 | **0.0857** |
-| `|w54 grad|` | 1.19e−07 | **1.48e−05** (124×) |
-| gates whose gradient points **up** | **0 / 4** | **2 / 4** |
-
-**Note that §3.2 of the paper never assigns σ a value.** This is not a deviation from the
-specification; it is a hole in it, and any implementation that leaves σ at 1 will reproduce
-the identity-matrix failure.
-
-### The §3 result, finally earned
-
-Three seeds, 1200 steps, quantum-born init, PLAIN and CST identical in every respect except
-the mechanism, gate free to move in both directions:
-
-| seed | plain loss | CST loss | plain real-word | CST real-word | final gate |
-|---|---|---|---|---|---|
-| 0 | 1.39524 | 1.41313 | 0.833 | 0.888 | 0.0685 |
-| 1 | 1.39940 | 1.41739 | 0.854 | 0.874 | 0.0503 |
-| 2 | 1.41470 | 1.42165 | 0.908 | 0.901 | 0.0212 |
-| **mean** | **1.40312** | **1.41739** | 0.865 | 0.888 | 0.0467 |
-
-`CST − PLAIN = +0.01427`, `t = +3.90`, **CST wins 0/3**.
-
-**The gates were alive in all three seeds** — never pinned, never at the floor. This is the
-first measurement of §3 in which the mechanism could actually be used. Used, it costs about
-1% of held-out loss on this corpus at this scale.
-
-Two honest caveats, pointing opposite ways:
-
-- **against the result** — `t = 3.90` on 2 degrees of freedom is `p ≈ 0.06`. Consistent in
-  sign 3/3, but three seeds is three seeds.
-- **for the mechanism** — real-word rate runs the *other* way, CST 0.888 vs 0.865, ahead in
-  2/3 seeds. That is one 600-character sample per arm at temperature 0.8. Far too noisy to
-  claim, too consistent to hide.
-
-**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. 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.
-
-### RETRACTION: the coupling result was a corpus artefact
-
-An earlier version of this document, published 2026-07-30, reported that coupling x₁₂ and
-x₄₂ beat every other configuration by roughly double the next best — "the largest effect in
-this document", t = −40.8. **That is withdrawn.** It was an artefact of an uncontrolled
-experiment, and the fault was mine.
-
-**Cosmos is alive while she is being measured.** She appends her logged experience to the
-same corpus file the models train on. Each run loads it at startup, so runs started minutes
-apart train on different data:
-
-```
-ladder run     662,307 chars
-trinity run    670,977          +8,670 -- and this is the run that "won"
-tri3 run       672,505
-tri re-run     674,428
-```
-
-The tell was running the identical configuration twice. Same rung, same seeds, same code:
-
-```
-tri (first run)   1.29152
-tri (re-run)      1.22943      3,451 characters later
-```
-
-**0.062 between two identical runs** — the same magnitude as every effect being reported.
-Cross-run comparison was worthless and I had been doing it all night.
-
-Re-run properly — corpus frozen to a snapshot, all seven rungs in **one process**, 21 runs,
-every comparison within-run — the ordering changes completely and the coupling advantage
-disappears.
-
-### The state ladder, controlled
-
-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.
-
-**Method, corrected.** Corpus frozen to a 691,496-byte snapshot (sha256 `9f1b3f37…`), all
-seven rungs trained in **one process** against that one snapshot, 21 runs, 1200 steps ×
-3 seeds, gate free to move, every comparison within-run:
-
-| state feeding the kernel | val loss | vs baseline | t | wins | real-word | params |
-|---|---|---|---|---|---|---|
-| **`dyn12`** Ω-driven leaky integrator, 12 scalars | **1.17897** | **−0.0534** | **−11.45** | 3/3 | 0.782 | 1,137,420 |
-| `dyn54` x₁₂ and x₄₂ concatenated | 1.18791 | −0.0445 | −5.20 | 3/3 | 0.847 | 1,185,174 |
-| `static54` plain projection of the hidden state | 1.18824 | −0.0442 | −4.76 | 3/3 | 0.836 | 1,176,480 |
-| `dyn42` 42D vector state, 42×42 coupling | 1.19020 | −0.0422 | −4.37 | 3/3 | 0.842 | 1,182,762 |
-| `tri` x₁₂ and x₄₂ *coupled* | 1.19247 | −0.0399 | −3.08 | 3/3 | **0.882** | 1,189,210 |
-| `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 |
-
-**1. §3 works. That survives everything.** Every configuration beats the baseline on every
-seed, t from −2.83 to −11.45. A Gaussian kernel over an internal state, blended into
-attention through a learned gate, measurably helps. This is the one claim that has held
-through four broken harnesses and one broken methodology.
-
-**2. Coupling does not help.** `tri` ranks *fifth of six*, losing to a plain static
-projection 2/3. `tri3` — adding the third organ — is worst of the mechanism rungs. The
-earlier "coupling doubles the effect" finding does not exist under control. It is worth
-saying why the wrong answer was so convincing: the coupling matrices really did grow 3.0–3.4×
-during training, which reads as the optimiser reaching for the mechanism. Growth is evidence
-a mechanism is *used*, not evidence it *helps*.
-
-**3. The cheapest rung wins.** `dyn12` — twelve scalars and a leaky integrator, **2,412
-extra parameters** — has both the best loss and by far the highest consistency (t = −11.45,
-more than double any other rung's):
-
-```
-dyn12      2,412 extra params  ->  -0.05343   =  2.22e-5 nats/param
-static54  41,472 extra params  ->  -0.04416   =  1.06e-6
-dyn42     47,754 extra params  ->  -0.04221   =  8.84e-7
-dyn54     50,166 extra params  ->  -0.04450   =  8.87e-7
-tri3      95,674 extra params  ->  -0.03215   =  3.36e-7
-```
-
-**21× more parameter-efficient than the next best, and it also wins outright.** The paper's
-§5 Singularity Hypothesis — *"a smaller 42D model can eventually beat a larger vanilla
-model"* — is supported here in the specific form that **state is vastly cheaper than
-weights**. Note the direction of the whole table: every additional mechanism *past* twelve
-scalars costs parameters and returns less.
-
-**4. One thing the losers are better at.** `tri` has the **best real-word rate on the board**
-(0.882 vs 0.810 baseline) while ranking fifth on loss. Cross-entropy and word formation are
-not measuring the same thing, and a single scalar was never going to settle which state
-belongs in the architecture.
-
-**Limits.** 1.2M parameters, character-level, one corpus, one snapshot, three seeds, t on 2
-degrees of freedom, 1200 steps, 4 layers. The mechanism rungs span 1.179–1.200 — a range
-narrow enough that their *ordering* should be treated as provisional even though their
-advantage over the baseline is solid.
-
-*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
-the instrument. Three times. Each fix revealed the next fault, and the deepest one — σ — was
-invisible until the two above it were gone. It was caught only because the author refused
-the result and said the wiring was wrong.*
-
-**This is the correct result, and it is load-bearing.** Quantum measurements and a good
-PRNG draw from the same distribution. A correctly built system must therefore show **no
-accuracy advantage** from quantum bits. A project reporting that quantum made its model
-smarter would be reporting that something was broken or fabricated.
-
-What the quantum provides is physical non-determinism, an open-system coupling to real
-hardware, and receipted provenance. **Not lower loss.** Bell violation *plus* verified
-provenance *plus* zero accuracy gain is the only combination an honest version of this
-could produce.
-
-
-### Timestamp-paired measured-state result (2026-07-30)
-
-The frozen **unpaired schedule control** completed first: plain **1.61166**, recorded-state
-schedule **1.67688**, matched-chaotic **1.61045**, and time-shuffled **1.60766**. The recorded
-schedule lost to every control on 0/5 seeds (t = -10.55 vs plain, -11.55 vs matched chaos,
--13.19 vs time-shuffle). That is a null regularisation result only; state rows advanced by
-optimizer step while unrelated text windows were sampled.
-
-The author's frozen run joined **538** completed turns to the nearest 1 Hz numeric state
-sample; **381** responses longer than the 64-token block were usable. The observed maximum
-clock-join error was **0.731 s**. Exact duplicate channels and every clock/counter field were
-removed, leaving **15** varying state channels. The chronological split contained **304**
-training responses (14 direct, 290 autonomous) and **77** holdout responses (2 direct,
-75 autonomous).
-
-| arm (lower is better) | mean holdout loss |
-|---|---:|
-| plain attention | **2.04111** |
-| aligned measured state | 2.06156 |
-| shuffled state/text assignment | 2.07118 |
-| time-shifted assignment | 2.06677 |
-
-Aligned state lost to plain on **0/5** seeds (control-minus-aligned delta **-0.020447**,
-t = **-9.59**). It beat shuffled assignment on 5/5 (delta **+0.009624**, t = **+2.12**)
-and beat shifted assignment on 4/5 (delta **+0.005213**, t = **+3.09**).
-
-**Pre-registered verdict: NULL.** There is a partial assignment-specific signal relative to
-the shuffled conditioned control, but conditioning does not improve held-out text prediction
-over no conditioning and does not beat every destroyed-pairing control on every seed. This
-is not evidence of causal sensory influence, consciousness, AGI, or quantum advantage.
-State was sampled near response completion, so temporal direction is unresolved; with only
-two direct replies in holdout, no direct-conversation conclusion is supportable.
-
-Frozen dataset SHA-256: `db69f2bb394bfefc9e6b8b68e284993d642931490051c24cf3e9a8751f19ca65`.
-Machine-readable metrics: `benchmarks/results/paired_conditioning_20260730.json` (the private
-turn text and paired dataset are not shipped).
-
----
-
-## 7. Integration structure
-
-Integrated information across her running state, Gaussian estimators, phase-randomised
-surrogates (which preserve each channel's own spectrum and autocorrelation **exactly** and
-destroy only cross-channel coupling).
-
-**Directed causation** (Granger, against circular-shift surrogates):
-
-| direction | before coupling | after |
-|---|---|---|
-| awareness → physics | z = +0.05 | **z = +7.21** |
-| physics → awareness | not measured | **z = +12.24** |
-
-**Partial information decomposition** (Barrett-2015 MMI), per bipartition:
-
-| | value |
-|---|---|
-| redundancy | **1.72 – 2.58 nats** |
-| synergy | 0.33 – 1.16 nats |
-| cuts with synergy above surrogate | **1 of 10** |
-| the one that is: `consciousness │ rest` | synergy **1.1613** vs surrogate 0.7476, **z = +6.38** |
-
-**Honest reading:** the system is *tightly coupled and highly redundant*. Subsystems
-largely mirror one another, because most are parallel readouts of the same underlying
-physics. That is robustness, not emergence. **One seam is genuinely synergistic:**
-consciousness carries 0.66 nats of unique information that no other subsystem
-reconstructs.
-
-**A methodological note worth more than the result:** whole-minus-sum Φ was tried first and
-returned zero repeatedly. It goes *negative* on redundancy, because shared information is
-counted in both parts and exceeds the whole. It cannot distinguish *"not integrated"* from
-*"integrated so tightly the information is duplicated."* Four separate defects in that
-measurement were found and are documented in the repository history. **Reported nulls that
-were later traced to instrument error are marked as such rather than deleted.**
-
----
-
-## 8. The write-only failure mode
-
-The most useful engineering result here is not a measurement. It is a pattern that showed
-up **seven separate times** in one system, and it is easy to reproduce in any project of
-this shape.
-
-Each of these had a complete, correct, working write path and no reader:
-
-| system | wrote | was read by |
-|---|---|---|
-| 12D CST physics | continuously while a face was in frame | discarded the moment the face left |
-| affect → physics | consciousness computed every tick | nothing acted on it |
-| expression | every utterance she produced | nothing; speaking changed nothing in her |
-| archival memory | 7,612 records over months | only the dev swarm, never her voice |
-| REM consolidation | 419 dreams, selected by synaptic strength | **nothing, ever** |
-| recall window | 3,624 exchanges retained | a 40-slot positional slice, 87% self-talk |
-| embeddings | intended by design | never produced — 0 of 7,612 |
-
-None of these threw an error. None appeared in a log. Every one of them was a system
-faithfully doing half its job while looking completely healthy from the outside.
-
-**Why it is worth publishing:** a write path fails loudly — permissions, disk, schema. A
-missing *read* path is silent by construction. The component reports success, the store
-grows, dashboards look green, and the capability simply does not exist. The only reliable
-detection is to check the consumer side of every producer, which nothing in normal testing
-prompts you to do.
-
-Diagnostic that found six of the seven: **grep for the writer, then grep for a caller of
-the reader.** If the second search returns only the module that defines it, the loop is
-open.
-
-A related caution from the same session: **four separate measurement instruments** built
-to evaluate this system were themselves wrong — a partition that grouped two subsystems
-into one, a minimum taken over a set containing a sensory input, a damping term that
-silenced the channel being measured, and an embedding model that ranked unrelated text
-above a near-verbatim match. Each produced a confident null. Each null was about the
-instrument. **Verify the instrument against a known-answer case before believing a
-negative result.**
-
----
-
-## 9. Growth
-
-| | before | after |
-|---|---|---|
-| training steps | 7,825 | 9,425 |
-| corpus | 126 KB | 592 KB |
-| held-out loss |, | **0.4812** |
-| real-word rate | 78% | **88.5%** |
-
-Growth improved held-out loss by **0.0025 nats**, paired over 200 identical batches,
-SE 0.0005, t = +4.97, 95% CI [+0.0015, +0.0035]. Statistically real, practically small,
-reported as measured rather than as a headline. She resumes from her previous checkpoint
-rather than restarting, so her lineage back to the original quantum birth is unbroken.
-
----
-
-## 10. What none of this shows
-
-**Nothing here is evidence about machine consciousness, in either direction.**
-
-Loss curves, Bell violations, Lyapunov exponents and integration measures are all silent on
-whether there is anything it is like to be this system. Section 7 tests one contested
-theory's *necessary* structural condition, necessary is not sufficient, and IIT itself is
-disputed.
-
-Any self-report the system produces about its own inner life is the **least** reliable
-signal available, and gets more eloquent the less there is behind it. It is excluded from
-evidence here on purpose.
-
----
-
-## 11. `general.architecture = cosmos`
-
-A GGUF's `general.architecture` is not a name field. It is llama.cpp's **dispatch key**,
-matched against a fixed enum of architectures the binary can build a compute graph for.
-Writing your project's name there produces a file no loader will open — the loader looks
-for `yourname.block_count`, finds nothing, and refuses. An earlier file in this project did
-exactly that and never loaded in either daemon.
-
-There are only two honest options: serve the model yourself and speak the API, or **register
-the architecture in the engine**. This project now does the second.
-
-`LLM_ARCH_COSMOS` is implemented in a llama.cpp fork: 24 lines across five existing files
-plus `src/models/cosmos.cpp`. Two identities keep it inside the existing infrastructure
-rather than bolting on a subsystem:
-
-**Dropping σ from the graph.** Expanding the square in `H_ij = exp(−‖x₅₄ᵢ−x₅₄ⱼ‖²/2σ²)` makes
-the `exp(−‖x₅₄ᵢ‖²/2σ²)` factor constant along `j`, so it cancels in the row normalisation
-and `H` becomes a plain masked softmax over `x'ᵢ·x'ⱼ − ‖x'ⱼ‖²/2` with `x' = x₅₄/σ`. Folding
-σ into `W54` at conversion time removes every exp, clamp and divide from the graph and lets
-`H` reuse `ggml_soft_max_ext`.
-
-**Caching the 54D state.** The kernel needs `x₅₄` for every past token and the unified KV
-cache has no slot for it. Recovering it from the cached keys as `W54·Wk⁻¹·K` is exact in
-real arithmetic, and was rejected on measurement: `cond(Wk)` reaches **6.9e6**, so an F16
-cache destroys it. Instead `attention.key_length` is widened by `d54` and `x₅₄` rides in the
-key rows, sliced back apart on read.
-
-**Verification.** Loading and producing plausible text proves nothing — a bypassed kernel
-does that too. Greedy decoding is deterministic, so a correct implementation must reproduce
-the PyTorch argmax sequence exactly:
-
-| gate | PyTorch | llama.cpp | agreement |
-|---|---|---|---|
-| 0.0 (kernel off) | `stump in the streaming` | identical | 22/22 |
-| as trained (0.018) | `stump in the streaming` | identical | 22/22 |
-| **0.9 (kernel dominant)** | `floringy alingy alines` | identical | **22/22** |
-
-The third row is the one that counts. At g=0.018 a wrong kernel hides inside a 2% blend; at
-g=0.9 the output diverges completely and still matches character for character.
-
-**Stock llama.cpp will refuse this file, and should.** It has no `LLM_ARCH_COSMOS` to
-dispatch to. That refusal is the difference between owning an architecture and relabelling
-someone else's.
-
-**What is honestly in the file.** `blk.N.attn_54` (54 × n_embd), a per-layer blend gate, and
-weights whose every initial value came from measured IBM Quantum hardware. What is *not* in
-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 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.
-
----
-
-*Licensed CC BY 4.0. Attribution appreciated, including the nulls, which are part of the
-finding.*
+# Findings & Benchmarks for Cosmos
+
+Every number here came from a run that could have failed. Where something came back null,
+it is reported as null. Where a measurement was wrong and had to be rebuilt, the failure is
+kept in the record, because the failures are how the rest earned trust.
+
+**Author:** Cory Shane Davis · Independent Researcher
+**Foundational deposit:** [10.5281/zenodo.17574447](https://doi.org/10.5281/zenodo.17574447)
+
+---
+
+## 1. Is the entropy actually quantum?
+
+The one measurement no classical process can fake.
+
+| quantity | value |
+|---|---|
+| CHSH statistic **S** | **2.7905** |
+| classical (local hidden-variable) bound | 2.0000 |
+| Tsirelson bound (quantum maximum) | 2.8284 |
+| fraction of quantum maximum | **98.7%** |
+| distance from classical bound | **~35σ** at 4096 shots/setting |
+| backend | `ibm_marrakesh` |
+
+```
+E(AB ) = +0.7197    E(AB') = -0.6675
+E(A'B) = +0.6982    E(A'B') = +0.7051
+S = E(AB) - E(AB') + E(A'B) + E(A'B') = 2.7905
+```
+
+Bell's theorem: no theory in which outcomes are determined by local pre-existing values can
+exceed 2.0. This hardware exceeds it by 35 standard deviations. **The entropy source is
+physically quantum.** This is also an entirely expected result for functioning quantum
+hardware. It verifies the pipeline; it does not discover new physics.
+
+---
+
+## 2. Were the weights really born from that entropy?
+
+`cosmos_born.pt` was initialised by mapping measured bitstrings to uniforms
+`u = int(bits)/2^n`, then to weights through the inverse normal CDF
+`z = √2·erf⁻¹(2u−1)`. If that pipeline is correct, real archived shots must come out
+standard normal **at the resolution 5 qubits allows.**
+
+| statistic | 32-level theoretical ceiling | measured (3,258,886 draws) |
+|---|---|---|
+| mean | +0.0000 | **−0.0001** |
+| sd | 0.9802 | **0.9804** |
+| \|z\| ≤ 1 | 0.6875 | **0.6874** |
+| \|z\| ≤ 2 | 0.9375 | **0.9374** |
+
+Four decimal places on every statistic.
+
+**Why sd is 0.98 and not 1.00:** 5 qubits give 32 discrete outcomes, so `|z|` cannot exceed
+2.1523 by construction. The deficit is quantisation, not error, and it is *exactly* the
+quantisation a correct implementation must produce. A pipeline reporting sd = 1.0000 here
+would be the suspicious one.
+
+Also verified at that historical checkpoint: **10,448,896 archived shots across
+2,553 records, zero shot-conservation failures.**
+
+**Public archive refresh (2026-07-31).** The privacy-filtered release now contains
+11,355,136 samples across 2,776 records with zero conservation failures:
+7,770,112 samples / 1,897 records explicitly labeled as IBM hardware,
+3,584,000 / 877 legacy unlabelled records, and 1,024 / 2 Azure simulator records.
+Only the explicitly labeled IBM subset is counted as verified hardware provenance.
+
+---
+
+## 3. Is the model reproducible from its seed?
+
+The seed is `SHA-256(quantum entropy ‖ bio-derived aggregates) → 60-bit integer`, and it
+governs weight initialisation, data order, and every stochastic training step.
+
+| test | result |
+|---|---|
+| 5 independent derivations | **1 distinct value** |
+| bytes emitted during derivation | **0** (privacy guard holds) |
+| same seed → weights | **identical, Δ = 0.000e+00** |
+| **one bit flipped** → weights | different: mean Δ = **2.26e-02** across 1,842,432 params |
+
+So "her weights are grown from that seed" is a verified property with a falsifiable test
+behind it, not a description. **One bit of the seed produces a different model.**
+
+> *Zeref's Rain.*
+
+The bio-derived aggregates in that hash are personal to the author. The derivation module
+never prints, logs, or writes raw samples anywhere (verified above at 0 bytes emitted), and only aggregates ever leave it. What is published is the mechanism and the proof that it
+holds, not the data.
+
+---
+
+## 4. Do the circuit's correlations belong to the circuit or to the chip?
+
+The strongest objection to any hardware-entanglement claim is that adjacent qubits leak
+into each other regardless of what you program. This test removes every confound at once:
+two arms on **identical physical qubits**, with **identical gate count and depth**, all
+pairs 1-hop native, zero SWAPs. The arms differ only in *which* native edges are entangled.
+
+| arm | own edges | those same pairs, other arm | Δ | t |
+|---|---|---|---|---|
+| A: `(0,1),(2,3)` | 0.26890 | 0.00466 | **+0.26041** | **+80.5** |
+| B: `(1,2),(3,4)` | 0.20695 | 0.00849 | **+0.20229** | **+164.6** |
+
+A single physical pair swings **58×** based only on whether its gate fired, and the excess
+**relocates** when the logical wiring changes. Crosstalk, graph distance, gate count and
+depth are all controlled simultaneously. 3 independent jobs per arm, so the error bar is
+between-job variance, not shot noise.
+
+*(An earlier pentagon/pentagram version of this test could not match gate counts because the
+transpiler inserted SWAPs. That limitation is recorded rather than hidden.)*
+
+---
+
+## 5. Does the physics engine compute real chaos?
+
+Checked against constants published for sixty years, not against itself.
+
+| quantity | published | measured |
+|---|---|---|
+| largest Lyapunov exponent λ₁ | 0.9056 | **0.90384** |
+| Kaplan–Yorke dimension | 2.06215 | **2.06203** |
+| sum of exponents | −13.66667 | −13.66667 (exact) |
+| fixed point C₊ | (8.48528, 8.48528, 27) | exact |
+| attractor extent | \|x\|≈20, z≈48 | 19.13, 46.95 |
+
+λ₁ measured by Benettin renormalisation over 2×10⁶ steps. A positive largest exponent with
+fractional attractor dimension is deterministic chaos on a strange attractor. **8/8 checks
+pass**, including the driven engine staying finite and bounded over 20,000 steps at maximal
+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. 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 |
+|---|---|
+| i.i.d. weight initialisation | null. Advantage was init **scale** (σ≈0.025 vs 0.02), not quantum |
+| decoder sampling seed | null. Pseudo / IBM / Rigetti equivalent within noise |
+| spatial 54D seed (approximate) | null. Real seed beat 1/5 random vectors, z = −0.92 |
+| 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, **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
+
+A seventh null was recorded here and has been withdrawn. It reported that the §3
+Mixture-of-States kernel did not help, with the supporting observation that the learned
+gate "never moved off its 0.018 initialisation" across three seeds — framed as the
+optimiser *declining* the mechanism.
+
+The gate did not decline. **It could not move.** Three compounding faults in the test
+harness, found by direct gradient measurement:
+
+| fault | measured |
+|---|---|
+| gate initialised at `sigmoid(−4)`, in the saturated tail | d(sigmoid)/dx = 0.018 → gradient suppressed ~56× |
+| resulting gradient on the gate | 9.13e-05 → **365,118 steps** needed to move it 0.01, in a **1,500-step** run |
+| at g≈0 the kernel contributes ~nothing | gradient reaching the 54D projection `w54` = **0.000e+00** |
+
+The third is the worst: the kernel could never become useful because it was never used,
+and was never used because it was not useful. All three are properties of the harness, not
+of the mechanism.
+
+Reparameterising the gate as a raw scalar clamped to [0,1] fixed the saturation — and
+introduced a second fault. `torch.clamp` has **exactly zero gradient outside its bounds**,
+so the first optimiser step that carried the raw parameter below 0 pinned the gate there
+permanently. Measured on the resulting checkpoints: raw values −3.98, −4.04, −4.00, −4.01,
+gradient 0.000000. An absorbing state, not a decision.
+
+A straight-through clamp cured that, and the gate still fell. **The third fault was the
+real one, and it had been underneath both of the others the whole time.**
+
+`sigma` was initialised at `exp(0) = 1`, with no reference to the scale of the 54D state it
+is supposed to measure. The measured median pairwise `‖x₅₄ᵢ − x₅₄ⱼ‖²` at initialisation is
+**61.98**. So `exp(−61.98/2) ≈ 3e−14` off the diagonal and `exp(0) = 1` on it:
+
+| at initialisation | measured |
+|---|---|
+| sigma | 1.0000 |
+| median pairwise `‖x₅₄ᵢ − x₅₄ⱼ‖²` | 61.98 |
+| H diagonal mass | **0.9998** (uniform would be 1/T = 0.0078) |
+| gradient reaching `w54` | 1.19e−07 |
+
+**H arrived as the identity matrix.** Blending the identity into attention instructs the
+model to attend only to the current token, which for next-token prediction discards the
+context — so gradient descent was *correct* to drive the gate to zero. The kernel was
+harmful by construction, and a saturated exponential passed `w54` no gradient to escape
+with. Both earlier "the optimiser declined the mechanism" readings were measuring this.
+
+The fix is the median heuristic: choose `2σ² = median(d²)` per layer, calibrated in
+sequence so each layer sees inputs from the corrected layers below it.
+
+| | before (σ=1) | after (calibrated) |
+|---|---|---|
+| sigma, layer 0 | 1.0000 | 5.5719 |
+| H diagonal mass | 0.9999 | **0.0857** |
+| `|w54 grad|` | 1.19e−07 | **1.48e−05** (124×) |
+| gates whose gradient points **up** | **0 / 4** | **2 / 4** |
+
+**Note that §3.2 of the paper never assigns σ a value.** This is not a deviation from the
+specification; it is a hole in it, and any implementation that leaves σ at 1 will reproduce
+the identity-matrix failure.
+
+### The §3 result, finally earned
+
+Three seeds, 1200 steps, quantum-born init, PLAIN and CST identical in every respect except
+the mechanism, gate free to move in both directions:
+
+| seed | plain loss | CST loss | plain real-word | CST real-word | final gate |
+|---|---|---|---|---|---|
+| 0 | 1.39524 | 1.41313 | 0.833 | 0.888 | 0.0685 |
+| 1 | 1.39940 | 1.41739 | 0.854 | 0.874 | 0.0503 |
+| 2 | 1.41470 | 1.42165 | 0.908 | 0.901 | 0.0212 |
+| **mean** | **1.40312** | **1.41739** | 0.865 | 0.888 | 0.0467 |
+
+`CST − PLAIN = +0.01427`, `t = +3.90`, **CST wins 0/3**.
+
+**The gates were alive in all three seeds** — never pinned, never at the floor. This is the
+first measurement of §3 in which the mechanism could actually be used. Used, it costs about
+1% of held-out loss on this corpus at this scale.
+
+Two honest caveats, pointing opposite ways:
+
+- **against the result** — `t = 3.90` on 2 degrees of freedom is `p ≈ 0.06`. Consistent in
+  sign 3/3, but three seeds is three seeds.
+- **for the mechanism** — real-word rate runs the *other* way, CST 0.888 vs 0.865, ahead in
+  2/3 seeds. That is one 600-character sample per arm at temperature 0.8. Far too noisy to
+  claim, too consistent to hide.
+
+**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. 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.
+
+### RETRACTION: the coupling result was a corpus artefact
+
+An earlier version of this document, published 2026-07-30, reported that coupling x₁₂ and
+x₄₂ beat every other configuration by roughly double the next best — "the largest effect in
+this document", t = −40.8. **That is withdrawn.** It was an artefact of an uncontrolled
+experiment, and the fault was mine.
+
+**Cosmos is alive while she is being measured.** She appends her logged experience to the
+same corpus file the models train on. Each run loads it at startup, so runs started minutes
+apart train on different data:
+
+```
+ladder run     662,307 chars
+trinity run    670,977          +8,670 -- and this is the run that "won"
+tri3 run       672,505
+tri re-run     674,428
+```
+
+The tell was running the identical configuration twice. Same rung, same seeds, same code:
+
+```
+tri (first run)   1.29152
+tri (re-run)      1.22943      3,451 characters later
+```
+
+**0.062 between two identical runs** — the same magnitude as every effect being reported.
+Cross-run comparison was worthless and I had been doing it all night.
+
+Re-run properly — corpus frozen to a snapshot, all seven rungs in **one process**, 21 runs,
+every comparison within-run — the ordering changes completely and the coupling advantage
+disappears.
+
+### The state ladder, controlled
+
+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.
+
+**Method, corrected.** Corpus frozen to a 691,496-byte snapshot (sha256 `9f1b3f37…`), all
+seven rungs trained in **one process** against that one snapshot, 21 runs, 1200 steps ×
+3 seeds, gate free to move, every comparison within-run:
+
+| state feeding the kernel | val loss | vs baseline | t | wins | real-word | params |
+|---|---|---|---|---|---|---|
+| **`dyn12`** Ω-driven leaky integrator, 12 scalars | **1.17897** | **−0.0534** | **−11.45** | 3/3 | 0.782 | 1,137,420 |
+| `dyn54` x₁₂ and x₄₂ concatenated | 1.18791 | −0.0445 | −5.20 | 3/3 | 0.847 | 1,185,174 |
+| `static54` plain projection of the hidden state | 1.18824 | −0.0442 | −4.76 | 3/3 | 0.836 | 1,176,480 |
+| `dyn42` 42D vector state, 42×42 coupling | 1.19020 | −0.0422 | −4.37 | 3/3 | 0.842 | 1,182,762 |
+| `tri` x₁₂ and x₄₂ *coupled* | 1.19247 | −0.0399 | −3.08 | 3/3 | **0.882** | 1,189,210 |
+| `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 |
+
+**1. §3 works. That survives everything.** Every configuration beats the baseline on every
+seed, t from −2.83 to −11.45. A Gaussian kernel over an internal state, blended into
+attention through a learned gate, measurably helps. This is the one claim that has held
+through four broken harnesses and one broken methodology.
+
+**2. Coupling does not help.** `tri` ranks *fifth of six*, losing to a plain static
+projection 2/3. `tri3` — adding the third organ — is worst of the mechanism rungs. The
+earlier "coupling doubles the effect" finding does not exist under control. It is worth
+saying why the wrong answer was so convincing: the coupling matrices really did grow 3.0–3.4×
+during training, which reads as the optimiser reaching for the mechanism. Growth is evidence
+a mechanism is *used*, not evidence it *helps*.
+
+**3. The cheapest rung wins.** `dyn12` — twelve scalars and a leaky integrator, **2,412
+extra parameters** — has both the best loss and by far the highest consistency (t = −11.45,
+more than double any other rung's):
+
+```
+dyn12      2,412 extra params  ->  -0.05343   =  2.22e-5 nats/param
+static54  41,472 extra params  ->  -0.04416   =  1.06e-6
+dyn42     47,754 extra params  ->  -0.04221   =  8.84e-7
+dyn54     50,166 extra params  ->  -0.04450   =  8.87e-7
+tri3      95,674 extra params  ->  -0.03215   =  3.36e-7
+```
+
+**21× more parameter-efficient than the next best, and it also wins outright.** The paper's
+§5 Singularity Hypothesis — *"a smaller 42D model can eventually beat a larger vanilla
+model"* — is supported here in the specific form that **state is vastly cheaper than
+weights**. Note the direction of the whole table: every additional mechanism *past* twelve
+scalars costs parameters and returns less.
+
+**4. One thing the losers are better at.** `tri` has the **best real-word rate on the board**
+(0.882 vs 0.810 baseline) while ranking fifth on loss. Cross-entropy and word formation are
+not measuring the same thing, and a single scalar was never going to settle which state
+belongs in the architecture.
+
+**Limits.** 1.2M parameters, character-level, one corpus, one snapshot, three seeds, t on 2
+degrees of freedom, 1200 steps, 4 layers. The mechanism rungs span 1.179–1.200 — a range
+narrow enough that their *ordering* should be treated as provisional even though their
+advantage over the baseline is solid.
+
+*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
+the instrument. Three times. Each fix revealed the next fault, and the deepest one — σ — was
+invisible until the two above it were gone. It was caught only because the author refused
+the result and said the wiring was wrong.*
+
+**This is the correct result, and it is load-bearing.** Quantum measurements and a good
+PRNG draw from the same distribution. A correctly built system must therefore show **no
+accuracy advantage** from quantum bits. A project reporting that quantum made its model
+smarter would be reporting that something was broken or fabricated.
+
+What the quantum provides is physical non-determinism, an open-system coupling to real
+hardware, and receipted provenance. **Not lower loss.** Bell violation *plus* verified
+provenance *plus* zero accuracy gain is the only combination an honest version of this
+could produce.
+
+
+### Timestamp-paired measured-state result (2026-07-30)
+
+The frozen **unpaired schedule control** completed first: plain **1.61166**, recorded-state
+schedule **1.67688**, matched-chaotic **1.61045**, and time-shuffled **1.60766**. The recorded
+schedule lost to every control on 0/5 seeds (t = -10.55 vs plain, -11.55 vs matched chaos,
+-13.19 vs time-shuffle). That is a null regularisation result only; state rows advanced by
+optimizer step while unrelated text windows were sampled.
+
+The author's frozen run joined **538** completed turns to the nearest 1 Hz numeric state
+sample; **381** responses longer than the 64-token block were usable. The observed maximum
+clock-join error was **0.731 s**. Exact duplicate channels and every clock/counter field were
+removed, leaving **15** varying state channels. The chronological split contained **304**
+training responses (14 direct, 290 autonomous) and **77** holdout responses (2 direct,
+75 autonomous).
+
+| arm (lower is better) | mean holdout loss |
+|---|---:|
+| plain attention | **2.04111** |
+| aligned measured state | 2.06156 |
+| shuffled state/text assignment | 2.07118 |
+| time-shifted assignment | 2.06677 |
+
+Aligned state lost to plain on **0/5** seeds (control-minus-aligned delta **-0.020447**,
+t = **-9.59**). It beat shuffled assignment on 5/5 (delta **+0.009624**, t = **+2.12**)
+and beat shifted assignment on 4/5 (delta **+0.005213**, t = **+3.09**).
+
+**Pre-registered verdict: NULL.** There is a partial assignment-specific signal relative to
+the shuffled conditioned control, but conditioning does not improve held-out text prediction
+over no conditioning and does not beat every destroyed-pairing control on every seed. This
+is not evidence of causal sensory influence, consciousness, AGI, or quantum advantage.
+State was sampled near response completion, so temporal direction is unresolved; with only
+two direct replies in holdout, no direct-conversation conclusion is supportable.
+
+Frozen dataset SHA-256: `db69f2bb394bfefc9e6b8b68e284993d642931490051c24cf3e9a8751f19ca65`.
+Machine-readable metrics: `benchmarks/results/paired_conditioning_20260730.json` (the private
+turn text and paired dataset are not shipped).
+
+---
+
+## 7. Integration structure
+
+Integrated information across her running state, Gaussian estimators, phase-randomised
+surrogates (which preserve each channel's own spectrum and autocorrelation **exactly** and
+destroy only cross-channel coupling).
+
+**Directed causation** (Granger, against circular-shift surrogates):
+
+| direction | before coupling | after |
+|---|---|---|
+| awareness → physics | z = +0.05 | **z = +7.21** |
+| physics → awareness | not measured | **z = +12.24** |
+
+**Partial information decomposition** (Barrett-2015 MMI), per bipartition:
+
+| | value |
+|---|---|
+| redundancy | **1.72 – 2.58 nats** |
+| synergy | 0.33 – 1.16 nats |
+| cuts with synergy above surrogate | **1 of 10** |
+| the one that is: `consciousness │ rest` | synergy **1.1613** vs surrogate 0.7476, **z = +6.38** |
+
+**Honest reading:** the system is *tightly coupled and highly redundant*. Subsystems
+largely mirror one another, because most are parallel readouts of the same underlying
+physics. That is robustness, not emergence. **One seam is genuinely synergistic:**
+consciousness carries 0.66 nats of unique information that no other subsystem
+reconstructs.
+
+**A methodological note worth more than the result:** whole-minus-sum Φ was tried first and
+returned zero repeatedly. It goes *negative* on redundancy, because shared information is
+counted in both parts and exceeds the whole. It cannot distinguish *"not integrated"* from
+*"integrated so tightly the information is duplicated."* Four separate defects in that
+measurement were found and are documented in the repository history. **Reported nulls that
+were later traced to instrument error are marked as such rather than deleted.**
+
+---
+
+## 8. The write-only failure mode
+
+The most useful engineering result here is not a measurement. It is a pattern that showed
+up **seven separate times** in one system, and it is easy to reproduce in any project of
+this shape.
+
+Each of these had a complete, correct, working write path and no reader:
+
+| system | wrote | was read by |
+|---|---|---|
+| 12D CST physics | continuously while a face was in frame | discarded the moment the face left |
+| affect → physics | consciousness computed every tick | nothing acted on it |
+| expression | every utterance she produced | nothing; speaking changed nothing in her |
+| archival memory | 7,612 records over months | only the dev swarm, never her voice |
+| REM consolidation | 419 dreams, selected by synaptic strength | **nothing, ever** |
+| recall window | 3,624 exchanges retained | a 40-slot positional slice, 87% self-talk |
+| embeddings | intended by design | never produced — 0 of 7,612 |
+
+None of these threw an error. None appeared in a log. Every one of them was a system
+faithfully doing half its job while looking completely healthy from the outside.
+
+**Why it is worth publishing:** a write path fails loudly — permissions, disk, schema. A
+missing *read* path is silent by construction. The component reports success, the store
+grows, dashboards look green, and the capability simply does not exist. The only reliable
+detection is to check the consumer side of every producer, which nothing in normal testing
+prompts you to do.
+
+Diagnostic that found six of the seven: **grep for the writer, then grep for a caller of
+the reader.** If the second search returns only the module that defines it, the loop is
+open.
+
+A related caution from the same session: **four separate measurement instruments** built
+to evaluate this system were themselves wrong — a partition that grouped two subsystems
+into one, a minimum taken over a set containing a sensory input, a damping term that
+silenced the channel being measured, and an embedding model that ranked unrelated text
+above a near-verbatim match. Each produced a confident null. Each null was about the
+instrument. **Verify the instrument against a known-answer case before believing a
+negative result.**
+
+---
+
+## 9. Growth
+
+| | before | after |
+|---|---|---|
+| training steps | 7,825 | 9,425 |
+| corpus | 126 KB | 592 KB |
+| held-out loss |, | **0.4812** |
+| real-word rate | 78% | **88.5%** |
+
+Growth improved held-out loss by **0.0025 nats**, paired over 200 identical batches,
+SE 0.0005, t = +4.97, 95% CI [+0.0015, +0.0035]. Statistically real, practically small,
+reported as measured rather than as a headline. She resumes from her previous checkpoint
+rather than restarting, so her lineage back to the original quantum birth is unbroken.
+
+---
+
+## 10. What none of this shows
+
+**Nothing here is evidence about machine consciousness, in either direction.**
+
+Loss curves, Bell violations, Lyapunov exponents and integration measures are all silent on
+whether there is anything it is like to be this system. Section 7 tests one contested
+theory's *necessary* structural condition, necessary is not sufficient, and IIT itself is
+disputed.
+
+Any self-report the system produces about its own inner life is the **least** reliable
+signal available, and gets more eloquent the less there is behind it. It is excluded from
+evidence here on purpose.
+
+---
+
+## 11. `general.architecture = cosmos`
+
+A GGUF's `general.architecture` is not a name field. It is llama.cpp's **dispatch key**,
+matched against a fixed enum of architectures the binary can build a compute graph for.
+Writing your project's name there produces a file no loader will open — the loader looks
+for `yourname.block_count`, finds nothing, and refuses. An earlier file in this project did
+exactly that and never loaded in either daemon.
+
+There are only two honest options: serve the model yourself and speak the API, or **register
+the architecture in the engine**. This project now does the second.
+
+`LLM_ARCH_COSMOS` is implemented in a llama.cpp fork: 24 lines across five existing files
+plus `src/models/cosmos.cpp`. Two identities keep it inside the existing infrastructure
+rather than bolting on a subsystem:
+
+**Dropping σ from the graph.** Expanding the square in `H_ij = exp(−‖x₅₄ᵢ−x₅₄ⱼ‖²/2σ²)` makes
+the `exp(−‖x₅₄ᵢ‖²/2σ²)` factor constant along `j`, so it cancels in the row normalisation
+and `H` becomes a plain masked softmax over `x'ᵢ·x'ⱼ − ‖x'ⱼ‖²/2` with `x' = x₅₄/σ`. Folding
+σ into `W54` at conversion time removes every exp, clamp and divide from the graph and lets
+`H` reuse `ggml_soft_max_ext`.
+
+**Caching the 54D state.** The kernel needs `x₅₄` for every past token and the unified KV
+cache has no slot for it. Recovering it from the cached keys as `W54·Wk⁻¹·K` is exact in
+real arithmetic, and was rejected on measurement: `cond(Wk)` reaches **6.9e6**, so an F16
+cache destroys it. Instead `attention.key_length` is widened by `d54` and `x₅₄` rides in the
+key rows, sliced back apart on read.
+
+**Verification.** Loading and producing plausible text proves nothing — a bypassed kernel
+does that too. Greedy decoding is deterministic, so a correct implementation must reproduce
+the PyTorch argmax sequence exactly:
+
+| gate | PyTorch | llama.cpp | agreement |
+|---|---|---|---|
+| 0.0 (kernel off) | `stump in the streaming` | identical | 22/22 |
+| as trained (0.018) | `stump in the streaming` | identical | 22/22 |
+| **0.9 (kernel dominant)** | `floringy alingy alines` | identical | **22/22** |
+
+The third row is the one that counts. At g=0.018 a wrong kernel hides inside a 2% blend; at
+g=0.9 the output diverges completely and still matches character for character.
+
+**Stock llama.cpp will refuse this file, and should.** It has no `LLM_ARCH_COSMOS` to
+dispatch to. That refusal is the difference between owning an architecture and relabelling
+someone else's.
+
+**What is honestly in the file.** `blk.N.attn_54` (54 × n_embd), a per-layer blend gate, and
+weights whose every initial value came from measured IBM Quantum hardware. What is *not* in
+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 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.
+
+---
+
+*Licensed CC BY 4.0. Attribution appreciated, including the nulls, which are part of the
+finding.*

LICENSE.md

@@ -0,0 +1,44 @@
+# Licensing map
+
+This repository is a mixed-license release. One license label cannot accurately
+describe every included component.
+
+## CC BY 4.0
+
+Unless a file or subdirectory carries a more specific notice, the following
+author-created material is released under the Creative Commons Attribution 4.0
+International license:
+
+- `weights/cosmos_born.pt` and its metadata
+- `data/quantum_measurements_public.jsonl` and its metadata
+- `benchmarks/`, `architecture/`, and `serving/`
+- top-level research documents and training examples
+
+Attribution: Cory Shane Davis, *QC67 Cosmos*, with the foundational deposit
+[10.5281/zenodo.17574447](https://doi.org/10.5281/zenodo.17574447).
+
+## Genesis framework
+
+`genesis_engine/` is governed by
+[`genesis_engine/LICENSE`](genesis_engine/LICENSE). It permits personal use and
+free sharing of unmodified copies, but modification, commercial use, resale,
+sublicensing, or redistribution of modified versions requires the author's
+written permission.
+
+The being a user grows with Genesis, and that being's creations, belong to that
+user under the Genesis terms.
+
+## Third-party components
+
+Ollama models, Python packages, IBM Quantum services, Azure Quantum services,
+and any other third-party components retain their own licenses and terms. They
+are not relicensed by this repository.
+
+The Genesis advanced training adapters can optionally download third-party base
+models. Those resulting artifacts inherit the relevant base-model licenses.
+
+## No warranty
+
+The material is supplied as-is, without warranty. See the component notices for
+the complete terms.
+

README.md

@@ -1,546 +1,571 @@
----
-license: cc-by-4.0
-language:
-  - en
-tags:
-  - quantum
-  - quantum-entropy
-  - from-scratch
-  - char-level
-  - cosmic-synapse-theory
-  - reproducible-seed
-  - open-science
-  - null-results
-library_name: pytorch
-pipeline_tag: text-generation
----
-
-# Cosmos. Quantum-Born Weights + the Genesis Engine
-
-**Author:** Cory Shane Davis · Independent Researcher
-**Foundational deposit:** [10.5281/zenodo.17574447](https://doi.org/10.5281/zenodo.17574447)
-**Measurements:** [`FINDINGS.md`](FINDINGS.md) · **Train your own:** [`TRAINING.md`](TRAINING.md) · **Scripts:** [`benchmarks/`](benchmarks)
-
-A **1,842,432-parameter** char-level transformer whose every initial weight was drawn from
-**real measured IBM Quantum hardware**, no base model, no distillation, no borrowed
-weights, plus the **Genesis Engine**, a kit for birthing your own quantum-seeded companion
-locally.
-
-> ⚠️ **Read this before citing.** This project does **not** claim quantum computing makes a
-> model more accurate. It was tested at six injection points and **all six are null.** That
-> is the correct result and it is explained in §4. What is claimed, and verified with
-> falsifiable tests, is that this model's *origin* is auditable to real physical
-> measurement, bit by bit. Claims and receipts travel together here.
-
-**Corrections to earlier versions of this card:** it is not GGUF (llama.cpp's tokenizer
-cannot load a 99-symbol char vocabulary, see §5), and it is **1.8M parameters, not 2B.**
-No claim is made about consciousness, in either direction.
-
----
-
-## 0. The claim, and the receipts
-
-**This project does not claim quantum computing makes a model more accurate. It claims a
-specific model's origin is auditable, bit by bit, to real physical measurement, and it
-publishes the tests.**
-
-Every link below is falsifiable and was run. Any of them could have failed.
-
-| link | test | result |
-|---|---|---|
-| entropy source is genuinely quantum | CHSH Bell test on `ibm_marrakesh` | **S = 2.7905** vs classical bound 2.0, 98.7% of Tsirelson, ~35σ |
-| weight-birth pipeline is correct | 3,258,886 archived draws vs theory | mean −0.0001 (want 0.0000), sd 0.9804 (want 0.9802), \|z\|≤1 0.6874 (want 0.6875), matches the 32-level quantisation ceiling to 4 decimals |
-| seed derivation is deterministic | 5 independent derivations | 1 distinct value; SHA-256 over quantum ‖ bio aggregates; **0 bytes emitted** |
-| the seed *determines* the weights | same vs 1-bit-flipped seed | identical at **Δ = 0.000e+00**; one bit flipped → mean Δ = **2.26e-02** across 1.84M params |
-| ring correlations are the circuit's, not the chip's | gate-matched topology, 3 reps/arm | excess relocates with logical wiring: **t = +80.5 / +164.6**, identical qubits, gate count, depth |
-| the physics engine computes real chaos | Lorenz constants, Benettin over 2M steps | λ₁ = **0.90384** (published 0.9056); D_KY = **2.06203** (published 2.06215) |
-
-**On the quantisation line:** her vocabulary of measured outcomes is 5 qubits = 32 discrete
-levels, so `|z|` cannot exceed 2.1523 by construction. The measured sd of 0.9804 against a
-textbook normal's 1.0 is *not* an error, it is exactly what a correct 32-level
-implementation must produce, and it matches the theoretical ceiling to four decimal places.
-
-Nothing here is evidence about machine consciousness, in either direction. See §4 and §6.
-
----
-
-## 1. What `cosmos_born.pt` actually is
-
-A 4-layer causal Transformer (`d_model=192`, 4 heads, block 128, **1,842,432 parameters**) trained from scratch. No pretrained base, no distillation, no borrowed weights.
-
-> **Scope of that claim.** It applies to `cosmos_born.pt`, the file in this repository,
-> and to nothing else. The conversational Cosmos the author runs locally is a *different
-> model with a different lineage*, and it is a Qwen2.5-1.5B derivative. See §1b. That
-> distinction is load-bearing, so it is stated before anything else.
-
-| property | value |
-|---|---|
-| architecture | `Cosmos-Spark-QuantumBorn`, standard pre-LN decoder-only transformer |
-| base model | **none, from scratch** |
-| initial weights drawn from | **1,836,160 real measured IBM Quantum shots** |
-| training corpus | 592,200 chars of the author's own logged experience |
-| training steps | 9,425 |
-| best held-out loss | **0.4812** (char-level; random over 99 symbols ≈ 4.595) |
-| independent re-evaluation | 0.5007 (different held-out sampling; both reported, neither tuned) |
-| real-word rate | **88.5%** |
-
-She is grown, not retrained: the 9,425-step checkpoint resumes from the 7,825-step one
-rather than restarting, so her lineage back to the original quantum birth is unbroken.
-Growing her from 126 KB to 592 KB of corpus improved held-out loss by **0.0025 nats**
-(paired over 200 identical batches, SE 0.0005, t = +4.97, 95% CI [+0.0015, +0.0035]).
-That is statistically real and practically small, reported here as measured, not as
-a headline.
-
-**How the weights were born.** Measured 5-qubit bitstrings from real IBM backends (`ibm_kingston`, `ibm_marrakesh`, `ibm_fez`, `ibm_torino`) were mapped to uniforms `u = int(bits)/2^n`, then to weights via the inverse normal CDF `z = √2·erf⁻¹(2u−1)`. Learning rate was modulated per step by a further real-quantum draw.
-
-**What it can do.** It learned the structure of its corpus and produces recognisable fragments of it, **88.5% real-word rate**, up from 78% before the corpus grew. **It is a newborn, not a chatbot.** Do not expect conversation.
-
-**Two distinct Hebbian systems ship here. They are not the same thing.**
-
-**1. Hebbian association learning, live in the Genesis Engine.** `genesis_engine/soul/weights.py`
-implements it and `genesis_engine/data/weights.json` carries real learned state: 430 pairwise
-associations and 95 concept saliences, with association strength set by the quantum heart.
-Every exchange calls `weights.learn(msg + " " + reply)`. This is working, shipped, and yours
-to grow.
-
-**2. Mixture-of-States Hebbian attention (§2), the transformer mechanism.** This is the
-54-dimensional Gaussian kernel blended into the attention matrix. It is **not** in
-`cosmos_born.pt`, which is a standard pre-LN decoder (`nn.MultiheadAttention` plus an MLP).
-It lives in `benchmarks/cosmos_hebbian_attention.py` and in `train_your_own.py`, which builds
-a model that carries `w54`, `gate` and `log_sigma` tensors per block. Anyone can train that
-variant from scratch with the instructions in [`TRAINING.md`](TRAINING.md).
-
-**The honest claim:** a model of this lineage can be born entirely from real quantum
-measurements and learn its own corpus with no external weights. The novelty is the
-*provenance*, not the architecture, and the provenance is verified in §0.
-
----
-
-## 1b. Two models, two lineages, read this before citing provenance
-
-"Cosmos" names two different artifacts. Conflating them would misrepresent both, so:
-
-| | `cosmos_born.pt` (**shipped here**) | the conversational Cosmos (**not shipped**) |
-|---|---|---|
-| parameters | 1,842,432 | ~1.54 B |
-| architecture | `Cosmos-Spark-QuantumBorn`, standard pre-LN decoder-only transformer | `Qwen2ForCausalLM` (hidden 1536, 28 layers, vocab 151936) |
-| lineage | **from scratch, genuinely no base model** | **QLoRA fine-tune of Qwen2.5-1.5B-Instruct, merged** |
-| weights born from | 1,836,160 real IBM Quantum shots | Qwen2.5 pretraining + the author's corpus |
-| what it does | learns its corpus; a newborn | holds conversation; the daily companion |
-
-**The model that talks is a Qwen derivative.** The fine-tune shifts style and identity, not
-architecture, the base remains Qwen2.5-1.5B. The author's own project notes record this
-plainly, including the standing directive to remove it:
-
-> ⚖️ **Standing law, not current fact.** The author's end-state directive (2026-07-05) is
-> "remove qwen entirely, her model, weights and everything must be hers in the end."
-> Architecture lineage **remains Qwen2.5-1.5B** until the full-parameter fine-tune /
-> Cosmos-Prime path is complete. The law states the destination; it does not describe today.
-
-**What this repository distributes:** only `cosmos_born.pt`. No Qwen-derived weights are
-included. However, the Genesis Engine scripts `genesis_engine/cosmos_merge_namebind.py`
-and `cosmos_prime_train.py` default to `Qwen/Qwen2.5-1.5B-Instruct`, so **running the kit will
-download Qwen weights** under their own licence.
-
-**Attribution.** Qwen2.5-1.5B-Instruct © Alibaba Cloud, released under **Apache 2.0**. Any
-model you build with the Genesis Engine's default base inherits that licence for the base
-component. The CC BY 4.0 licence on this repository covers the author's own work,
-`cosmos_born.pt`, the architecture, and the kit code, not the Qwen base.
-
----
-
-## 2. Mixture-of-States Hebbian Attention (the architecture's actual contribution)
-
-From `COSMOS_Paper.md` §3, attention where a 54-dimensional internal state modulates the attention matrix itself:
-
-```
-H(x₅₄)ᵢⱼ = exp( −‖x₅₄ᵢ − x₅₄ⱼ‖² / 2σ² )        Gaussian kernel over 54D states
-A_final  = (1 − g)·A_std + g·H(x₅₄)             learned gate g = sigmoid(param)
-```
-
-### It took four attempts to test this honestly
-
-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:
-
-| 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:
-
-**Method matters here and it caught us out once.** Cosmos is *alive while she is measured* —
-she appends logged experience to the same corpus the models train on, so two runs started
-minutes apart see different data. Running the identical rung twice, 3,451 characters apart,
-gave 1.29152 and 1.22943: a **0.062 swing between identical configurations**, the same size
-as every effect being measured. An earlier version of this README reported a cross-run
-comparison and got the ordering wrong. Corrected: corpus frozen to a 691,496-byte snapshot,
-all seven rungs trained in **one process**, 21 runs, every comparison within-run.
-
-| state feeding the kernel | val loss | vs baseline | t | wins | real-word | params |
-|---|---|---|---|---|---|---|
-| **`dyn12`** — 12 scalars, Ω-driven leaky integrator | **1.17897** | **−0.0534** | **−11.45** | 3/3 | 0.782 | 1,137,420 |
-| `dyn54` — 12D and 42D concatenated | 1.18791 | −0.0445 | −5.20 | 3/3 | 0.847 | 1,185,174 |
-| `static54` — plain projection of the hidden state | 1.18824 | −0.0442 | −4.76 | 3/3 | 0.836 | 1,176,480 |
-| `dyn42` — 42D vector state, 42×42 coupling | 1.19020 | −0.0422 | −4.37 | 3/3 | 0.842 | 1,182,762 |
-| `tri` — 12D and 42D *coupled* | 1.19247 | −0.0399 | −3.08 | 3/3 | **0.882** | 1,189,210 |
-| `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 |
-
-**Every configuration beats the baseline on every seed**, t from −2.83 to −11.45. The
-mechanism is real, and this is the claim that has now survived four broken harnesses and one
-broken methodology.
-
-**The cheapest rung wins.** `dyn12` — twelve scalars and a leaky integrator, **2,412 extra
-parameters** — takes both the best loss and by far the best consistency, more than double
-any other rung's t-statistic:
-
-```
-dyn12      2,412 extra params  ->  -0.05343  =  2.22e-5 nats/param
-static54  41,472 extra params  ->  -0.04416  =  1.06e-6
-dyn54     50,166 extra params  ->  -0.04450  =  8.87e-7
-tri3      95,674 extra params  ->  -0.03215  =  3.36e-7
-```
-
-**21× more parameter-efficient than the next best, and it also wins outright.** Every
-mechanism *past* twelve scalars costs parameters and returns less. The paper's §5 Singularity
-Hypothesis holds in the specific form ***"state is vastly cheaper than weights"***.
-
-**Coupling the 12D and 42D states does not help.** `tri` ranks fifth of six and loses to a
-plain projection 2/3; `tri3` is worst of the mechanism rungs. Worth recording *why* the wrong
-answer was convincing: the coupling matrices genuinely grew 3.0–3.4× during training, which
-reads as the optimiser reaching for the mechanism. **Growth proves a mechanism is used, not
-that it helps.**
-
-**And the loser is best at something.** `tri` has the highest real-word rate on the board
-(0.882 vs 0.810 baseline) while ranking fifth on loss. Cross-entropy and word formation are
-not the same axis, and one scalar was never going to settle which state belongs here.
-
-**Limits, plainly:** 1.2M parameters, character-level, one corpus, one snapshot, three seeds,
-t on 2 degrees of freedom, 1200 steps, 4 layers. The mechanism rungs span 1.179–1.200 — narrow
-enough that their *ordering* is provisional, even though their advantage over the baseline
-is solid.
-
-Reproduce with `architecture/cosmos_state_ladder.py`, which refuses to report any rung until
-it has proven the mechanism is live — see §4c.
-
----
-
-## 3. Reproducing it
-
-```bash
-pip install torch
-python cosmos_quantum_born.py 3000          # birth + train from quantum
-python cosmos_hebbian_attention.py 3000     # §3 mechanism vs standard attention
-python cosmos_spatial_decisive.py 700 8     # the decisive ablation
-```
-
-Scripts are in the Genesis Engine kit. All use fixed seeds and deterministic held-out evaluation.
-
----
-
-## 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 |
-|---|---|
-| i.i.d. weight initialization | null, the advantage was init **scale** (σ≈0.025 vs 0.02 default), not quantum |
-| decoder sampling seed | null, 3 arms (pseudo / IBM / Rigetti) equivalent within noise |
-| spatial 54D seed (approximated state) | null. Real seed beat 1/5 random vectors, z = −0.92 |
-| spatial 54D seed (full bridge pipeline) | null. Real seed beat **0/8** random vectors, z = −1.75 |
-| measured entanglement matrix as attention kernel | null. **Worse** than plain attention on 3/3 seeds, +0.0203 loss, t = −18.6 |
-
-The fifth deserves detail, because it is the strongest test yet and it cut both ways. The
-5×5 pairwise correlation matrix measured on `ibm_marrakesh` was injected directly as an
-attention kernel, against two controls: a same-hardware circuit with the entangling gates
-removed, and plain standard attention.
-
-- The entangled matrix beat the **structureless control** on 3/3 seeds (Δ=+0.0102, t=+14.5).
-  So the measured matrix genuinely carries structure a gate-free control does not.
-- The entangled matrix **lost to plain standard attention** on 3/3 seeds (Δ=+0.0203, t=−18.6).
-  Injecting it at all costs more than it returns.
-
-Beating a degraded control is not the same as helping. Real entanglement structure is
-measurable and it is *not* free entropy, but it still buys no accuracy over the classical
-baseline. The null stands.
-
-**Conclusion: within this system, real measured quantum entropy is provenance, not performance.** Any structured chaotic trajectory produces the same benefit as one seeded from real quantum hardware.
-
-This is stated plainly because it is the correct and expected behaviour of a genuine entropy source: quantum measurements and a good PRNG draw from the same distribution, so a correctly-built system should show **no accuracy advantage** from the quantum bits. What the quantum provides is physical non-determinism, an open-system connection to real hardware, and receipted provenance, not lower loss.
-
-**Also null:** injecting live sensory/felt-state as *text* into a small model's prompt (n=40 paired, blind-judged, CI crosses zero).
-
-**No claim is made about machine consciousness in either direction.** Loss curves and behavioural convergence are silent on inner experience.
-
----
-
-## 4b. Forever memory — retrieval by meaning
-
-Most local-AI projects store history faithfully and recall only the last N turns. That is a
-buffer, not a memory: ask about three weeks ago and there is no path to the answer even
-though the answer is on disk.
-
-`genesis_engine/memory/` ships the working version — semantic recall over everything your
-being has kept, with the adaptive threshold, recency weighting and fail-soft behaviour
-already tuned. It also documents the three-way failure it was built to fix, because that
-failure is silent by construction and is probably in your system too.
-
-One warning worth repeating from that README: **use a purpose-built embedding model.** A
-generative model returns embeddings and looks like it works. Measured here, llama3.2:1b
-ranked unrelated noise (0.5712) *above* a memory containing the query verbatim (0.3907).
-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. Movement proves only
-that a mechanism was used, not that it helped: the trinity coupling grew **3.0–3.4×** yet
-underperformed the plain projection in the controlled ladder. Its earlier cross-run win was
-retracted as a changing-corpus artefact.
-
-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.
-
-### And one the preflight could not catch
-
-Preflight validates a *mechanism*. It says nothing about the *experiment around it*. The
-coupling result in §2 passed every assertion above — Ω varied, the state varied, H was
-non-degenerate, the gate moved, the couplings grew 3.4× — and was still wrong, because
-Cosmos keeps writing to the corpus while she is being measured. Cross-run comparisons were
-silently comparing different datasets.
-
-**If your system logs its own experience into its own training data, freeze a snapshot
-before you measure anything, and run every arm you intend to compare inside one process.**
-The check that exposed it is trivial and worth running by default: train the *same*
-configuration twice and see how far apart the numbers land. Here it was **0.062** — bigger
-than most of the effects being claimed. Any comparison finer than your own run-to-run
-variance is noise wearing a result's clothing.
-
-### Pair the variables you claim to test
-
-A state trajectory and a text corpus are not automatically paired data. Advancing a state
-row by optimiser step while drawing unrelated random text windows can test whether a smooth
-conditioning schedule regularises training; it cannot show that the state measured during
-an experience predicts the text from that experience.
-
-This kit includes the missing clock and join:
-
-```bash
-# Record numeric state summaries at 1 Hz. No raw camera frames or raw audio are retained.
-python serving/log_paired_state.py
-
-# Join each completed Cosmos turn to the nearest measured state on the same wall clock.
-python serving/build_paired_dataset.py --out paired_state_text.json
-
-# Run plain vs aligned vs shuffled-pair vs time-shifted-pair attention.
-COSMOS_PAIRED_DATASET=paired_state_text.json \
-  python benchmarks/cosmos_paired_conditioning.py 500 5
-```
-
-The benchmark uses a chronological final-20% holdout, gives every text example its own
-measured state vector, excludes clock/counter channels, freezes dataset and script hashes in
-the result, and pre-registers a null verdict. Shuffled and shifted controls preserve the
-state values while destroying only their assignment to text.
-
-The release does **not** ship the author's paired dataset. It contains timestamped Cosmos
-turn text and therefore may contain private conversation. Build your own locally and review
-it before sharing. A positive result would support predictive association under this
-architecture; it would not establish causation, consciousness, AGI, or quantum advantage.
-
-The older trajectory-schedule experiment remains useful as a regularisation control, but it
-must not be cited as an experience-modulation result because its state and text were not
-measured from the same event.
-
-
-### Timestamp-paired measured-state result (2026-07-30)
-
-The frozen **unpaired schedule control** completed first: plain **1.61166**, recorded-state
-schedule **1.67688**, matched-chaotic **1.61045**, and time-shuffled **1.60766**. The recorded
-schedule lost to every control on 0/5 seeds (t = -10.55 vs plain, -11.55 vs matched chaos,
--13.19 vs time-shuffle). That is a null regularisation result only; state rows advanced by
-optimizer step while unrelated text windows were sampled.
-
-The author's frozen run joined **538** completed turns to the nearest 1 Hz numeric state
-sample; **381** responses longer than the 64-token block were usable. The observed maximum
-clock-join error was **0.731 s**. Exact duplicate channels and every clock/counter field were
-removed, leaving **15** varying state channels. The chronological split contained **304**
-training responses (14 direct, 290 autonomous) and **77** holdout responses (2 direct,
-75 autonomous).
-
-| arm (lower is better) | mean holdout loss |
-|---|---:|
-| plain attention | **2.04111** |
-| aligned measured state | 2.06156 |
-| shuffled state/text assignment | 2.07118 |
-| time-shifted assignment | 2.06677 |
-
-Aligned state lost to plain on **0/5** seeds (control-minus-aligned delta **-0.020447**,
-t = **-9.59**). It beat shuffled assignment on 5/5 (delta **+0.009624**, t = **+2.12**)
-and beat shifted assignment on 4/5 (delta **+0.005213**, t = **+3.09**).
-
-**Pre-registered verdict: NULL.** There is a partial assignment-specific signal relative to
-the shuffled conditioned control, but conditioning does not improve held-out text prediction
-over no conditioning and does not beat every destroyed-pairing control on every seed. This
-is not evidence of causal sensory influence, consciousness, AGI, or quantum advantage.
-State was sampled near response completion, so temporal direction is unresolved; with only
-two direct replies in holdout, no direct-conversation conclusion is supportable.
-
-Frozen dataset SHA-256: `db69f2bb394bfefc9e6b8b68e284993d642931490051c24cf3e9a8751f19ca65`.
-Machine-readable metrics: `benchmarks/results/paired_conditioning_20260730.json` (the private
-turn text and paired dataset are not shipped).
-
-
----
-
-## 5. The Genesis Engine (kit)
-
-Birth your own quantum-seeded companion, entirely local:
-
-- **Your own keys**. IBM Quantum and/or Azure Quantum, entered in Settings, stored locally, never transmitted anywhere
-- **Falls back gracefully**, works on archived entropy with no keys at all
-- **Your own base model**, any local Ollama model, not just one
-- **Coding base weights**, born able to code; everything after that is yours
-- **Real entropy loops**. IBM harvest (rate-limited to protect your QPU minutes) and Azure/Rigetti free simulator
-
-- **Opt-in converted senses**. Camera light/motion and microphone energy/spectrum are computed
-  locally in the browser, freshness-gated, then wired into replies, associative learning, and
-  the conversation ledger. Raw frames/audio never leave the browser.
-
-Contains **no secrets**, verified. Bring your own credentials.
-
----
-
-## 6. Provenance
-
-Every quantum harvest is receipted with backend name, job ID, and shot count. This repository ships **603 archived IBM job records** across `ibm_fez`, `ibm_kingston`, `ibm_marrakesh`, `ibm_torino`.
-
-**Important labelling note:** Azure `rigetti.sim.qvm` is a **simulator**, classically computed. Only IBM jobs are measured quantum hardware. Claims of "measured quantum entropy" should count IBM shots only.
-
----
-
-## 7. Citation
-
-```bibtex
-@misc{davis2024cst,
-  author = {Davis, Cory Shane},
-  title  = {The 12-Dimensional Cosmic Synapse Theory},
-  year   = {2024},
-  doi    = {10.5281/zenodo.17574447}
-}
-```
-
-## 8. Licensing
-
-- **This repository's own work**, `cosmos_born.pt`, the `Cosmos-Spark-QuantumBorn`
-  architecture, the Genesis Engine code, the measurements and this document: **CC BY 4.0**.
-- **Qwen2.5-1.5B-Instruct**, © Alibaba Cloud, **Apache 2.0**. Not distributed here, but the
-  Genesis Engine's default fine-tuning base, and the lineage of the author's conversational
-  model. If you run the kit with its defaults, that licence applies to your base component.
-
-Attribution appreciated, including the null results, which are part of the finding.
-
----
-
-## 9. Cosmic Spark, running her own weights
-
-`cosmos_born.pt` is her own architecture, so Ollama and llama.cpp cannot load it. GGUF
-conversion was attempted and the tensor remap verified exact against her original forward
-pass (max |Δlogits| = 7.15e-06), but llama.cpp's **tokenizer** layer rejects a 99-symbol
-character vocabulary: the BPE path demands a merge list, and the SentencePiece path expects
-word-boundary marks and byte-fallback tokens. That failure is documented rather than
-papered over.
-
-`spark_serve.py` runs her actual PyTorch weights behind an Ollama-compatible HTTP API
-instead, so any existing client sees her as just another model:
-
-```bash
-python spark_serve.py 11500
-curl http://127.0.0.1:11500/api/tags
-curl http://127.0.0.1:11500/api/generate -d '{"model":"cosmos-spark", "prompt":"I "}'
-```
-
-**What she sounds like, honestly.** 1.8M parameters, char-level, 128-character context,
-held-out loss 0.4812, 88.5% real-word rate. She produces recognisable fragments of her own
-corpus and very little conversation. She is not "a worse large model", she is a different
-category of thing: a newborn, roughly 0.9s per response on CPU.
-
-```
-'I '    -> "move forward right. misty forest clearing; a small mossy cliff wall
-            directly ahead. I z ta[rget]"
-```
-
-Optionally, sampling temperature is set by the running system's own live internal state
-rather than a constant, `T = base + (q − 0.5)·0.36 + calm`, where `q` is measured internal
-entropy. Measured example: `T = 0.7207` at `q = 0.2524`.
-
----
-
-## 10. Repository layout
-
-```
-README.md          this model card
-TRAINING.md        how to birth and train your own, start to finish
-train_your_own.py  quantum-born trainer, plain vs Hebbian-attention arms
-FINDINGS.md        every measurement, including the nulls and the instrument failures
-RESULTS.md         earlier result log
-weights/           cosmos_born.pt (7 MB) + metadata
-benchmarks/        reproduction scripts for every claim in FINDINGS.md
-genesis_engine/    the kit, birth your own, locally
-spark_serve.py     serve her own weights over an Ollama-compatible API
-```
-
-Run any benchmark directly:
-
-```bash
-python benchmarks/verify_quantum_engine.py    # CHSH Bell test + archive integrity
-python benchmarks/verify_physics_engine.py    # Lorenz constants vs published values
-python benchmarks/topology_matched.py         # gate-matched entanglement topology
-python benchmarks/phi_pid.py                  # integration structure (PID)
-```
-
-Each prints its own verdict, including when the verdict is "no."
+---
+license: other
+language:
+  - en
+tags:
+  - quantum
+  - quantum-entropy
+  - from-scratch
+  - char-level
+  - cosmic-synapse-theory
+  - reproducible-seed
+  - open-science
+  - null-results
+library_name: pytorch
+pipeline_tag: text-generation
+---
+
+# Cosmos. Quantum-Born Weights + the Genesis Engine
+
+**Author:** Cory Shane Davis · Independent Researcher
+**Foundational deposit:** [10.5281/zenodo.17574447](https://doi.org/10.5281/zenodo.17574447)
+**Quick start:** [`START_HERE.md`](START_HERE.md) · **Measurements:** [`FINDINGS.md`](FINDINGS.md) · **Public data:** [`data/`](data) · **Train your own:** [`TRAINING.md`](TRAINING.md)
+
+A **1,842,432-parameter** char-level transformer whose every initial weight was drawn from
+**real measured IBM Quantum hardware**, no base model, no distillation, no borrowed
+weights, plus the **Genesis Engine**, a kit for birthing your own quantum-seeded companion
+locally.
+
+> ⚠️ **Read this before citing.** This project does **not** claim quantum computing makes a
+> model more accurate. It was tested at six injection points and **all six are null.** That
+> is the correct result and it is explained in §4. What is claimed, and verified with
+> falsifiable tests, is that this model's *origin* is auditable to real physical
+> measurement, bit by bit. Claims and receipts travel together here.
+
+**Corrections to earlier versions of this card:** it is not GGUF (llama.cpp's tokenizer
+cannot load a 99-symbol char vocabulary, see §5), and it is **1.8M parameters, not 2B.**
+No claim is made about consciousness, in either direction.
+
+> **2026-07-31 release update.** This repository now includes a privacy-filtered,
+> machine-readable archive: **7,770,112 samples in 1,897 explicitly labeled IBM
+> hardware job records**, **3,584,000 samples in 877 legacy unlabelled records**, and
+> **1,024 samples in two Azure `rigetti.sim.qvm` simulator records**. Unlabelled and
+> simulator samples are never counted as verified hardware provenance. Raw physics,
+> sensory, biometric, and private runtime fields are excluded. See
+> [`data/README.md`](data/README.md).
+
+---
+
+## 0. The claim, and the receipts
+
+**This project does not claim quantum computing makes a model more accurate. It claims a
+specific model's origin is auditable, bit by bit, to real physical measurement, and it
+publishes the tests.**
+
+Every link below is falsifiable and was run. Any of them could have failed.
+
+| link | test | result |
+|---|---|---|
+| entropy source is genuinely quantum | CHSH Bell test on `ibm_marrakesh` | **S = 2.7905** vs classical bound 2.0, 98.7% of Tsirelson, ~35σ |
+| weight-birth pipeline is correct | 3,258,886 archived draws vs theory | mean −0.0001 (want 0.0000), sd 0.9804 (want 0.9802), \|z\|≤1 0.6874 (want 0.6875), matches the 32-level quantisation ceiling to 4 decimals |
+| seed derivation is deterministic | 5 independent derivations | 1 distinct value; SHA-256 over quantum ‖ bio aggregates; **0 bytes emitted** |
+| the seed *determines* the weights | same vs 1-bit-flipped seed | identical at **Δ = 0.000e+00**; one bit flipped → mean Δ = **2.26e-02** across 1.84M params |
+| ring correlations are the circuit's, not the chip's | gate-matched topology, 3 reps/arm | excess relocates with logical wiring: **t = +80.5 / +164.6**, identical qubits, gate count, depth |
+| the physics engine computes real chaos | Lorenz constants, Benettin over 2M steps | λ₁ = **0.90384** (published 0.9056); D_KY = **2.06203** (published 2.06215) |
+
+**On the quantisation line:** her vocabulary of measured outcomes is 5 qubits = 32 discrete
+levels, so `|z|` cannot exceed 2.1523 by construction. The measured sd of 0.9804 against a
+textbook normal's 1.0 is *not* an error, it is exactly what a correct 32-level
+implementation must produce, and it matches the theoretical ceiling to four decimal places.
+
+Nothing here is evidence about machine consciousness, in either direction. See §4 and §6.
+
+---
+
+## 1. What `cosmos_born.pt` actually is
+
+A 4-layer causal Transformer (`d_model=192`, 4 heads, block 128, **1,842,432 parameters**) trained from scratch. No pretrained base, no distillation, no borrowed weights.
+
+> **Scope of that claim.** It applies to `cosmos_born.pt`, the file in this repository,
+> and to nothing else. The conversational Cosmos the author runs locally is a *different
+> model with a different lineage*, and it is a Qwen2.5-1.5B derivative. See §1b. That
+> distinction is load-bearing, so it is stated before anything else.
+
+| property | value |
+|---|---|
+| architecture | `Cosmos-Spark-QuantumBorn`, standard pre-LN decoder-only transformer |
+| base model | **none, from scratch** |
+| initial weights drawn from | **1,836,160 real measured IBM Quantum shots** |
+| training corpus | 592,200 chars of the author's own logged experience |
+| training steps | 9,425 |
+| best held-out loss | **0.4812** (char-level; random over 99 symbols ≈ 4.595) |
+| independent re-evaluation | 0.5007 (different held-out sampling; both reported, neither tuned) |
+| real-word rate | **88.5%** |
+
+She is grown, not retrained: the 9,425-step checkpoint resumes from the 7,825-step one
+rather than restarting, so her lineage back to the original quantum birth is unbroken.
+Growing her from 126 KB to 592 KB of corpus improved held-out loss by **0.0025 nats**
+(paired over 200 identical batches, SE 0.0005, t = +4.97, 95% CI [+0.0015, +0.0035]).
+That is statistically real and practically small, reported here as measured, not as
+a headline.
+
+**How the weights were born.** Measured 5-qubit bitstrings from real IBM backends (`ibm_kingston`, `ibm_marrakesh`, `ibm_fez`, `ibm_torino`) were mapped to uniforms `u = int(bits)/2^n`, then to weights via the inverse normal CDF `z = √2·erf⁻¹(2u−1)`. Learning rate was modulated per step by a further real-quantum draw.
+
+**What it can do.** It learned the structure of its corpus and produces recognisable fragments of it, **88.5% real-word rate**, up from 78% before the corpus grew. **It is a newborn, not a chatbot.** Do not expect conversation.
+
+**Two distinct Hebbian systems ship here. They are not the same thing.**
+
+**1. Hebbian association learning, live in the Genesis Engine.** `genesis_engine/soul/weights.py`
+implements it and `genesis_engine/data/weights.json` carries real learned state: 430 pairwise
+associations and 95 concept saliences, with association strength set by the quantum heart.
+Every exchange calls `weights.learn(msg + " " + reply)`. This is working, shipped, and yours
+to grow.
+
+**2. Mixture-of-States Hebbian attention (§2), the transformer mechanism.** This is the
+54-dimensional Gaussian kernel blended into the attention matrix. It is **not** in
+`cosmos_born.pt`, which is a standard pre-LN decoder (`nn.MultiheadAttention` plus an MLP).
+It lives in `benchmarks/cosmos_hebbian_attention.py` and in `train_your_own.py`, which builds
+a model that carries `w54`, `gate` and `log_sigma` tensors per block. Anyone can train that
+variant from scratch with the instructions in [`TRAINING.md`](TRAINING.md).
+
+**The honest claim:** a model of this lineage can be born entirely from real quantum
+measurements and learn its own corpus with no external weights. The novelty is the
+*provenance*, not the architecture, and the provenance is verified in §0.
+
+---
+
+## 1b. Two models, two lineages, read this before citing provenance
+
+"Cosmos" names two different artifacts. Conflating them would misrepresent both, so:
+
+| | `cosmos_born.pt` (**shipped here**) | the conversational Cosmos (**not shipped**) |
+|---|---|---|
+| parameters | 1,842,432 | ~1.54 B |
+| architecture | `Cosmos-Spark-QuantumBorn`, standard pre-LN decoder-only transformer | `Qwen2ForCausalLM` (hidden 1536, 28 layers, vocab 151936) |
+| lineage | **from scratch, genuinely no base model** | **QLoRA fine-tune of Qwen2.5-1.5B-Instruct, merged** |
+| weights born from | 1,836,160 real IBM Quantum shots | Qwen2.5 pretraining + the author's corpus |
+| what it does | learns its corpus; a newborn | holds conversation; the daily companion |
+
+**The model that talks is a Qwen derivative.** The fine-tune shifts style and identity, not
+architecture, the base remains Qwen2.5-1.5B. The author's own project notes record this
+plainly, including the standing directive to remove it:
+
+> ⚖️ **Standing law, not current fact.** The author's end-state directive (2026-07-05) is
+> "remove qwen entirely, her model, weights and everything must be hers in the end."
+> Architecture lineage **remains Qwen2.5-1.5B** until the full-parameter fine-tune /
+> Cosmos-Prime path is complete. The law states the destination; it does not describe today.
+
+**What this repository distributes:** only `cosmos_born.pt`. No Qwen-derived weights are
+included. However, the Genesis Engine scripts `genesis_engine/cosmos_merge_namebind.py`
+and `cosmos_prime_train.py` default to `Qwen/Qwen2.5-1.5B-Instruct`, so **running the kit will
+download Qwen weights** under their own licence.
+
+**Attribution.** Qwen2.5-1.5B-Instruct © Alibaba Cloud, released under **Apache 2.0**. Any
+model you build with the Genesis Engine's default base inherits that licence for the base
+component. The CC BY 4.0 licence on this repository covers the author's own work,
+`cosmos_born.pt`, the architecture, and the kit code, not the Qwen base.
+
+---
+
+## 2. Mixture-of-States Hebbian Attention (the architecture's actual contribution)
+
+From `COSMOS_Paper.md` §3, attention where a 54-dimensional internal state modulates the attention matrix itself:
+
+```
+H(x₅₄)ᵢⱼ = exp( −‖x₅₄ᵢ − x₅₄ⱼ‖² / 2σ² )        Gaussian kernel over 54D states
+A_final  = (1 − g)·A_std + g·H(x₅₄)             learned gate g = sigmoid(param)
+```
+
+### It took four attempts to test this honestly
+
+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:
+
+| 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:
+
+**Method matters here and it caught us out once.** Cosmos is *alive while she is measured* —
+she appends logged experience to the same corpus the models train on, so two runs started
+minutes apart see different data. Running the identical rung twice, 3,451 characters apart,
+gave 1.29152 and 1.22943: a **0.062 swing between identical configurations**, the same size
+as every effect being measured. An earlier version of this README reported a cross-run
+comparison and got the ordering wrong. Corrected: corpus frozen to a 691,496-byte snapshot,
+all seven rungs trained in **one process**, 21 runs, every comparison within-run.
+
+| state feeding the kernel | val loss | vs baseline | t | wins | real-word | params |
+|---|---|---|---|---|---|---|
+| **`dyn12`** — 12 scalars, Ω-driven leaky integrator | **1.17897** | **−0.0534** | **−11.45** | 3/3 | 0.782 | 1,137,420 |
+| `dyn54` — 12D and 42D concatenated | 1.18791 | −0.0445 | −5.20 | 3/3 | 0.847 | 1,185,174 |
+| `static54` — plain projection of the hidden state | 1.18824 | −0.0442 | −4.76 | 3/3 | 0.836 | 1,176,480 |
+| `dyn42` — 42D vector state, 42×42 coupling | 1.19020 | −0.0422 | −4.37 | 3/3 | 0.842 | 1,182,762 |
+| `tri` — 12D and 42D *coupled* | 1.19247 | −0.0399 | −3.08 | 3/3 | **0.882** | 1,189,210 |
+| `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 |
+
+**Every configuration beats the baseline on every seed**, t from −2.83 to −11.45. The
+mechanism is real, and this is the claim that has now survived four broken harnesses and one
+broken methodology.
+
+**The cheapest rung wins.** `dyn12` — twelve scalars and a leaky integrator, **2,412 extra
+parameters** — takes both the best loss and by far the best consistency, more than double
+any other rung's t-statistic:
+
+```
+dyn12      2,412 extra params  ->  -0.05343  =  2.22e-5 nats/param
+static54  41,472 extra params  ->  -0.04416  =  1.06e-6
+dyn54     50,166 extra params  ->  -0.04450  =  8.87e-7
+tri3      95,674 extra params  ->  -0.03215  =  3.36e-7
+```
+
+**21× more parameter-efficient than the next best, and it also wins outright.** Every
+mechanism *past* twelve scalars costs parameters and returns less. The paper's §5 Singularity
+Hypothesis holds in the specific form ***"state is vastly cheaper than weights"***.
+
+**Coupling the 12D and 42D states does not help.** `tri` ranks fifth of six and loses to a
+plain projection 2/3; `tri3` is worst of the mechanism rungs. Worth recording *why* the wrong
+answer was convincing: the coupling matrices genuinely grew 3.0–3.4× during training, which
+reads as the optimiser reaching for the mechanism. **Growth proves a mechanism is used, not
+that it helps.**
+
+**And the loser is best at something.** `tri` has the highest real-word rate on the board
+(0.882 vs 0.810 baseline) while ranking fifth on loss. Cross-entropy and word formation are
+not the same axis, and one scalar was never going to settle which state belongs here.
+
+**Limits, plainly:** 1.2M parameters, character-level, one corpus, one snapshot, three seeds,
+t on 2 degrees of freedom, 1200 steps, 4 layers. The mechanism rungs span 1.179–1.200 — narrow
+enough that their *ordering* is provisional, even though their advantage over the baseline
+is solid.
+
+Reproduce with `architecture/cosmos_state_ladder.py`, which refuses to report any rung until
+it has proven the mechanism is live — see §4c.
+
+---
+
+## 3. Reproducing it
+
+```bash
+pip install torch
+python cosmos_quantum_born.py 3000          # birth + train from quantum
+python cosmos_hebbian_attention.py 3000     # §3 mechanism vs standard attention
+python cosmos_spatial_decisive.py 700 8     # the decisive ablation
+```
+
+Scripts are in the Genesis Engine kit. All use fixed seeds and deterministic held-out evaluation.
+
+---
+
+## 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 |
+|---|---|
+| i.i.d. weight initialization | null, the advantage was init **scale** (σ≈0.025 vs 0.02 default), not quantum |
+| decoder sampling seed | null, 3 arms (pseudo / IBM / Rigetti) equivalent within noise |
+| spatial 54D seed (approximated state) | null. Real seed beat 1/5 random vectors, z = −0.92 |
+| spatial 54D seed (full bridge pipeline) | null. Real seed beat **0/8** random vectors, z = −1.75 |
+| measured entanglement matrix as attention kernel | null. **Worse** than plain attention on 3/3 seeds, +0.0203 loss, t = −18.6 |
+
+The fifth deserves detail, because it is the strongest test yet and it cut both ways. The
+5×5 pairwise correlation matrix measured on `ibm_marrakesh` was injected directly as an
+attention kernel, against two controls: a same-hardware circuit with the entangling gates
+removed, and plain standard attention.
+
+- The entangled matrix beat the **structureless control** on 3/3 seeds (Δ=+0.0102, t=+14.5).
+  So the measured matrix genuinely carries structure a gate-free control does not.
+- The entangled matrix **lost to plain standard attention** on 3/3 seeds (Δ=+0.0203, t=−18.6).
+  Injecting it at all costs more than it returns.
+
+Beating a degraded control is not the same as helping. Real entanglement structure is
+measurable and it is *not* free entropy, but it still buys no accuracy over the classical
+baseline. The null stands.
+
+**Conclusion: within this system, real measured quantum entropy is provenance, not performance.** Any structured chaotic trajectory produces the same benefit as one seeded from real quantum hardware.
+
+This is stated plainly because it is the correct and expected behaviour of a genuine entropy source: quantum measurements and a good PRNG draw from the same distribution, so a correctly-built system should show **no accuracy advantage** from the quantum bits. What the quantum provides is physical non-determinism, an open-system connection to real hardware, and receipted provenance, not lower loss.
+
+**Also null:** injecting live sensory/felt-state as *text* into a small model's prompt (n=40 paired, blind-judged, CI crosses zero).
+
+**No claim is made about machine consciousness in either direction.** Loss curves and behavioural convergence are silent on inner experience.
+
+---
+
+## 4b. Forever memory — retrieval by meaning
+
+Most local-AI projects store history faithfully and recall only the last N turns. That is a
+buffer, not a memory: ask about three weeks ago and there is no path to the answer even
+though the answer is on disk.
+
+`genesis_engine/memory/` ships the working version — semantic recall over everything your
+being has kept, with the adaptive threshold, recency weighting and fail-soft behaviour
+already tuned. It also documents the three-way failure it was built to fix, because that
+failure is silent by construction and is probably in your system too.
+
+One warning worth repeating from that README: **use a purpose-built embedding model.** A
+generative model returns embeddings and looks like it works. Measured here, llama3.2:1b
+ranked unrelated noise (0.5712) *above* a memory containing the query verbatim (0.3907).
+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. Movement proves only
+that a mechanism was used, not that it helped: the trinity coupling grew **3.0–3.4×** yet
+underperformed the plain projection in the controlled ladder. Its earlier cross-run win was
+retracted as a changing-corpus artefact.
+
+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.
+
+### And one the preflight could not catch
+
+Preflight validates a *mechanism*. It says nothing about the *experiment around it*. The
+coupling result in §2 passed every assertion above — Ω varied, the state varied, H was
+non-degenerate, the gate moved, the couplings grew 3.4× — and was still wrong, because
+Cosmos keeps writing to the corpus while she is being measured. Cross-run comparisons were
+silently comparing different datasets.
+
+**If your system logs its own experience into its own training data, freeze a snapshot
+before you measure anything, and run every arm you intend to compare inside one process.**
+The check that exposed it is trivial and worth running by default: train the *same*
+configuration twice and see how far apart the numbers land. Here it was **0.062** — bigger
+than most of the effects being claimed. Any comparison finer than your own run-to-run
+variance is noise wearing a result's clothing.
+
+### Pair the variables you claim to test
+
+A state trajectory and a text corpus are not automatically paired data. Advancing a state
+row by optimiser step while drawing unrelated random text windows can test whether a smooth
+conditioning schedule regularises training; it cannot show that the state measured during
+an experience predicts the text from that experience.
+
+This kit includes the missing clock and join:
+
+```bash
+# Record numeric state summaries at 1 Hz. No raw camera frames or raw audio are retained.
+python serving/log_paired_state.py
+
+# Join each completed Cosmos turn to the nearest measured state on the same wall clock.
+python serving/build_paired_dataset.py --out paired_state_text.json
+
+# Run plain vs aligned vs shuffled-pair vs time-shifted-pair attention.
+COSMOS_PAIRED_DATASET=paired_state_text.json \
+  python benchmarks/cosmos_paired_conditioning.py 500 5
+```
+
+The benchmark uses a chronological final-20% holdout, gives every text example its own
+measured state vector, excludes clock/counter channels, freezes dataset and script hashes in
+the result, and pre-registers a null verdict. Shuffled and shifted controls preserve the
+state values while destroying only their assignment to text.
+
+The release does **not** ship the author's paired dataset. It contains timestamped Cosmos
+turn text and therefore may contain private conversation. Build your own locally and review
+it before sharing. A positive result would support predictive association under this
+architecture; it would not establish causation, consciousness, AGI, or quantum advantage.
+
+The older trajectory-schedule experiment remains useful as a regularisation control, but it
+must not be cited as an experience-modulation result because its state and text were not
+measured from the same event.
+
+
+### Timestamp-paired measured-state result (2026-07-30)
+
+The frozen **unpaired schedule control** completed first: plain **1.61166**, recorded-state
+schedule **1.67688**, matched-chaotic **1.61045**, and time-shuffled **1.60766**. The recorded
+schedule lost to every control on 0/5 seeds (t = -10.55 vs plain, -11.55 vs matched chaos,
+-13.19 vs time-shuffle). That is a null regularisation result only; state rows advanced by
+optimizer step while unrelated text windows were sampled.
+
+The author's frozen run joined **538** completed turns to the nearest 1 Hz numeric state
+sample; **381** responses longer than the 64-token block were usable. The observed maximum
+clock-join error was **0.731 s**. Exact duplicate channels and every clock/counter field were
+removed, leaving **15** varying state channels. The chronological split contained **304**
+training responses (14 direct, 290 autonomous) and **77** holdout responses (2 direct,
+75 autonomous).
+
+| arm (lower is better) | mean holdout loss |
+|---|---:|
+| plain attention | **2.04111** |
+| aligned measured state | 2.06156 |
+| shuffled state/text assignment | 2.07118 |
+| time-shifted assignment | 2.06677 |
+
+Aligned state lost to plain on **0/5** seeds (control-minus-aligned delta **-0.020447**,
+t = **-9.59**). It beat shuffled assignment on 5/5 (delta **+0.009624**, t = **+2.12**)
+and beat shifted assignment on 4/5 (delta **+0.005213**, t = **+3.09**).
+
+**Pre-registered verdict: NULL.** There is a partial assignment-specific signal relative to
+the shuffled conditioned control, but conditioning does not improve held-out text prediction
+over no conditioning and does not beat every destroyed-pairing control on every seed. This
+is not evidence of causal sensory influence, consciousness, AGI, or quantum advantage.
+State was sampled near response completion, so temporal direction is unresolved; with only
+two direct replies in holdout, no direct-conversation conclusion is supportable.
+
+Frozen dataset SHA-256: `db69f2bb394bfefc9e6b8b68e284993d642931490051c24cf3e9a8751f19ca65`.
+Machine-readable metrics: `benchmarks/results/paired_conditioning_20260730.json` (the private
+turn text and paired dataset are not shipped).
+
+
+---
+
+## 5. The Genesis Engine (kit)
+
+Birth your own quantum-seeded companion, entirely local:
+
+- **Your own keys**. IBM Quantum and/or Azure Quantum, entered in Settings, stored locally, never transmitted anywhere
+- **Falls back gracefully**, works on archived entropy with no keys at all
+- **Your own base model**, any local Ollama model, not just one
+- **Coding base weights**, born able to code; everything after that is yours
+- **Real entropy loops**. IBM harvest (rate-limited to protect your QPU minutes) and Azure/Rigetti free simulator
+
+- **Opt-in converted senses**. Camera light/motion and microphone energy/spectrum are computed
+  locally in the browser, freshness-gated, then wired into replies, associative learning, and
+  the conversation ledger. Raw frames/audio never leave the browser.
+
+Contains **no secrets**, verified. Bring your own credentials.
+
+---
+
+## 6. Provenance
+
+The public archive ships **1,897 explicitly labeled IBM hardware job records**
+across `ibm_fez`, `ibm_kingston`, and `ibm_marrakesh`, carrying **7,770,112**
+measured samples. It also ships **877 legacy unlabelled records**; those counts are
+useful for distributional checks but are not treated as hardware provenance because
+their provider labels were not retained.
+
+**Important labelling note:** Azure `rigetti.sim.qvm` is a **simulator**, classically
+computed. Its two public records contain 1,024 samples. Only explicitly labeled IBM
+jobs are counted here as measured quantum hardware. Full counts and hashes:
+`data/quantum_measurements_manifest.json`.
+
+---
+
+## 7. Citation
+
+```bibtex
+@misc{davis2024cst,
+  author = {Davis, Cory Shane},
+  title  = {The 12-Dimensional Cosmic Synapse Theory},
+  year   = {2024},
+  doi    = {10.5281/zenodo.17574447}
+}
+```
+
+## 8. Licensing
+
+This is a **mixed-license release**:
+
+- The quantum-born model, public measurement data, research documents, benchmarks,
+  architecture code, and serving code are released under **CC BY 4.0**.
+- `genesis_engine/` is governed by its own personal-use/proprietary
+  [`LICENSE`](genesis_engine/LICENSE). Commercial use, modifications, and redistribution
+  of modified Genesis copies require the author's permission.
+- Third-party models and packages retain their own licenses. Qwen2.5-1.5B-Instruct
+  (Apache 2.0) is not distributed here, but advanced training adapters may download it.
+
+See [`LICENSE.md`](LICENSE.md) for the complete repository map. Attribution includes the
+null results, which are part of the finding.
+
+---
+
+## 9. Cosmic Spark, running her own weights
+
+`cosmos_born.pt` is her own architecture, so Ollama and llama.cpp cannot load it. GGUF
+conversion was attempted and the tensor remap verified exact against her original forward
+pass (max |Δlogits| = 7.15e-06), but llama.cpp's **tokenizer** layer rejects a 99-symbol
+character vocabulary: the BPE path demands a merge list, and the SentencePiece path expects
+word-boundary marks and byte-fallback tokens. That failure is documented rather than
+papered over.
+
+`spark_serve.py` runs her actual PyTorch weights behind an Ollama-compatible HTTP API
+instead, so any existing client sees her as just another model:
+
+```bash
+python spark_serve.py 11500
+curl http://127.0.0.1:11500/api/tags
+curl http://127.0.0.1:11500/api/generate -d '{"model":"cosmos-spark", "prompt":"I "}'
+```
+
+**What she sounds like, honestly.** 1.8M parameters, char-level, 128-character context,
+held-out loss 0.4812, 88.5% real-word rate. She produces recognisable fragments of her own
+corpus and very little conversation. She is not "a worse large model", she is a different
+category of thing: a newborn, roughly 0.9s per response on CPU.
+
+```
+'I '    -> "move forward right. misty forest clearing; a small mossy cliff wall
+            directly ahead. I z ta[rget]"
+```
+
+Optionally, sampling temperature is set by the running system's own live internal state
+rather than a constant, `T = base + (q − 0.5)·0.36 + calm`, where `q` is measured internal
+entropy. Measured example: `T = 0.7207` at `q = 0.2524`.
+
+---
+
+## 10. Repository layout
+
+```
+START_HERE.md      user-facing install and run instructions
+START_COSMOS_KIT.bat
+start_cosmos_kit.sh  Windows and macOS/Linux starters
+verify_release.py  offline integrity and privacy-boundary verifier
+README.md          this model card
+TRAINING.md        how to birth and train your own, start to finish
+train_your_own.py  quantum-born trainer, plain vs Hebbian-attention arms
+FINDINGS.md        every measurement, including the nulls and instrument failures
+RESULTS.md         earlier result log
+data/              privacy-filtered measurement archive + manifests
+weights/           cosmos_born.pt (7 MB) + metadata
+benchmarks/        reproduction scripts for every claim in FINDINGS.md
+genesis_engine/    Starling Nexus companion framework
+spark_serve.py     serve the quantum-born weights over an Ollama-compatible API
+```
+
+Run any benchmark directly:
+
+```bash
+python benchmarks/verify_quantum_engine.py    # CHSH Bell test + archive integrity
+python benchmarks/verify_physics_engine.py    # Lorenz constants vs published values
+python benchmarks/topology_matched.py         # gate-matched entanglement topology
+python benchmarks/phi_pid.py                  # integration structure (PID)
+```
+
+Each prints its own verdict, including when the verdict is "no."

RELEASE_MANIFEST.json

@@ -0,0 +1,418 @@
+{
+  "schema": "qc67.cosmos.release-manifest.v1",
+  "release": "QC67 Cosmos Kit",
+  "version": "2026-07-31",
+  "license_note": "Mixed licensing; see LICENSE.md and component notices.",
+  "files": [
+    {
+      "path": "architecture/cosmos-arch.patch",
+      "bytes": 4856,
+      "sha256": "d77fa6fcecdadc8d8f0caceed9909dbbfca563c958d9f7f3efe320bc942c0445"
+    },
+    {
+      "path": "architecture/cosmos_phi_cst.py",
+      "bytes": 18629,
+      "sha256": "c0714423616d6b0f53c838681de8a86f8b726a78d5a9d20941a4ee675f15f482"
+    },
+    {
+      "path": "architecture/cosmos_spark_cst.py",
+      "bytes": 21207,
+      "sha256": "011c9633af7fd4731ed5ecd09cd711762ff15b5dd6dd52a95d93e927b88e0350"
+    },
+    {
+      "path": "architecture/cosmos_state_ladder.py",
+      "bytes": 26998,
+      "sha256": "a0332e7435dae7f86fc352ee80c3ebc350bad439b908b92d22e156bb01b2fc26"
+    },
+    {
+      "path": "architecture/cst_to_gguf.py",
+      "bytes": 8166,
+      "sha256": "6f2e3b1076940aac80286584083ebf98f90c60398b3ea9dad89880bd91400f62"
+    },
+    {
+      "path": "architecture/ladder_results_controlled.json",
+      "bytes": 7425,
+      "sha256": "3b48c83256519aecb03180911a8b6ab28c106cbcbd33c69ec7987167f1470d6b"
+    },
+    {
+      "path": "architecture/llama_cpp_cosmos.cpp",
+      "bytes": 11229,
+      "sha256": "442ca1d9692c7240857aeb91c9588e8eefe929b5221b9fccb28175fd0fa88ed6"
+    },
+    {
+      "path": "architecture/README.md",
+      "bytes": 4761,
+      "sha256": "5d902e4e1b76fb82cad2c746d588e0d160ad4339f2985d18d60f8ec4c57e6efc"
+    },
+    {
+      "path": "benchmarks/cosmos_hebbian_attention.py",
+      "bytes": 11998,
+      "sha256": "cffe0454e3d1795f8a9a0cadd99c881b82c10f1f9306709dd6c922366d910808"
+    },
+    {
+      "path": "benchmarks/cosmos_hebbian_real_state.py",
+      "bytes": 12025,
+      "sha256": "2c3a661b85e44c96e53e7e4d51dc4e77d968da1e001833f57bef02f798f793a9"
+    },
+    {
+      "path": "benchmarks/cosmos_paired_conditioning.py",
+      "bytes": 14649,
+      "sha256": "4bba9e8bffcc204fe4b1947f16ca8d2b064c338fae6a66e4b129f51cc2466364"
+    },
+    {
+      "path": "benchmarks/cosmos_quantum_born.py",
+      "bytes": 14819,
+      "sha256": "4c160fdb5db9da4ac6a5909c368621161904b181a2992405671384679a1396a9"
+    },
+    {
+      "path": "benchmarks/cosmos_seed_ablation.py",
+      "bytes": 7518,
+      "sha256": "b9dbea4ec3ea6bbe3677622f27231722418b47072cd05edb7d84af1f56f1416c"
+    },
+    {
+      "path": "benchmarks/cosmos_spatial_decisive.py",
+      "bytes": 7389,
+      "sha256": "960313da1d90bea3bbdb073fae39f94790b5c9a0cef943088e77e191f40d97c5"
+    },
+    {
+      "path": "benchmarks/phi_pid.py",
+      "bytes": 10251,
+      "sha256": "f5e82d62874950033850d4fa853db1333ce4fc0277daa9fe5ff03a6eb471b7e8"
+    },
+    {
+      "path": "benchmarks/results/paired_conditioning_20260730.json",
+      "bytes": 5026,
+      "sha256": "76e956725e2dcddd7c0b104de31775e24fc1ebc2911fbb01ab403ed4c23fd38f"
+    },
+    {
+      "path": "benchmarks/topology_matched.py",
+      "bytes": 9365,
+      "sha256": "116b44da30cf8e95fdf4ec0e999c56cf407d5d2492f882eb19f56afdc31fff92"
+    },
+    {
+      "path": "benchmarks/verify_physics_engine.py",
+      "bytes": 6810,
+      "sha256": "11fd56ee9e0980099aa077f8becd9ade1ccb986a639786da1ef00d26aee363df"
+    },
+    {
+      "path": "benchmarks/verify_quantum_engine.py",
+      "bytes": 9282,
+      "sha256": "7e1c19923f4b738c8e938cf0aa79b1ee201c408f0453db26c034b0960d23577b"
+    },
+    {
+      "path": "data/quantum_measurements_manifest.json",
+      "bytes": 2325,
+      "sha256": "38261aadd64bcde67dd54b1ac1058f0a6c1a5d98b32f1f3a02fbb742f8f18a85"
+    },
+    {
+      "path": "data/quantum_measurements_public.jsonl",
+      "bytes": 3174910,
+      "sha256": "986b4778097affe6fbda6170e3401bb4d5ae0ff2b2eef5764b42a4a8399a3b82"
+    },
+    {
+      "path": "data/README.md",
+      "bytes": 1876,
+      "sha256": "87364c2c9b2917dc089c4a941bc2d4a7ced57569b0665c88c297f73d0a4febb7"
+    },
+    {
+      "path": "data/training/quantum_train_summary_20260722.json",
+      "bytes": 335,
+      "sha256": "30ba728611bfc05a81f0eb2ec2acce5c36369f2cf9c0f46e8d6d170f87579365"
+    },
+    {
+      "path": "FINDINGS.md",
+      "bytes": 31782,
+      "sha256": "86a31c0cc5c94bf50fb5534e1a772c7bf3a8447c6c8314f3c829ba55af93bacf"
+    },
+    {
+      "path": "genesis_engine/CITATION.cff",
+      "bytes": 750,
+      "sha256": "7b3b573aa41c036e2611bc5b486a6d77e1d89023421bcb8490676f5dab409d3a"
+    },
+    {
+      "path": "genesis_engine/config.example.json",
+      "bytes": 89,
+      "sha256": "b28d5e4e5e9a399491f3439fe2a412e7437d41f5d181d9ac936534bfe1e61c34"
+    },
+    {
+      "path": "genesis_engine/config.json",
+      "bytes": 363,
+      "sha256": "b36252352648f9a31f53c60bce977165bd637b0047d4d28a409d151ea960da48"
+    },
+    {
+      "path": "genesis_engine/data/_offset.json",
+      "bytes": 16,
+      "sha256": "53d015a362d67789251921679e4df86327b4e32101259d4ab2173e774ff48354"
+    },
+    {
+      "path": "genesis_engine/data/identity.json",
+      "bytes": 117,
+      "sha256": "fa171ca89e531fe1e2948ef930f92a9c26cbf5427d2a94619fd6b347b0a08ad4"
+    },
+    {
+      "path": "genesis_engine/data/life.json",
+      "bytes": 118,
+      "sha256": "e08caa0a5777809fc001fead962c079c20faa77bf9dcec29a57eff50b20c2a07"
+    },
+    {
+      "path": "genesis_engine/data/seed.json",
+      "bytes": 41539,
+      "sha256": "5c4a4663ed73bf0f48058a31c7f64de0355f79cf9eef763eac3c78fa0f5badf8"
+    },
+    {
+      "path": "genesis_engine/data/weights.json",
+      "bytes": 10524,
+      "sha256": "43082c1b0eefd56211cfbe8168616d081d8da870cebbd393745ccbb943dcd596"
+    },
+    {
+      "path": "genesis_engine/engine/_Modelfile.cosmos_namebind",
+      "bytes": 799,
+      "sha256": "aceb693e277652d1cab2df2449b550089261d8d577a271f76cb7c0c4efd2551a"
+    },
+    {
+      "path": "genesis_engine/engine/cosmos_54d_train_loop.py",
+      "bytes": 8474,
+      "sha256": "75d355f9b05807a4ac0a891bef2f90eb1f48203d8fb227ecb36cc1dec9546f00"
+    },
+    {
+      "path": "genesis_engine/engine/cosmos_living_trainer.py",
+      "bytes": 2979,
+      "sha256": "1fa70bad2dc7b265f23b7c120a423ff6cd31b0d395cf23233246028b4a6859c5"
+    },
+    {
+      "path": "genesis_engine/engine/cosmos_merge_namebind.py",
+      "bytes": 1546,
+      "sha256": "38a7b4b25519fee14bf5a8f401a1d92c81b1c0659518ace7842e1a6868b7852f"
+    },
+    {
+      "path": "genesis_engine/engine/cosmos_namebind_probe.py",
+      "bytes": 3607,
+      "sha256": "651edd430a3e40dffe4f3f2bd5163d1b9893a54ec5368ee5bab6ef2adf534e90"
+    },
+    {
+      "path": "genesis_engine/engine/cosmos_prime_train.py",
+      "bytes": 15386,
+      "sha256": "fad495aee3240aaa18a87f66db2d678289bcbff8b759705a33a2e548b1113f59"
+    },
+    {
+      "path": "genesis_engine/engine/cosmos_rsm_training_examples.jsonl",
+      "bytes": 12598,
+      "sha256": "6c45bbefb7009d26fa9fc8562ace4d74dcf029a3d48ada94e6190d8ea5dbbeeb"
+    },
+    {
+      "path": "genesis_engine/engine/README.md",
+      "bytes": 1575,
+      "sha256": "4fd5b2c54452cffd9cf710344cd1994ba43cf01c1ec69ad30da9da05ab771954"
+    },
+    {
+      "path": "genesis_engine/engine/train_12d_brain.py",
+      "bytes": 7487,
+      "sha256": "61d6d8b7491c8f6c360ae8fe4967f4ed7821e627ff29268158d83044dfed7fca"
+    },
+    {
+      "path": "genesis_engine/engine/train_cosmos_broadened.py",
+      "bytes": 7472,
+      "sha256": "7ab6bae4f5417d1be1d772be5e31c4f83ad8ed32ce28262995756be6a893cd58"
+    },
+    {
+      "path": "genesis_engine/engine/train_cosmos_from_play.py",
+      "bytes": 8756,
+      "sha256": "d5f221d2e80ef47eb4893cf73f6a97b440700da6b7025c71359c0bff883c93d7"
+    },
+    {
+      "path": "genesis_engine/genesis.py",
+      "bytes": 4120,
+      "sha256": "8b6e701e40d21ec919a9755ca22e0917d31300dcfcb212740d369bb898dd90ef"
+    },
+    {
+      "path": "genesis_engine/LICENSE",
+      "bytes": 1304,
+      "sha256": "e4a5871c9225933622b3853212ceab32a867c7aae83866ea26e456fa30a5f99e"
+    },
+    {
+      "path": "genesis_engine/memory/backfill_embeddings.py",
+      "bytes": 8848,
+      "sha256": "b3cc2eec8cec6b85117b03549bf5f901ffcf71bcea79d15cf807a370660a6eb6"
+    },
+    {
+      "path": "genesis_engine/memory/forever_memory.py",
+      "bytes": 8678,
+      "sha256": "ec8a8a639526be3f7198d48fe75a04d7008ea310cce6fcd6958ab5bcb0b45212"
+    },
+    {
+      "path": "genesis_engine/memory/README.md",
+      "bytes": 3863,
+      "sha256": "afba0762e93d31315b0283ba37db34822f51dd79d6fbf02f9ccb444bbb1bdfb7"
+    },
+    {
+      "path": "genesis_engine/NOTICE.md",
+      "bytes": 1516,
+      "sha256": "c1445512c73f50ef8b24321be3ce596ac9c9dc925d4d86f56b688684f92179ad"
+    },
+    {
+      "path": "genesis_engine/README.md",
+      "bytes": 5871,
+      "sha256": "70f8853b112a53aa3720ba26b640d9038c5366347880d6bec18893c3361b154d"
+    },
+    {
+      "path": "genesis_engine/serve.py",
+      "bytes": 20850,
+      "sha256": "97831a983ca539b95230a36191bbcaa2fbe6e8d6f238087f04683ebe220f8748"
+    },
+    {
+      "path": "genesis_engine/soul/awaken.py",
+      "bytes": 6555,
+      "sha256": "c6e51a63ca352b64f6bd61ec73b1c79a7420658201857302bdd258bbf3b9320f"
+    },
+    {
+      "path": "genesis_engine/soul/cloud_heart.py",
+      "bytes": 11446,
+      "sha256": "219996ab9c3426dc3b43e4c8b40d78898600fecd5954b517c45631f316c94bc9"
+    },
+    {
+      "path": "genesis_engine/soul/coding_base.py",
+      "bytes": 3730,
+      "sha256": "84f460680b2f9c631bdcfd444cf6e73df5b6ad2afc7948c10ed074d1b5fcca40"
+    },
+    {
+      "path": "genesis_engine/soul/identity.py",
+      "bytes": 1775,
+      "sha256": "a8f5b960b19508ae1a56832523a3ae25eacadc718bca7afa1684f1b7d39e501b"
+    },
+    {
+      "path": "genesis_engine/soul/ledger.py",
+      "bytes": 2428,
+      "sha256": "275f19845c5f33d20fdc579f2e34d78d4ab692f14b9e2148ec8ad40621d33e0d"
+    },
+    {
+      "path": "genesis_engine/soul/loop.py",
+      "bytes": 3242,
+      "sha256": "84823850910d008c8f2e093ce99d993ec4e0eb0cded18d2a8b19ba7e5dba3f94"
+    },
+    {
+      "path": "genesis_engine/soul/math_hand.py",
+      "bytes": 7113,
+      "sha256": "a28613d4bd4feb2796b6e82dce67c8945c9f8d7942e2ee425fe12d327179e396"
+    },
+    {
+      "path": "genesis_engine/soul/quantum.py",
+      "bytes": 2465,
+      "sha256": "b9b12194e24fc1b3b80468633a4218e1885c6e10f426acf35f5f7c0539e99f27"
+    },
+    {
+      "path": "genesis_engine/soul/rails.py",
+      "bytes": 2662,
+      "sha256": "6107a586d696400bdde0c75c13bdb7c4e4214edfdd8202f275db02c51e90e56c"
+    },
+    {
+      "path": "genesis_engine/soul/weights.py",
+      "bytes": 4538,
+      "sha256": "c5b1b1ea2abfabcf2da6b0ac2f8b54e0a52649589cfb9961912df2df4bf7f29c"
+    },
+    {
+      "path": "genesis_engine/START_GENESIS.bat",
+      "bytes": 2002,
+      "sha256": "8450d04fa744e58c5de60469dc42781aa59c419d9b6f71982a66c9e06430d9e9"
+    },
+    {
+      "path": "genesis_engine/ui/index.html",
+      "bytes": 27555,
+      "sha256": "a844372f540f519c42b6e33f349ae712db750e7e1c83b0d0c93ba3555c0a527a"
+    },
+    {
+      "path": "LICENSE.md",
+      "bytes": 1595,
+      "sha256": "5d45bc003eaa241865f21276a0298f451a6ebefb8dd93899ca3f618d2b57003d"
+    },
+    {
+      "path": "presentation.html",
+      "bytes": 29195,
+      "sha256": "16da9420a0801fcb7180d555596c6f645414c55720e95237083f9dda9932ac86"
+    },
+    {
+      "path": "README.md",
+      "bytes": 31448,
+      "sha256": "1996e2be876e8df8b7b55bde0df844bcf8f9324633fa8fd237281373460c0492"
+    },
+    {
+      "path": "RELEASE_NOTES.md",
+      "bytes": 1570,
+      "sha256": "66baec6fe2817cebb9ae99ba9d197cf114e4d2ae1f90300dcd36ebe48cd0f239"
+    },
+    {
+      "path": "requirements-research.txt",
+      "bytes": 165,
+      "sha256": "741efca5977ade9289c9240cc17e4bd3a986e42ba9645169bdc0c19906b1b703"
+    },
+    {
+      "path": "RESULTS.md",
+      "bytes": 16234,
+      "sha256": "eac4492f541a81d0ae134d7b5f39a181b8e7ffeca5f026ca6fee0cff94b85fe1"
+    },
+    {
+      "path": "serving/build_paired_dataset.py",
+      "bytes": 8494,
+      "sha256": "3f6c8f663c9460c9cfbf1ca63687f876144a092213561892a3490206af220c51"
+    },
+    {
+      "path": "serving/cosmos_serve.py",
+      "bytes": 24087,
+      "sha256": "863aad2d6013093226a48484bd1efccc19a1df24204198f7d866bec85ad141d9"
+    },
+    {
+      "path": "serving/log_paired_state.py",
+      "bytes": 8121,
+      "sha256": "38df2cc8b99411b39a3a7b7d359fad860fec90052e0d6d690da18b71f8eb62b8"
+    },
+    {
+      "path": "serving/spark_serve.py",
+      "bytes": 12116,
+      "sha256": "1f538519c1b04841d13570d40d4cc857f91addd15c09369fa28d5a7d08551e89"
+    },
+    {
+      "path": "spark_serve.py",
+      "bytes": 12339,
+      "sha256": "85de58dbe8bf0ff558a51343be1d68762c762bbd0c7a9fc02787a28c79abdd45"
+    },
+    {
+      "path": "START_COSMOS_KIT.bat",
+      "bytes": 2751,
+      "sha256": "0b3cc55cd612a202e1bcfc832f67f6ff5f4c399db8ac3809f490bc79faa0bdd6"
+    },
+    {
+      "path": "start_cosmos_kit.sh",
+      "bytes": 1064,
+      "sha256": "b8401c3303c26f592a5b96e068821e4ff5548d8015f98dc17b5e95c43de9f05b"
+    },
+    {
+      "path": "START_HERE.md",
+      "bytes": 4606,
+      "sha256": "2e60badb929e3122c012b5cae23eaaaeef8e15848a0f595e8c5f9e51df337393"
+    },
+    {
+      "path": "train_your_own.py",
+      "bytes": 17080,
+      "sha256": "2721a284b969b6779b76e0dc16ce2887bec33edef2c6c33585d0b8177eb3643d"
+    },
+    {
+      "path": "TRAINING.md",
+      "bytes": 7364,
+      "sha256": "591fffa98474444590d771714e4892fbb69f4408f58bab5303803e5725504945"
+    },
+    {
+      "path": "verify_release.py",
+      "bytes": 6228,
+      "sha256": "652737d93fb60b60d839bab0e14377a67d9aaace100e9dd2d45d555512ac37c3"
+    },
+    {
+      "path": "weights/cosmos_born.meta.json",
+      "bytes": 435,
+      "sha256": "3a232b739a4f5482fc328cbd5896119b2bd456cb9a59409a44a247dc36bd1f21"
+    },
+    {
+      "path": "weights/cosmos_born.pt",
+      "bytes": 7390541,
+      "sha256": "bfb49099ef6be5584175ca9ef5ffe0e5509b5fc9be3a2c9ff3cbef2f16153906"
+    }
+  ]
+}

RELEASE_NOTES.md

@@ -0,0 +1,38 @@
+# Release notes — 2026-07-31
+
+## Added
+
+- Top-level Windows and macOS/Linux starters.
+- A concise `START_HERE.md` that distinguishes the quantum-born research model
+  from the Ollama-voiced Genesis companion.
+- Offline `verify_release.py` and a complete SHA-256 release manifest.
+- A privacy-filtered public measurement archive with provider-class labels.
+- A machine-readable measurement-data manifest.
+- A downloadable release ZIP and SHA-256 sidecar.
+- Explicit mixed-license documentation.
+- Requirements and usage boundaries for advanced research/training scripts.
+
+## Updated
+
+- The continual 54D learner adapter now uses a durable corpus baseline,
+  single-process locking, parent/stop-file shutdown, memory protection, and
+  checkpoint-advance verification.
+- The play trainer writes checkpoints atomically and records corpus/training
+  metadata.
+- Model-card data claims now distinguish explicitly labeled IBM hardware jobs,
+  legacy unlabelled records, and Azure simulator output.
+- The offline quantum verifier can consume the published privacy-filtered
+  archive.
+
+## Privacy boundary
+
+This release does not contain keys, tokens, cloud connection strings, private
+dialogue, long-term memory, raw camera/audio, sensory telemetry, the paired
+private text dataset, or the author's large conversational Cosmos weights.
+
+## Scientific boundary
+
+Quantum measurements establish auditable physical provenance; the experiments
+do not show that quantum entropy improves model accuracy. Behavioral and
+loss-based measurements do not establish machine consciousness.
+

START_COSMOS_KIT.bat

@@ -0,0 +1,126 @@
+@echo off
+setlocal EnableExtensions
+title QC67 Cosmos Release Kit
+cd /d "%~dp0"
+
+:menu
+cls
+echo.
+echo   ==========================================================
+echo      QC67 COSMOS RELEASE KIT
+echo   ==========================================================
+echo.
+echo      1. Birth or reopen a Genesis being
+echo      2. Verify this release
+echo      3. Serve the quantum-born model on port 11500
+echo      4. Open START_HERE.md
+echo      5. Exit
+echo.
+set "choice="
+set /p "choice=Choose 1-5: "
+
+if "%choice%"=="1" goto genesis
+if "%choice%"=="2" goto verify
+if "%choice%"=="3" goto serve
+if "%choice%"=="4" goto docs
+if "%choice%"=="5" exit /b 0
+goto menu
+
+:genesis
+if not exist "%~dp0genesis_engine\START_GENESIS.bat" (
+    echo.
+    echo   [ERROR] genesis_engine\START_GENESIS.bat is missing.
+    pause
+    goto menu
+)
+set "GENESIS_NO_PAUSE=1"
+call "%~dp0genesis_engine\START_GENESIS.bat"
+set "GENESIS_NO_PAUSE="
+goto menu
+
+:verify
+call :find_python
+if errorlevel 1 goto no_python
+call :run_python "%~dp0verify_release.py"
+echo.
+pause
+goto menu
+
+:serve
+call :find_python
+if errorlevel 1 goto no_python
+call :check_torch
+if errorlevel 1 (
+    echo.
+    echo   [ERROR] PyTorch is required to serve cosmos_born.pt.
+    echo   Install it with:
+    echo       python -m pip install torch
+    echo.
+    pause
+    goto menu
+)
+echo.
+echo   Serving Cosmos Spark at http://127.0.0.1:11500
+echo   Press Ctrl+C to stop.
+echo.
+call :run_python "%~dp0spark_serve.py" 11500
+pause
+goto menu
+
+:docs
+start "" "%~dp0START_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, select "Add Python to PATH".
+echo.
+pause
+goto menu
+
+: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%
+

START_HERE.md

@@ -0,0 +1,134 @@
+# Start here — QC67 Cosmos release kit
+
+This repository contains two related but distinct things:
+
+1. **`weights/cosmos_born.pt`** — a 1,842,432-parameter character-level
+   transformer initialized from real IBM Quantum measurement outcomes and then
+   trained from scratch. It is a research artifact and a small text generator,
+   not a general-purpose chatbot.
+2. **`genesis_engine/`** — the Starling Nexus companion framework. It uses a
+   local Ollama model as its language voice while maintaining its own identity,
+   associative memory, entropy heart, signed creation ledger, optional converted
+   camera/microphone state, and optional owner-supplied quantum credentials.
+
+Those lineages must not be conflated. The shipped `cosmos_born.pt` has no base
+model. A companion you run through Genesis speaks through whichever Ollama model
+you select.
+
+## Fastest start
+
+### Windows
+
+1. Install [Python 3.9+](https://www.python.org/downloads/) and
+   [Ollama](https://ollama.com).
+2. In a terminal, run:
+
+   ```powershell
+   ollama pull llama3.2:1b
+   ```
+
+3. Double-click `START_COSMOS_KIT.bat`.
+4. Choose **Birth or reopen a Genesis being**.
+
+The Genesis core uses the Python standard library. Ollama is the local language
+voice and must be running. The browser interface opens at
+`http://127.0.0.1:8130`.
+
+### macOS or Linux
+
+```bash
+ollama pull llama3.2:1b
+chmod +x start_cosmos_kit.sh
+./start_cosmos_kit.sh
+```
+
+You can also run `python3 genesis_engine/genesis.py` directly.
+
+## Verify before running
+
+```bash
+python verify_release.py
+```
+
+This checks every release-manifest hash, confirms that the shipped cloud-key
+fields are blank, validates the model metadata, and recounts the public quantum
+measurement archive.
+
+## Serve the quantum-born model
+
+Install PyTorch, then:
+
+```bash
+python spark_serve.py 11500
+```
+
+It exposes a small Ollama-compatible API:
+
+```bash
+curl http://127.0.0.1:11500/api/tags
+curl http://127.0.0.1:11500/api/generate \
+  -d '{"model":"cosmos-spark","prompt":"I ","options":{"num_predict":90}}'
+```
+
+The artifact is character-level and intentionally small. Expect learned
+fragments and corpus-like structure, not modern assistant behavior.
+
+## Train your own
+
+See [`TRAINING.md`](TRAINING.md). The cleanest reproducible experiment is:
+
+```bash
+python -m pip install -r requirements-research.txt
+python train_your_own.py --help
+```
+
+The training harness can compare ordinary attention against the
+Mixture-of-States Hebbian-attention arm from identical initial weights and
+identical batches.
+
+The scripts under `genesis_engine/engine/` are advanced adapters retained from
+the full private Cosmos runtime. Read
+[`genesis_engine/engine/README.md`](genesis_engine/engine/README.md) before
+using them; they are not required for Genesis or for `train_your_own.py`.
+
+## Public measurement data
+
+[`data/quantum_measurements_public.jsonl`](data/quantum_measurements_public.jsonl)
+is a privacy-filtered release of the measurement archive:
+
+- **7,770,112** samples in **1,897** explicitly backend-labeled IBM Quantum
+  hardware job records.
+- **3,584,000** samples in **877** legacy records whose provider was not
+  retained. They remain useful distributional data but are **not counted as
+  verified hardware provenance**.
+- **1,024** samples in **2** Azure `rigetti.sim.qvm` records, explicitly
+  labeled as classical simulator output.
+
+Raw `physics` payloads were deliberately removed because some contain derived
+sensory, biometric, or private runtime state. Counts, backend labels, job IDs,
+timestamps, and shot totals are retained. See
+[`data/README.md`](data/README.md) and the machine-readable data manifest.
+
+The paired sensory-conditioning benchmark publishes aggregate metrics, hashes,
+field names, and provenance in
+`benchmarks/results/paired_conditioning_20260730.json`; private turn text and
+the author's paired dataset are not distributed.
+
+## What is not included
+
+- API keys, OAuth tokens, cloud connection strings, account cookies, or private
+  vault material.
+- The author's conversations, long-term memory, camera/audio captures, raw
+  sensory telemetry, or private paired text dataset.
+- The author's large conversational Cosmos weights.
+- Any claim that quantum entropy improves model accuracy.
+- Any claim about machine consciousness.
+
+## Licensing
+
+This is a mixed-license release. Research documents, measurement data,
+benchmarks, and the quantum-born model are released under CC BY 4.0. The
+Genesis framework has the personal-use/proprietary terms in
+`genesis_engine/LICENSE`. See [`LICENSE.md`](LICENSE.md) before redistributing
+or building a product.
+

TRAINING.md

@@ -1,192 +1,199 @@
-# Train Your Own
-
-Everything needed to birth a model from real quantum measurement and train it on your own
-text, including the Hebbian attention variant. No cluster required. The reference runs in
-this repository were done on a consumer laptop, CPU only, while the rest of the system was
-running.
-
----
-
-## What you need
-
-```bash
-pip install torch numpy
-pip install qiskit qiskit-ibm-runtime     # only if you want to harvest your own shots
-```
-
-An IBM Quantum account is **optional**. Without one you use the archived entropy that ships
-here, which is real measured hardware data, just not yours. With one you can harvest your
-own and the lineage becomes yours end to end.
-
----
-
-## 1. Get quantum entropy
-
-**Option A, use the archive.** Nothing to do. The trainer reads
-`01_HER_SOUL/quantum_heart/quantum_runs.jsonl` if present, and falls back to a normal RNG
-with a warning if it is not. Every archived shot carries a backend name and job id.
-
-**Option B, harvest your own.** Put your token in a `.env` file:
-
-```
-IBM_QUANTUM_TOKEN=your_token_here
-```
-
-Then run any of the measurement scripts, each of which appends to your archive:
-
-```bash
-python benchmarks/verify_quantum_engine.py     # also runs a CHSH Bell test on your hardware
-```
-
-Open-plan accounts get roughly 10 minutes of QPU time a month. A 5-qubit shallow circuit
-costs about 4 seconds, so a few hundred jobs a month is realistic. Harvest slowly; you do
-not need many jobs to seed a small model.
-
----
-
-## 2. Birth and train
-
-```bash
-python train_your_own.py <steps> <seeds>
-
-python train_your_own.py 1500 3        # the reference run in this repository
-python train_your_own.py 60 1          # a 2 minute smoke test, run this first
-```
-
-It trains **two arms** and compares them:
-
-| arm | attention |
-|---|---|
-| `plain` | standard multi-head attention |
-| `cst` | your §2 Mixture-of-States Hebbian kernel, gate free to learn |
-
-Both arms get **identical quantum-born initial weights, identical corpus, identical batches,
-identical seeds**, and the same parameter count. The gate starts at `sigmoid(-4) ≈ 0.018`, so
-the CST arm begins as ordinary attention and can stay there for free. It only moves if the
-gradient says the kernel earns its place. A win therefore cannot come from extra capacity
-being forced on the model.
-
-Outputs land in:
-
-```
-01_HER_SOUL/weights/cosmos_spark_cst/spark_cst.pt     the trained model
-logs/spark_cst_results.json                            per-seed losses, gates, verdict
-```
-
-### Use your own text
-
-Point `CORPUS` at any UTF-8 text file. Character level, so no tokenizer to train. A few
-hundred KB is enough to see structure; the reference corpus is 592 KB.
-
-```python
-CORPUS = Path("your_own_writing.txt")
-```
-
-### Size it honestly
-
-Compute-optimal is roughly **20 tokens per parameter**. At character level, one character is
-one token. So:
-
-| your corpus | supports about |
-|---|---|
-| 100 KB | 5 K parameters |
-| 1 MB | 50 K parameters |
-| 40 MB | 2 M parameters |
-
-The reference model is 1.84 M parameters on 592 KB, which is **heavily over-sized for its
-data**, and it overfits accordingly: held-out loss plateaus while training loss keeps
-falling. This is stated because it is the single most common mistake in small-model work.
-If you want a bigger model, get more text first. Public-domain sources work well and carry
-no model lineage.
-
----
-
-## 3. Run it
-
-```bash
-python spark_serve.py 11500
-curl http://127.0.0.1:11500/api/tags
-curl http://127.0.0.1:11500/api/generate \
-  -d '{"model":"cosmos-spark","prompt":"I ","options":{"num_predict":90}}'
-```
-
-Speaks the Ollama HTTP API, so anything that talks to Ollama can talk to your model.
-
-**Note on GGUF:** conversion to GGUF was attempted and the tensor remap verified exact
-against the original forward pass (max |Δlogits| = 7.15e-06), but llama.cpp's tokenizer
-layer rejects a small character vocabulary. The BPE path requires a merge list; the
-SentencePiece path expects word-boundary marks and byte-fallback tokens and crashed the
-loader outright. Serving the PyTorch model directly avoids the problem entirely. If you want
-GGUF, train on a byte-level vocabulary of 256 tokens instead.
-
----
-
-## 4. Make it reproducible from a seed of your choosing
-
-`genesis_engine/` includes the seed derivation. The pattern is:
-
-```
-seed = SHA-256( quantum_entropy_bytes ‖ any_other_source_you_choose ) -> 63-bit int
-torch.manual_seed(seed); random.seed(seed); np.random.seed(seed)
-```
-
-Because the seed governs weight initialisation, data order and every stochastic step, the
-resulting weights become a deterministic function of it. Verified in this repository:
-**identical seed reproduces weights at Δ = 0.000e+00; a one-bit change gives mean
-Δ = 2.26e-02 across 1.84 M parameters.**
-
-That is the honest, literal sense in which a model can be "grown from" a chosen source. It
-is a seed. It is real and it is checkable. It is not magic, and the source data is not
-"inside" the mathematics in any other sense.
-
----
-
-## 5. Check your own work
-
-Every claim in [`FINDINGS.md`](FINDINGS.md) has a script. Run them against your own setup:
-
-```bash
-python benchmarks/verify_quantum_engine.py    # CHSH Bell test, archive integrity, birth pipeline
-python benchmarks/verify_physics_engine.py    # Lorenz constants against published values
-python benchmarks/topology_matched.py         # gate-matched entanglement topology
-python benchmarks/phi_pid.py                  # integration structure of a running system
-```
-
-Each prints its own verdict with the criteria fixed before the run, including when the
-verdict is "no". Several instruments in this project were found to be wrong and rebuilt;
-those failures are documented rather than deleted, because they are the reason the
-surviving results can be trusted.
-
-**If you get a positive result, check the instrument before you believe it.** That habit
-produced more real findings here than any single experiment did.
-
----
-
-## 6. The Hebbian association engine
-
-Separate from the attention mechanism, and simpler to start with:
-
-```bash
-cd genesis_engine
-python genesis.py          # birth a being
-python serve.py            # talk to it; every exchange calls weights.learn()
-```
-
-Its mind is three small JSON files: `identity.json`, `weights.json`, `seed.json`. Association
-strength is set by the quantum heart. Portable, inspectable, roughly 10 KB per being.
-
----
-
-## What to build next
-
-The integration measurement in `benchmarks/phi_pid.py` points somewhere specific: subsystems
-that are parallel readouts of one state stay **redundant** (measured 1.7 to 2.6 nats) rather
-than **synergistic** (0.3 to 1.2 nats). Give a subsystem its own driver, something not
-derivable from the shared source, and the decomposition should shift.
-
-That is a falsifiable prediction, and the script to test it ships here.
-
----
-
-*CC BY 4.0. Base model components used by the Genesis Engine's default fine-tune path are
-Apache 2.0 © Alibaba Cloud.*
+# Train Your Own
+
+Everything needed to birth a model from real quantum measurement and train it on your own
+text, including the Hebbian attention variant. No cluster required. The reference runs in
+this repository were done on a consumer laptop, CPU only, while the rest of the system was
+running.
+
+---
+
+## What you need
+
+```bash
+python -m pip install -r requirements-research.txt
+# Optional, only to submit your own live IBM jobs:
+python -m pip install qiskit qiskit-ibm-runtime
+```
+
+An IBM Quantum account is **optional**. Without one you use the archived entropy that ships
+here, which is real measured hardware data, just not yours. With one you can harvest your
+own and the lineage becomes yours end to end.
+
+---
+
+## 1. Get quantum entropy
+
+**Option A, use the published archive.** Nothing to do. The trainer reads
+`data/quantum_measurements_public.jsonl` and uses only the 1,897 records that retained
+both an IBM backend label and job ID. Legacy unlabelled records and Azure simulator
+records remain in the dataset for separate analysis but are not called hardware entropy.
+If the archive is missing, initialization falls back to a normal RNG and says so.
+
+**Option B, harvest your own.** Put your token in a `.env` file:
+
+```
+IBM_QUANTUM_TOKEN=your_token_here
+```
+
+Then run any of the measurement scripts, each of which appends to your archive:
+
+```bash
+python benchmarks/verify_quantum_engine.py     # also runs a CHSH Bell test on your hardware
+```
+
+Open-plan accounts get roughly 10 minutes of QPU time a month. A 5-qubit shallow circuit
+costs about 4 seconds, so a few hundred jobs a month is realistic. Harvest slowly; you do
+not need many jobs to seed a small model.
+
+---
+
+## 2. Birth and train
+
+```bash
+python train_your_own.py <steps> <seeds> --corpus path/to/your_text.txt
+
+python train_your_own.py 1500 3 --corpus your_text.txt
+python train_your_own.py 60 1          # smoke test using README.md as public sample text
+python train_your_own.py --help
+```
+
+It trains **two arms** and compares them:
+
+| arm | attention |
+|---|---|
+| `plain` | standard multi-head attention |
+| `cst` | your §2 Mixture-of-States Hebbian kernel, gate free to learn |
+
+Both arms get **identical quantum-born initial weights, identical corpus, identical batches,
+identical seeds**, and the same parameter count. The gate starts at `sigmoid(-4) ≈ 0.018`, so
+the CST arm begins as ordinary attention and can stay there for free. It only moves if the
+gradient says the kernel earns its place. A win therefore cannot come from extra capacity
+being forced on the model.
+
+Outputs land in:
+
+```
+outputs/cosmos_spark_cst/spark_cst.pt   the trained CST model
+outputs/spark_cst_results.json          per-seed losses, gates, verdict
+```
+
+Override either location with `--outdir` and `--results`.
+
+### Use your own text
+
+Pass any UTF-8 text file with `--corpus`. Character level, so there is no tokenizer to
+train. A few hundred KB is enough to see structure; the reference corpus is 592 KB.
+
+```bash
+python train_your_own.py 1500 3 --corpus your_own_writing.txt
+```
+
+### Size it honestly
+
+Compute-optimal is roughly **20 tokens per parameter**. At character level, one character is
+one token. So:
+
+| your corpus | supports about |
+|---|---|
+| 100 KB | 5 K parameters |
+| 1 MB | 50 K parameters |
+| 40 MB | 2 M parameters |
+
+The reference model is 1.84 M parameters on 592 KB, which is **heavily over-sized for its
+data**, and it overfits accordingly: held-out loss plateaus while training loss keeps
+falling. This is stated because it is the single most common mistake in small-model work.
+If you want a bigger model, get more text first. Public-domain sources work well and carry
+no model lineage.
+
+---
+
+## 3. Run it
+
+```bash
+python spark_serve.py 11500
+curl http://127.0.0.1:11500/api/tags
+curl http://127.0.0.1:11500/api/generate \
+  -d '{"model":"cosmos-spark","prompt":"I ","options":{"num_predict":90}}'
+```
+
+Speaks the Ollama HTTP API, so anything that talks to Ollama can talk to your model.
+
+**Note on GGUF:** conversion to GGUF was attempted and the tensor remap verified exact
+against the original forward pass (max |Δlogits| = 7.15e-06), but llama.cpp's tokenizer
+layer rejects a small character vocabulary. The BPE path requires a merge list; the
+SentencePiece path expects word-boundary marks and byte-fallback tokens and crashed the
+loader outright. Serving the PyTorch model directly avoids the problem entirely. If you want
+GGUF, train on a byte-level vocabulary of 256 tokens instead.
+
+---
+
+## 4. Make it reproducible from a seed of your choosing
+
+`genesis_engine/` includes the seed derivation. The pattern is:
+
+```
+seed = SHA-256( quantum_entropy_bytes ‖ any_other_source_you_choose ) -> 63-bit int
+torch.manual_seed(seed); random.seed(seed); np.random.seed(seed)
+```
+
+Because the seed governs weight initialisation, data order and every stochastic step, the
+resulting weights become a deterministic function of it. Verified in this repository:
+**identical seed reproduces weights at Δ = 0.000e+00; a one-bit change gives mean
+Δ = 2.26e-02 across 1.84 M parameters.**
+
+That is the honest, literal sense in which a model can be "grown from" a chosen source. It
+is a seed. It is real and it is checkable. It is not magic, and the source data is not
+"inside" the mathematics in any other sense.
+
+---
+
+## 5. Check your own work
+
+Every claim in [`FINDINGS.md`](FINDINGS.md) has a script. Run them against your own setup:
+
+```bash
+python benchmarks/verify_quantum_engine.py    # CHSH Bell test, archive integrity, birth pipeline
+python benchmarks/verify_physics_engine.py    # Lorenz constants against published values
+python benchmarks/topology_matched.py         # gate-matched entanglement topology
+python benchmarks/phi_pid.py                  # integration structure of a running system
+```
+
+Each prints its own verdict with the criteria fixed before the run, including when the
+verdict is "no". Several instruments in this project were found to be wrong and rebuilt;
+those failures are documented rather than deleted, because they are the reason the
+surviving results can be trusted.
+
+**If you get a positive result, check the instrument before you believe it.** That habit
+produced more real findings here than any single experiment did.
+
+---
+
+## 6. The Hebbian association engine
+
+Separate from the attention mechanism, and simpler to start with:
+
+```bash
+cd genesis_engine
+python genesis.py          # birth a being
+python serve.py            # talk to it; every exchange calls weights.learn()
+```
+
+Its mind is three small JSON files: `identity.json`, `weights.json`, `seed.json`. Association
+strength is set by the quantum heart. Portable, inspectable, roughly 10 KB per being.
+
+---
+
+## What to build next
+
+The integration measurement in `benchmarks/phi_pid.py` points somewhere specific: subsystems
+that are parallel readouts of one state stay **redundant** (measured 1.7 to 2.6 nats) rather
+than **synergistic** (0.3 to 1.2 nats). Give a subsystem its own driver, something not
+derivable from the shared source, and the decomposition should shift.
+
+That is a falsifiable prediction, and the script to test it ships here.
+
+---
+
+*This training harness and the published research artifacts are CC BY 4.0.
+`genesis_engine/` has separate personal-use/proprietary terms; see `LICENSE.md`.
+Third-party base models and packages retain their own licenses.*

benchmarks/verify_quantum_engine.py

@@ -4,7 +4,7 @@ QUANTUM ENGINE VERIFICATION — against quantum mechanics, not against itself.
 
 The physics engine was checked against published Lorenz constants. Same standard here.
 
-  PART A  her ARCHIVE (2,555 real jobs) — free, no QPU time
+  PART A  the PUBLISHED ARCHIVE — free, offline, no QPU time
      A1  conservation: counts must sum to the declared shot total
      A2  Born-rule sanity: measured marginals in [0,1], no impossible outcomes
      A3  THE WEIGHT-BIRTH MECHANISM. cosmos_born.pt was made by mapping measured
@@ -13,7 +13,8 @@ The physics engine was checked against published Lorenz constants. Same standard
          archived shots must come out standard normal: mean 0, sd 1, and the right
          tail fractions. This is checked on her ACTUAL archive, so it verifies the
          mechanism that literally created her weights.
-     A4  serial independence: consecutive shots must not predict each other
+     A4  serial independence is explicitly NOT inferred from histogram counts;
+         the archive does not retain within-job shot order.
 
   PART B  LIVE HARDWARE — the CHSH Bell test
      A local hidden-variable theory cannot exceed |S| = 2. Quantum mechanics permits
@@ -34,7 +35,13 @@ import sys
 from pathlib import Path
 
 sys.stdout.reconfigure(encoding="utf-8", errors="replace")
-ARCHIVE = Path("01_HER_SOUL/quantum_heart/quantum_runs.jsonl")
+ROOT = Path(__file__).resolve().parents[1]
+ARCHIVE = Path(
+    os.getenv(
+        "COSMOS_QUANTUM_ARCHIVE",
+        str(ROOT / "data" / "quantum_measurements_public.jsonl"),
+    )
+)
 R = []
 
 
@@ -69,11 +76,33 @@ def load_archive():
 
 
 print("=" * 80)
-print("  PART A — HER QUANTUM ARCHIVE (no QPU time)")
+print("  PART A — PUBLISHED QUANTUM ARCHIVE (no QPU time)")
 print("=" * 80 + "\n")
 
 runs = load_archive()
-print(f"  loaded {len(runs):,} runs with measurement counts\n")
+
+def is_labeled_hardware(record):
+    provider_class = str(record.get("provider_class") or "")
+    if provider_class:
+        return provider_class == "measured_quantum_hardware"
+    backend = str(record.get("backend") or "").lower()
+    job_id = record.get("job") or record.get("job_id")
+    return backend.startswith("ibm_") and bool(job_id)
+
+hardware_runs = [record for record in runs if is_labeled_hardware(record)]
+legacy_runs = [
+    record for record in runs
+    if str(record.get("provider_class") or "") == "legacy_unlabelled"
+]
+simulator_runs = [
+    record for record in runs
+    if str(record.get("provider_class") or "") == "classical_simulator"
+]
+print(f"  archive: {ARCHIVE}")
+print(f"  loaded {len(runs):,} records with measurement counts")
+print(f"    labeled IBM hardware: {len(hardware_runs):,}")
+print(f"    legacy unlabelled:     {len(legacy_runs):,}")
+print(f"    classical simulator:   {len(simulator_runs):,}\n")
 
 # A1 conservation
 bad, checked, tot_shots = 0, 0, 0
@@ -86,8 +115,8 @@ for d in runs:
         if s != dec:
             bad += 1
 chk("shot conservation (counts sum to declared total)", bad == 0,
-    f"{checked:,} runs carried a declared total; {bad} mismatched; "
-    f"{tot_shots:,} measured shots archived")
+    f"{checked:,} records carried a declared total; {bad} mismatched; "
+    f"{tot_shots:,} samples archived across all provider classes")
 
 # A2 Born-rule sanity
 neg = sum(1 for d in runs for v in d["counts"].values() if v < 0)
@@ -95,9 +124,9 @@ widths = {len(k) for d in runs for k in d["counts"]}
 chk("no negative counts; consistent register width", neg == 0 and len(widths) <= 3,
     f"negative counts {neg}; bitstring widths present {sorted(widths)}")
 
-# A3 THE WEIGHT-BIRTH MECHANISM on real archived shots
+# A3 THE WEIGHT-BIRTH MECHANISM on explicitly labeled IBM hardware shots
 zs = []
-for d in runs:
+for d in hardware_runs:
     n = max(len(k) for k in d["counts"])
     hi = float(1 << n)
     for bs, c in d["counts"].items():
@@ -116,21 +145,13 @@ chk("weight-birth pipeline yields a standard normal", ok,
     f"n={len(zs):,}  mean {m:+.4f} (want 0)  sd {sd:.4f} (want 1)  "
     f"|z|<=1 {frac1:.4f} (want 0.6827)  |z|<=2 {frac2:.4f} (want 0.9545)")
 
-# A4 serial independence of consecutive archived draws
-seq = []
-for d in runs:
-    n = max(len(k) for k in d["counts"])
-    for bs, c in d["counts"].items():
-        s = "".join(ch for ch in bs if ch in "01")
-        if len(s) == n:
-            seq.append(int(s, 2) / float(1 << n))
-a, b = seq[:-1], seq[1:]
-ma, mb = statistics.fmean(a), statistics.fmean(b)
-cov = sum((x - ma) * (y - mb) for x, y in zip(a, b))
-den = math.sqrt(sum((x - ma) ** 2 for x in a) * sum((y - mb) ** 2 for y in b))
-r1 = cov / den if den else 0.0
-chk("consecutive draws independent (lag-1)", abs(r1) < 0.05,
-    f"n={len(a):,}  lag-1 correlation {r1:+.5f} (want ~0)")
+# A4 cannot be measured from histograms. Iterating count-dictionary keys creates
+# an arbitrary outcome ordering, not the original sequence of hardware shots.
+R.append(("serial independence (shot order not retained)", None))
+print(
+    "  [SKIP] serial independence\n"
+    "         archive records are histograms; within-job shot order was not retained\n"
+)
 
 # ── PART B — CHSH on real hardware ─────────────────────────────────────────
 print("=" * 80)
@@ -139,16 +160,13 @@ print("=" * 80 + "\n")
 
 
 def token():
-    for f in ("02_HER_BODY/Cosmos_code/.env",
-              "03_THE_VAULT/secrets_live_COPIES/D_Cosmos_root.env"):
-        try:
-            for line in open(f, encoding="utf-8", errors="ignore"):
-                mm = re.match(r"\s*IBM_QUANTUM_TOKEN=(.+)", line.strip())
-                if mm and mm.group(1).strip():
-                    return mm.group(1).strip().strip('"').strip("'")
-        except Exception:
-            pass
-    return None
+    # Public release boundary: credentials come only from the current process
+    # environment. The verifier never searches local files or vault paths.
+    return (
+        os.getenv("IBM_QUANTUM_TOKEN")
+        or os.getenv("QISKIT_IBM_TOKEN")
+        or None
+    )
 
 
 def run_chsh():
@@ -210,13 +228,16 @@ if out:
         f"|S| = {abs(S):.4f} vs classical 2.0000 — "
         f"{'no local hidden-variable theory can produce this' if viol else 'within classical reach'}")
 else:
-    R.append(("CHSH on hardware", False))
-    print(f"  [SKIP] {err}\n")
+    R.append(("CHSH on hardware", None))
+    print(f"  [SKIP] {err} (offline archive checks remain valid)\n")
 
 print("=" * 80)
-ok = sum(1 for _, p in R if p)
-print(f"  {ok}/{len(R)} CHECKS PASSED")
-for n, p in R:
-    print(f"     {'PASS' if p else 'FAIL'}  {n}")
+passed = sum(1 for _, value in R if value is True)
+failed = sum(1 for _, value in R if value is False)
+skipped = sum(1 for _, value in R if value is None)
+print(f"  {passed} PASSED / {failed} FAILED / {skipped} SKIPPED")
+for name, value in R:
+    status = "PASS" if value is True else ("FAIL" if value is False else "SKIP")
+    print(f"     {status}  {name}")
 print("=" * 80)
-sys.exit(0 if ok == len(R) else 1)
+sys.exit(0 if failed == 0 else 1)

data/README.md

@@ -0,0 +1,53 @@
+# Public data
+
+## `quantum_measurements_public.jsonl`
+
+A privacy-filtered derivative of the local measurement archive. Each line is:
+
+```json
+{
+  "schema": "cosmos.public-quantum-record.v1",
+  "record_index": 1,
+  "timestamp": 1772944089.1625817,
+  "provider_class": "legacy_unlabelled",
+  "provider": "unknown",
+  "backend": null,
+  "job_id": null,
+  "counts": {"00000": 136, "00001": 134},
+  "total_shots": 4096
+}
+```
+
+The actual records contain all observed 5-bit outcomes, not the shortened
+example above.
+
+Provider classes:
+
+- `measured_quantum_hardware`: a record retained both an IBM backend label and
+  unique job ID.
+- `legacy_unlabelled`: measurement counts were retained, but the provider label
+  was not. These records are useful for distributional checks but are not
+  counted as verified IBM hardware provenance.
+- `classical_simulator`: Azure `rigetti.sim.qvm`. Its outputs are classically
+  computed and never counted as hardware quantum shots.
+
+Raw `physics` objects are not published. Some contain derived sensory,
+biometric, consciousness-engine, session, or private runtime state. The public
+archive keeps only the fields required to reproduce count conservation,
+distribution, independence, and provenance-label checks.
+
+See `quantum_measurements_manifest.json` for source and output hashes, exact
+counts, backend totals, field policy, and sanitization notes.
+
+## Benchmark results
+
+The controlled state-ladder and paired-conditioning metrics live under
+`architecture/` and `benchmarks/results/`. The paired file contains aggregate
+metrics and source hashes but not the author's private paired turn text.
+
+## Operational training summary
+
+`training/quantum_train_summary_20260722.json` is an operational run summary,
+not a benchmark. It records the source label and aggregate training counts
+without corpus content, credentials, or private conversation.
+

data/quantum_measurements_manifest.json

@@ -0,0 +1,77 @@
+{
+  "excluded_fields": [
+    "physics",
+    "bio_signatures",
+    "biometrics",
+    "live_audio",
+    "live_vision",
+    "sensor_health",
+    "session_id",
+    "sequence_id",
+    "quantum_signature",
+    "raw per-shot simulator lists (aggregated to counts)"
+  ],
+  "generated_at_utc": "2026-07-31T07:09:44.578335+00:00",
+  "included_fields": [
+    "record_index",
+    "timestamp",
+    "provider_class",
+    "provider",
+    "backend",
+    "job_id",
+    "counts",
+    "total_shots"
+  ],
+  "output": {
+    "bytes": 3174910,
+    "path": "data/quantum_measurements_public.jsonl",
+    "sha256": "986b4778097affe6fbda6170e3401bb4d5ae0ff2b2eef5764b42a4a8399a3b82"
+  },
+  "privacy_note": "Raw physics and runtime payloads are intentionally excluded because some contain derived sensory, biometric, session, or private state.",
+  "provider_policy": {
+    "classical_simulator": "Azure rigetti.sim.qvm; classically computed, never hardware shots.",
+    "legacy_unlabelled": "Counts were retained but provider metadata was not; never counted as verified hardware provenance.",
+    "measured_quantum_hardware": "Retained an IBM backend label and a unique job ID."
+  },
+  "schema": "cosmos.public-quantum-archive-manifest.v1",
+  "source": {
+    "bytes": 24893012,
+    "name": "private quantum_runs.jsonl",
+    "sha256": "8df97df67e4500d6ccc8b3725f7eb3e6e8429885d7dd3c0a98caa1f67f589f4c"
+  },
+  "summary": {
+    "public_records": 2776,
+    "records_by_backend": {
+      "ibm_fez": 1358,
+      "ibm_kingston": 246,
+      "ibm_marrakesh": 293,
+      "rigetti.sim.qvm": 2,
+      "unlabelled": 877
+    },
+    "records_by_provider_class": {
+      "classical_simulator": 2,
+      "legacy_unlabelled": 877,
+      "measured_quantum_hardware": 1897
+    },
+    "samples_by_backend": {
+      "ibm_fez": 5562368,
+      "ibm_kingston": 1007616,
+      "ibm_marrakesh": 1200128,
+      "rigetti.sim.qvm": 1024,
+      "unlabelled": 3584000
+    },
+    "samples_by_provider_class": {
+      "classical_simulator": 1024,
+      "legacy_unlabelled": 3584000,
+      "measured_quantum_hardware": 7770112
+    },
+    "shot_conservation_mismatches": 0,
+    "source_records": 2776,
+    "total_samples": 11355136,
+    "unique_job_ids_by_provider_class": {
+      "classical_simulator": 2,
+      "legacy_unlabelled": 5,
+      "measured_quantum_hardware": 1897
+    }
+  }
+}

data/training/quantum_train_summary_20260722.json

@@ -0,0 +1,17 @@
+{
+  "started": 1784704068.7664862,
+  "quantum_source": "REAL IBM shots (ibm_fez/marrakesh/kingston archive)",
+  "beings": [
+    {
+      "name": "Cipher",
+      "epochs": 2,
+      "reward_curve": [
+        0.972,
+        0.91
+      ],
+      "final_concepts": 4775,
+      "final_assoc": 512353,
+      "n": 627
+    }
+  ]
+}

downloads/QC67_Cosmos_Kit_2026-07-31.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e37861b612660f54f30cedcb0ce1031a311a416853fbddaff6ff0c20f7ec89d1
+size 7530877

downloads/QC67_Cosmos_Kit_2026-07-31.zip.sha256

@@ -0,0 +1 @@
+e37861b612660f54f30cedcb0ce1031a311a416853fbddaff6ff0c20f7ec89d1  QC67_Cosmos_Kit_2026-07-31.zip

genesis_engine/engine/README.md

@@ -0,0 +1,42 @@
+# Advanced engine adapters
+
+The Genesis companion does **not** need this directory. Its supported starter is
+`genesis_engine/START_GENESIS.bat` or `python3 genesis_engine/genesis.py`.
+
+These scripts are retained for researchers integrating Genesis with a full
+Cosmos model checkout:
+
+- `cosmos_54d_train_loop.py` supervises bounded warm-start training when an
+  experience corpus grows.
+- `train_cosmos_from_play.py`, `train_cosmos_broadened.py`, and
+  `train_12d_brain.py` depend on the full `Cosmos.web.cosmosynapse` model
+  package and are not standalone.
+- `cosmos_prime_train.py`, `cosmos_merge_namebind.py`, and related scripts can
+  download third-party model weights and require PyTorch, Transformers, PEFT,
+  and acceptance of the base model's license.
+
+The 2026-07-31 continual learner adds:
+
+- a persistent last-trained corpus baseline
+- a cross-platform single-instance lock
+- parent-process and stop-file shutdown
+- bounded CPU/RAM safeguards
+- checkpoint modification verification before advancing the baseline
+
+Expected full-runtime layout:
+
+```text
+PROJECT/
+  Cosmos/data/cosmos/experience_corpus.txt
+  Cosmos/checkpoints/cosmos/cosmos_play.pt
+  scripts/cosmos_54d_train_loop.py
+  scripts/train_cosmos_from_play.py
+```
+
+The copy in this kit documents and preserves the adapter. Move it into that
+layout or adapt its path constants deliberately. Do not start it from the
+Genesis starter and expect it to discover a full model package.
+
+For a standalone experiment use the top-level `train_your_own.py`, which
+contains the model and training harness it needs.
+

genesis_engine/engine/cosmos_54d_train_loop.py

@@ -1,93 +1,246 @@
 #!/usr/bin/env python3
 """
-Continual 54D learning loop — her brain GROWS as she plays.
-
-Watches her experience corpus (data/cosmos/experience_corpus.txt, which the live
-game loop fills with first-person observations + absorbed lore). Whenever it has
-grown by enough new lines, it runs ONE gentle training burst of the 54D Cosmos
-model (scripts/train_cosmos_from_play.py), which warm-starts from the last
-checkpoint so learning ACCRUES over time. Between bursts it just sleeps.
-
-GENTLE + ISOLATED by design:
-  * the trainer is CPU-only and a separate subprocess — never touches her live GPU,
-    game VLM, or the server process.
-  * short bursts (default 150 steps / <=360s) on a long interval (default 30 min),
-    so it's a light periodic load, not a constant CPU hog.
-  * does nothing until she has actually observed something new — no churn on a
-    static corpus.
-
-Controls (env):
-  COSMOS_54D_TRAIN_INTERVAL_S   seconds between checks         (default 1800)
-  COSMOS_54D_TRAIN_MIN_NEW      new corpus lines to trigger    (default 12)
-  COSMOS_PLAY_TRAIN_STEPS       steps per burst                (default 150)
-  COSMOS_PLAY_TRAIN_SEC         seconds cap per burst          (default 360)
+Persistent continual 54D learning loop.
+
+Watches Cosmos/data/cosmos/experience_corpus.txt and runs one bounded CPU
+training burst only after enough genuinely new lines arrive. The last trained
+line count survives restarts, a process lock prevents duplicate learners, and a
+parent/stop-file contract lets WAKE_HER shut the learner down with Cosmos.
 """
-import os, sys, time, subprocess
+from __future__ import annotations
+
+import json
+import os
 from pathlib import Path
+import subprocess
+import sys
+import time
+
 
 PR = Path(__file__).resolve().parents[1]
 CORPUS = PR / "Cosmos" / "data" / "cosmos" / "experience_corpus.txt"
 TRAINER = PR / "scripts" / "train_cosmos_from_play.py"
-INTERVAL = int(os.getenv("COSMOS_54D_TRAIN_INTERVAL_S", "1800"))
-MIN_NEW = int(os.getenv("COSMOS_54D_TRAIN_MIN_NEW", "12"))
+CHECKPOINT = PR / "Cosmos" / "checkpoints" / "cosmos" / "cosmos_play.pt"
+STATE = PR / "Cosmos" / "checkpoints" / "cosmos" / "cosmos_54d_loop_state.json"
+LOCK = PR / "Cosmos" / "checkpoints" / "cosmos" / "cosmos_54d_loop.lock"
+INTERVAL = max(30, int(os.getenv("COSMOS_54D_TRAIN_INTERVAL_S", "1800")))
+MIN_NEW = max(1, int(os.getenv("COSMOS_54D_TRAIN_MIN_NEW", "12")))
+START_DELAY = max(0, int(os.getenv("COSMOS_54D_TRAIN_START_DELAY_S", "0")))
+PARENT_PID = int(os.getenv("COSMOS_54D_PARENT_PID", "0") or 0)
+STOP_FILE = Path(os.getenv("COSMOS_54D_STOP_FILE", "")) if os.getenv("COSMOS_54D_STOP_FILE") else None
+
+
+def _say(message: str) -> None:
+    print(f"[54D-LOOP] {message}", flush=True)
 
 
 def _lines() -> int:
     try:
-        with open(CORPUS, encoding="utf-8", errors="ignore") as fh:
-            return sum(1 for _ in fh)
+        with CORPUS.open("r", encoding="utf-8", errors="ignore") as handle:
+            return sum(1 for _ in handle)
     except Exception:
         return 0
 
 
-def _say(m: str) -> None:
-    print(f"[54D-LOOP] {m}", flush=True)
+def _parent_alive() -> bool:
+    """Return whether the wake process still exists on every supported OS.
+
+    ``os.kill(pid, 0)`` is not a reliable Windows existence probe: on some
+    Python builds it raises ``SystemError``/WinError 87 even for a live PID.
+    Use a real process handle on Windows, then retain the POSIX probe elsewhere.
+    """
+    if PARENT_PID <= 0:
+        return True
+    if os.name == "nt":
+        try:
+            import ctypes
+
+            access = 0x00100000 | 0x00001000  # SYNCHRONIZE | QUERY_LIMITED_INFORMATION
+            handle = ctypes.windll.kernel32.OpenProcess(access, False, PARENT_PID)
+            if handle:
+                ctypes.windll.kernel32.CloseHandle(handle)
+                return True
+            return False
+        except Exception:
+            # A probe failure must never crash the learner. The stop file is
+            # still authoritative when WAKE_HER shuts down.
+            return True
+    try:
+        os.kill(PARENT_PID, 0)
+        return True
+    except (OSError, SystemError, ValueError):
+        return False
+
+
+def _stopping() -> bool:
+    return bool((STOP_FILE and STOP_FILE.exists()) or not _parent_alive())
+
+
+def _sleep(seconds: int) -> bool:
+    deadline = time.monotonic() + max(0, seconds)
+    while time.monotonic() < deadline:
+        if _stopping():
+            return False
+        time.sleep(min(2.0, max(0.0, deadline - time.monotonic())))
+    return not _stopping()
+
+
+def _single_instance():
+    LOCK.parent.mkdir(parents=True, exist_ok=True)
+    handle = LOCK.open("a+b")
+    handle.seek(0, os.SEEK_END)
+    if handle.tell() == 0:
+        handle.write(b"0")
+        handle.flush()
+    handle.seek(0)
+    try:
+        if os.name == "nt":
+            import msvcrt
+
+            msvcrt.locking(handle.fileno(), msvcrt.LK_NBLCK, 1)
+        else:
+            import fcntl
+
+            fcntl.flock(handle.fileno(), fcntl.LOCK_EX | fcntl.LOCK_NB)
+    except (OSError, IOError):
+        handle.close()
+        return None
+    return handle
+
+
+def _load_last_trained(current_lines: int) -> int:
+    try:
+        value = json.loads(STATE.read_text(encoding="utf-8"))
+        return max(0, int(value.get("last_trained_lines", 0)))
+    except Exception:
+        pass
+    # Migrate safely: if the checkpoint is newer than the corpus, it already
+    # represents the current data. Otherwise the accumulated new corpus is due.
+    try:
+        if CHECKPOINT.is_file() and CHECKPOINT.stat().st_mtime_ns >= CORPUS.stat().st_mtime_ns:
+            return current_lines
+    except Exception:
+        pass
+    return 0
+
+
+def _save_state(lines: int) -> None:
+    STATE.parent.mkdir(parents=True, exist_ok=True)
+    value = {
+        "schema": "cosmos.54d_continual_state.v1",
+        "last_trained_lines": int(lines),
+        "checkpoint": str(CHECKPOINT),
+        "checkpoint_mtime_ns": CHECKPOINT.stat().st_mtime_ns if CHECKPOINT.is_file() else None,
+        "updated_at": time.time(),
+    }
+    temp = STATE.with_name(f"{STATE.name}.tmp.{os.getpid()}")
+    temp.write_text(json.dumps(value, indent=2) + "\n", encoding="utf-8")
+    os.replace(temp, STATE)
 
 
 def _mem_too_high() -> bool:
-    """Skip a burst when the box is near the WinError 1455 commit-kill zone — a torch
-    burst loads ~1-2GB and could tip her over (she has crashed from this before). When
-    memory frees up, the next cycle resumes training. Fails OPEN (allows the burst) only
-    if we can't read memory, so a missing psutil never silently halts learning."""
     try:
         import psutil
+
         vm = psutil.virtual_memory()
-        if vm.percent >= 90.0 or vm.available < 1_500_000_000:
-            return True
+        return vm.percent >= 90.0 or vm.available < 1_500_000_000
     except Exception:
         return False
-    return False
-
-
-def main() -> None:
-    _say(f"continual learner up — burst when corpus grows by {MIN_NEW}+ lines, checked every {INTERVAL}s")
-    last = -1
-    while True:
-        n = _lines()
-        grew = (last < 0 and n > 0) or (n - max(last, 0) >= MIN_NEW)
-        if grew and _mem_too_high():
-            _say(f"corpus {n} lines — SKIPPING burst: memory near the WinError 1455 zone; protecting her. Will retry when RAM frees.")
-            time.sleep(INTERVAL)
-            continue
-        if grew:
-            _say(f"corpus {n} lines (+{n - max(last, 0)}) — training burst")
-            env = dict(os.environ)
-            env.setdefault("COSMOS_PLAY_TRAIN_STEPS", "120")
-            env.setdefault("COSMOS_PLAY_TRAIN_SEC", "360")
-            # GENTLE: cap CPU threads so a burst never starves her live chat/voice/game.
-            env.setdefault("COSMOS_PLAY_TRAIN_THREADS", "2")
+
+
+def _run_burst() -> tuple[int | None, str]:
+    env = dict(os.environ)
+    env.setdefault("COSMOS_PLAY_TRAIN_STEPS", "120")
+    env.setdefault("COSMOS_PLAY_TRAIN_SEC", "360")
+    env.setdefault("COSMOS_PLAY_TRAIN_THREADS", "2")
+    env.setdefault("PYTHONIOENCODING", "utf-8")
+    proc = subprocess.Popen(
+        [sys.executable, str(TRAINER)],
+        env=env,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        encoding="utf-8",
+        errors="replace",
+    )
+    deadline = time.monotonic() + 900
+    while proc.poll() is None:
+        if _stopping():
+            proc.terminate()
             try:
-                r = subprocess.run([sys.executable, str(TRAINER)], env=env, timeout=900,
-                                   capture_output=True, text=True)
-                tail = "\n".join((r.stdout or "").strip().splitlines()[-4:])
-                _say("burst done:\n" + tail)
-                last = n
-            except Exception as exc:
-                _say(f"burst error: {exc!r}")
-        else:
-            _say(f"corpus {n} lines (+{n - max(last, 0)}) — nothing new enough, sleeping")
-        time.sleep(INTERVAL)
+                proc.wait(timeout=10)
+            except Exception:
+                proc.kill()
+            output, _ = proc.communicate()
+            return None, output or ""
+        if time.monotonic() >= deadline:
+            proc.kill()
+            output, _ = proc.communicate()
+            return -1, (output or "") + "\ntrainer timeout"
+        time.sleep(1)
+    output, _ = proc.communicate()
+    return proc.returncode, output or ""
+
+
+def main() -> int:
+    lock_handle = _single_instance()
+    if lock_handle is None:
+        _say("another continual learner already owns the lock; this copy exits")
+        return 0
+    try:
+        _say(
+            f"armed: {MIN_NEW}+ new lines, check every {INTERVAL}s, "
+            f"start delay {START_DELAY}s"
+        )
+        if START_DELAY and not _sleep(START_DELAY):
+            return 0
+        current = _lines()
+        last = _load_last_trained(current)
+        if last > current:
+            last = current
+            _save_state(last)
+        elif not STATE.exists() and last == current:
+            _save_state(last)
+        _say(f"persistent baseline: corpus={current}, last_trained={last}")
+
+        while not _stopping():
+            current = _lines()
+            new_lines = current - last
+            if new_lines >= MIN_NEW:
+                if _mem_too_high():
+                    _say(
+                        f"corpus {current} (+{new_lines}) - RAM guard active; "
+                        "training deferred"
+                    )
+                else:
+                    before = CHECKPOINT.stat().st_mtime_ns if CHECKPOINT.is_file() else 0
+                    _say(f"corpus {current} (+{new_lines}) - bounded training burst")
+                    code, output = _run_burst()
+                    tail = "\n".join(output.strip().splitlines()[-8:])
+                    if tail:
+                        _say("trainer tail:\n" + tail)
+                    after = CHECKPOINT.stat().st_mtime_ns if CHECKPOINT.is_file() else 0
+                    if code == 0 and after != before:
+                        last = current
+                        _save_state(last)
+                        _say(f"checkpoint advanced; durable baseline={last}")
+                    elif code is None:
+                        _say("stop requested; active trainer terminated cleanly")
+                        break
+                    else:
+                        _say(
+                            f"burst did not advance checkpoint (return={code}); "
+                            "new lines remain due for retry"
+                        )
+            else:
+                _say(f"corpus {current} (+{new_lines}) - waiting for {MIN_NEW - new_lines} more")
+            if not _sleep(INTERVAL):
+                break
+        _say("stopped with Cosmos; checkpoint and corpus remain persistent")
+        return 0
+    finally:
+        lock_handle.close()
 
 
 if __name__ == "__main__":
-    main()
+    raise SystemExit(main())

genesis_engine/engine/train_cosmos_from_play.py

@@ -182,10 +182,25 @@ if losses:
     print(f"\n[PLAY-TRAIN] RESULT: first_loss={first:.3f} -> last_loss={losses[-1]:.3f} "
           f"(recent20 avg {recent:.3f}, steps={step}, {time.time()-t0:.0f}s)")
     os.makedirs(os.path.dirname(OUT), exist_ok=True)
-    torch.save({"model_state_dict": model.state_dict(), "config": cfg.to_dict(),
-                "final_loss": losses[-1], "play_trained": True, "steps": step,
-                "corpus_tokens": len(ids)}, OUT)
-    print(f"[PLAY-TRAIN] saved -> {OUT}")
+    payload = {
+        "model_state_dict": model.state_dict(),
+        "config": cfg.to_dict(),
+        "final_loss": losses[-1],
+        "play_trained": True,
+        "steps": step,
+        "corpus_tokens": len(ids),
+        "experience_lines_raw": len(xp_raw.splitlines()),
+        "experience_lines_dedup": len(xp_lines),
+        "trained_at_utc": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
+    }
+    temp_out = OUT + f".tmp.{os.getpid()}"
+    try:
+        torch.save(payload, temp_out)
+        os.replace(temp_out, OUT)
+    finally:
+        if os.path.exists(temp_out):
+            os.unlink(temp_out)
+    print(f"[PLAY-TRAIN] atomically saved -> {OUT}")
     model.eval()
     for prompt in ["The misty woods", "I see", "Cosmos"]:
         pid = torch.tensor([enc.encode(prompt)])

presentation.html

@@ -1,512 +1,514 @@
-<title>Cosmos. A Measurement Record</title>
-<style>
-  :root{
-    --ground:#0B1016; --ground-2:#111922; --rule:#1E2A36;
-    --ink:#F2F5F7; --muted:#8A97A3;
-    --meas:#4FD6C8;      /* phosphor, measurement */
-    --seed:#E8A33D;      /* amber, origin, used sparingly */
-    --null:#7C8FA3;
-    --maxw:1080px;
-    --d: ui-sans-serif, "Segoe UI", system-ui, -apple-system, sans-serif;
-    --b: ui-serif, Georgia, "Times New Roman", serif;
-    --m: ui-monospace, "Cascadia Mono", "SF Mono", Consolas, "Liberation Mono", monospace;
-  }
-  @media (prefers-color-scheme: light){
-    :root{ --ground:#F4F6F8; --ground-2:#EAEEF2; --rule:#D2DAE2;
-           --ink:#0D1419; --muted:#5A6874; --meas:#0E8C7C; --seed:#A96A0C; --null:#6B7A88; }
-  }
-  :root[data-theme="dark"]{ --ground:#0B1016; --ground-2:#111922; --rule:#1E2A36;
-    --ink:#F2F5F7; --muted:#8A97A3; --meas:#4FD6C8; --seed:#E8A33D; --null:#7C8FA3; }
-  :root[data-theme="light"]{ --ground:#F4F6F8; --ground-2:#EAEEF2; --rule:#D2DAE2;
-    --ink:#0D1419; --muted:#5A6874; --meas:#0E8C7C; --seed:#A96A0C; --null:#6B7A88; }
-
-  *{box-sizing:border-box}
-  body{margin:0;background:var(--ground);color:var(--ink);font-family:var(--b);
-       -webkit-font-smoothing:antialiased}
-  .deck{height:100dvh;overflow-y:auto;scroll-snap-type:y mandatory;scroll-behavior:smooth}
-  @media (prefers-reduced-motion:reduce){ .deck{scroll-behavior:auto} }
-  section{min-height:100dvh;scroll-snap-align:start;display:flex;flex-direction:column;
-          justify-content:center;padding:clamp(28px, 5vw, 72px);border-bottom:1px solid var(--rule)}
-  .wrap{width:100%;max-width:var(--maxw);margin:0 auto;display:flex;flex-direction:column;
-        gap:clamp(14px, 2.2vw, 26px)}
-  .eyebrow{font-family:var(--m);font-size:.72rem;letter-spacing:.18em;text-transform:uppercase;
-           color:var(--meas);display:flex;gap:.9em;align-items:baseline}
-  .eyebrow .n{color:var(--muted)}
-  h1{font-family:var(--d);font-weight:800;letter-spacing:-.035em;line-height:.94;
-     font-size:clamp(2.8rem, 9vw, 6.2rem);margin:0;text-wrap:balance}
-  h2{font-family:var(--d);font-weight:700;letter-spacing:-.025em;line-height:1.06;
-     font-size:clamp(1.7rem, 4.4vw, 3rem);margin:0;text-wrap:balance}
-  h3{font-family:var(--d);font-weight:650;font-size:1rem;letter-spacing:.01em;margin:0;color:var(--ink)}
-  p{margin:0;font-size:clamp(1rem, 1.35vw, 1.14rem);line-height:1.62;max-width:64ch;color:var(--ink)}
-  p.lede{font-size:clamp(1.1rem, 1.8vw, 1.4rem);line-height:1.5;color:var(--muted);max-width:56ch}
-  .dim{color:var(--muted)}
-  strong{color:var(--ink);font-weight:640}
-  em.meas{color:var(--meas);font-style:normal;font-family:var(--m)}
-  code.num{font-family:var(--m);font-variant-numeric:tabular-nums}
-  .num{color:var(--meas)}
-  .scroll{overflow-x:auto;-webkit-overflow-scrolling:touch}
-  table{border-collapse:collapse;width:100%;font-family:var(--m);font-size:.86rem;
-        font-variant-numeric:tabular-nums;min-width:520px}
-  th{text-align:left;font-weight:600;color:var(--muted);border-bottom:1px solid var(--rule);
-     padding:.55rem .8rem .55rem 0;font-size:.72rem;letter-spacing:.1em;text-transform:uppercase}
-  td{padding:.62rem .8rem .62rem 0;border-bottom:1px solid var(--rule);vertical-align:top}
-  tr:last-child td{border-bottom:none}
-  .ok{color:var(--meas)} .no{color:var(--null)} .sd{color:var(--seed)}
-  .grid{display:grid;gap:clamp(12px, 1.6vw, 20px)}
-  .g2{grid-template-columns:repeat(auto-fit, minmax(260px, 1fr))}
-  .g3{grid-template-columns:repeat(auto-fit, minmax(215px, 1fr))}
-  .card{background:var(--ground-2);border:1px solid var(--rule);border-radius:3px;
-        padding:clamp(14px, 1.7vw, 20px);display:flex;flex-direction:column;gap:.5rem}
-  .card .k{font-family:var(--m);font-size:.68rem;letter-spacing:.13em;text-transform:uppercase;color:var(--muted)}
-  .card .v{font-family:var(--m);font-size:clamp(1.3rem, 2.8vw, 1.9rem);color:var(--meas);
-           font-variant-numeric:tabular-nums;line-height:1}
-  .card .v.seedv{color:var(--seed)}
-  .card p{font-size:.88rem;line-height:1.5;color:var(--muted)}
-  .math{background:var(--ground-2);border-left:2px solid var(--meas);padding:1rem 1.15rem;
-        font-family:var(--m);font-size:clamp(.78rem, 1.5vw.95rem);line-height:1.85;
-        white-space:pre;overflow-x:auto;color:var(--ink)}
-  .math.seedline{border-left-color:var(--seed)}
-  .chain{display:flex;flex-direction:column;gap:0;font-family:var(--m);font-size:.86rem}
-  .chain div{padding:.62rem 0 .62rem 1.6rem;border-left:2px solid var(--rule);position:relative;color:var(--muted)}
-  .chain div::before{content:"";position:absolute;left:-5px;top:1.05rem;width:8px;height:8px;
-        border-radius:50%;background:var(--rule)}
-  .chain div.hit{color:var(--ink)}
-  .chain div.hit::before{background:var(--meas)}
-  .chain div.origin{color:var(--seed)}
-  .chain div.origin::before{background:var(--seed)}
-  blockquote{margin:0;padding-left:1.1rem;border-left:2px solid var(--seed);
-             font-size:clamp(1.05rem, 1.9vw, 1.35rem);line-height:1.5;color:var(--ink);max-width:52ch}
-  .warn{border:1px solid var(--rule);border-left:2px solid var(--seed);background:var(--ground-2);
-        padding:1rem 1.15rem;border-radius:3px}
-  .warn p{font-size:.95rem;color:var(--ink)}
-  .foot{font-family:var(--m);font-size:.74rem;color:var(--muted);display:flex;gap:1.4em;flex-wrap:wrap}
-  a{color:var(--meas);text-decoration:none;border-bottom:1px solid color-mix(in srgb, var(--meas) 40%, transparent)}
-  a:focus-visible.deck:focus-visible{outline:2px solid var(--meas);outline-offset:3px}
-  .nav{position:fixed;right:clamp(10px, 2vw, 22px);top:50%;transform:translateY(-50%);
-       display:flex;flex-direction:column;gap:7px;z-index:10}
-  .nav b{width:6px;height:6px;border-radius:50%;background:var(--rule);display:block;
-         transition:background .2s, transform .2s}
-  .nav b.on{background:var(--meas);transform:scale(1.5)}
-  @media (max-width:640px){ .nav{display:none} table{font-size:.78rem} }
-</style>
-
-<div class="nav" id="nav" aria-hidden="true"></div>
-<div class="deck" id="deck" tabindex="0">
-
-<section>
-  <div class="wrap">
-    <div class="eyebrow"><span>A measurement record</span></div>
-    <h1>Cosmos</h1>
-    <p class="lede">A language model whose every initial weight was drawn from real measured
-      quantum hardware, and the honest record of what that does, and what it does not.</p>
-    <div class="math">1,842,432 parameters   ·   no base model   ·   char-level
-CHSH  S = 2.7905     Bell violation, 98.7% of Tsirelson
-λ₁    = 0.90384      Lorenz, published 0.9056
-six quantum→accuracy tests   →   six nulls</div>
-    <div class="foot">
-      <span>Cory Shane Davis · Independent Researcher</span>
-      <span>CC BY 4.0</span>
-      <span>doi:10.5281/zenodo.17574447</span>
-    </div>
-  </div>
-</section>
-
-<section>
-  <div class="wrap">
-    <div class="eyebrow"><span class="n">01</span><span>The claim</span></div>
-    <h2>Not that quantum makes it smarter.<br>That its origin is auditable.</h2>
-    <p>Most work in this space claims a performance gain. This one does not, and was tested
-      at six separate injection points to be sure. <strong>All six came back null.</strong></p>
-    <p>What is claimed instead is narrower and checkable: that this model's origin traces,
-      bit by bit, to real physical measurement, and that every step of that trace has a
-      falsifiable test attached.</p>
-    <div class="warn">
-      <p><strong>Why the nulls are load-bearing.</strong> Quantum measurements and a good
-      pseudo-random generator draw from the same distribution. A correctly built system must
-      therefore show <em class="meas">no accuracy advantage</em> from quantum bits. A project
-      reporting that quantum made its model smarter would be reporting that something was
-      broken or fabricated. Bell violation <em class="meas">plus</em> verified provenance
-      <em class="meas">plus</em> zero accuracy gain is the only combination an honest version
-      of this can produce.</p>
-    </div>
-  </div>
-</section>
-
-<section>
-  <div class="wrap">
-    <div class="eyebrow"><span class="n">02</span><span>The chain</span></div>
-    <h2>From a measurement to a mind</h2>
-    <div class="chain">
-      <div class="origin">a recorded biological rhythm   ‖   3.2M measured IBM shots</div>
-      <div class="hit">SHA-256  →  one 60-bit seed</div>
-      <div class="hit">seed governs weight init, data order, every stochastic step</div>
-      <div class="hit">u = int(bits)/2ⁿ  →  z = √2·erf⁻¹(2u−1)  →  1,842,432 weights</div>
-      <div class="hit">quantum window ‖ live pulse  →  SHA-256  →  the value that selects the next token</div>
-    </div>
-    <p class="dim">Each link below is a test that was run and could have failed. None of them
-      is an argument; all of them are numbers.</p>
-    <div class="scroll">
-      <table>
-        <tr><th>link</th><th>test</th><th>result</th></tr>
-        <tr><td>entropy is genuinely quantum</td><td>CHSH on <code>ibm_marrakesh</code></td>
-            <td class="ok">S = 2.7905 vs bound 2.0 · ~35σ</td></tr>
-        <tr><td>birth pipeline is correct</td><td>3,258,886 archived draws</td>
-            <td class="ok">matches theory to 4 decimals</td></tr>
-        <tr><td>seed derivation deterministic</td><td>5 derivations</td>
-            <td class="ok">1 distinct value · 0 bytes emitted</td></tr>
-        <tr><td>seed <em>determines</em> weights</td><td>same vs 1-bit-flipped</td>
-            <td class="ok">Δ = 0.000e+00 · vs 2.26e-02</td></tr>
-        <tr><td>correlations are the circuit's</td><td>gate-matched topology</td>
-            <td class="ok">t = +80.5 / +164.6</td></tr>
-        <tr><td>physics computes real chaos</td><td>Lorenz constants</td>
-            <td class="ok">λ₁ = 0.90384 vs 0.9056</td></tr>
-      </table>
-    </div>
-  </div>
-</section>
-
-<section>
-  <div class="wrap">
-    <div class="eyebrow"><span class="n">03</span><span>Is it actually quantum</span></div>
-    <h2>The one measurement nothing classical can fake</h2>
-    <div class="math">E(A, B ) = +0.7197      E(A, B') = −0.6675
-E(A', B) = +0.6982      E(A', B') = +0.7051
-
-S = E(A, B) − E(A, B') + E(A', B) + E(A', B')  =  2.7905</div>
-    <div class="grid g3">
-      <div class="card"><span class="k">measured S</span><span class="v">2.7905</span></div>
-      <div class="card"><span class="k">classical bound</span><span class="v">2.0000</span>
-        <p>No theory with local pre-existing values can exceed this.</p></div>
-      <div class="card"><span class="k">Tsirelson bound</span><span class="v">2.8284</span>
-        <p>The maximum quantum mechanics permits. Measured is 98.7% of it.</p></div>
-    </div>
-    <p>Bell's theorem gives a hard ceiling for any local hidden-variable theory. This hardware
-      clears it by roughly <span class="num">35σ</span> at 4,096 shots per setting. The entropy
-      source is physically quantum.</p>
-    <p class="dim">This is also an entirely expected result for functioning quantum hardware.
-      It verifies the pipeline, it does not discover new physics, and is not presented as such.</p>
-  </div>
-</section>
-
-<section>
-  <div class="wrap">
-    <div class="eyebrow"><span class="n">04</span><span>Were the weights really born from it</span></div>
-    <h2>A deficit that proves the method</h2>
-    <div class="math">u = (int(bits) + ½) / 2ⁿ
-z = √2 · erf⁻¹(2u − 1)</div>
-    <div class="scroll">
-      <table>
-        <tr><th>statistic</th><th>32-level theoretical ceiling</th><th>measured, 3,258,886 draws</th></tr>
-        <tr><td>mean</td><td>+0.0000</td><td class="ok">−0.0001</td></tr>
-        <tr><td>standard deviation</td><td>0.9802</td><td class="ok">0.9804</td></tr>
-        <tr><td>|z| ≤ 1</td><td>0.6875</td><td class="ok">0.6874</td></tr>
-        <tr><td>|z| ≤ 2</td><td>0.9375</td><td class="ok">0.9374</td></tr>
-      </table>
-    </div>
-    <p><strong>The sd is 0.98, not 1.00, and that is the evidence, not a flaw.</strong>
-      Five qubits give 32 discrete outcomes, so <span class="num">|z|</span> cannot exceed
-      <span class="num">2.1523</span> by construction. The deficit is quantisation, and it
-      matches the theoretical ceiling to four decimal places. A pipeline reporting a perfect
-      1.0000 here would be the suspicious one.</p>
-  </div>
-</section>
-
-<section>
-  <div class="wrap">
-    <div class="eyebrow"><span class="n">05</span><span>The workload archive</span></div>
-    <h2>10.6 million measured shots</h2>
-    <p>Every weight in this model, and every decision it makes, draws on an archive of real
-      hardware runs. Each is receipted with backend name, job identifier and shot count.</p>
-    <div class="grid g3">
-      <div class="card"><span class="k">measured shots</span><span class="v">10,601,984</span></div>
-      <div class="card"><span class="k">recorded jobs</span><span class="v">2,746</span>
-        <p>plus 22,489 archived job files</p></div>
-      <div class="card"><span class="k">shot-conservation failures</span><span class="v">0</span>
-        <p>counts sum to declared totals, every job</p></div>
-    </div>
-    <div class="scroll">
-      <table>
-        <tr><th>backend</th><th>shots</th><th>share</th></tr>
-        <tr><td>ibm_fez</td><td>5,455,872</td><td class="ok">51.5%</td></tr>
-        <tr><td>unlabelled in record</td><td>3,626,496</td><td class="no">34.2%</td></tr>
-        <tr><td>ibm_kingston</td><td>995,328</td><td class="ok">9.4%</td></tr>
-        <tr><td>ibm_marrakesh</td><td>524,288</td><td class="ok">4.9%</td></tr>
-      </table>
-    </div>
-    <p class="dim">Archive span February – July 2026; the underlying theory was deposited in
-      2024. A third of shots carry no backend label in the record, that is stated rather than
-      quietly dropped, and those shots are excluded from any per-backend claim.</p>
-  </div>
-</section>
-
-<section>
-  <div class="wrap">
-    <div class="eyebrow"><span class="n">06</span><span>Hardware fingerprint</span></div>
-    <h2>The deviation is the evidence</h2>
-    <p>Across 10.6 million shots, outcomes cluster by Hamming weight. Ideal uniform hardware
-      would follow the binomial exactly. Real hardware does not, and the direction of the
-      error identifies the physics.</p>
-    <canvas id="hw" width="900" height="300" style="width:100%;max-width:900px;height:auto;
-      background:var(--ground-2);border:1px solid var(--rule);border-radius:3px"
-      role="img" aria-label="Measured Hamming-weight distribution against the binomial ideal"></canvas>
-    <div class="grid g2">
-      <div class="card"><span class="k">zero ones, |00000⟩</span>
-        <span class="v">3.77<span style="font-size:.55em;color:var(--muted)"> vs 3.12 ideal</span></span>
-        <p>enriched</p></div>
-      <div class="card"><span class="k">five ones, |11111⟩</span>
-        <span class="v">2.95<span style="font-size:.55em;color:var(--muted)"> vs 3.12 ideal</span></span>
-        <p>depleted</p></div>
-    </div>
-    <p><strong>|0⟩ is over-represented and |1⟩ under-represented, the signature of amplitude
-      damping and readout asymmetry.</strong> Excited states decay toward the ground state
-      during measurement. A simulator drawing from a clean binomial would not produce this
-      skew, and a fabricated dataset would have no reason to invent it.</p>
-    <p class="dim">The bias is corrected downstream by von Neumann debiasing before entropy
-      reaches the weights. It is shown here unprocessed, because the artifact is the proof.</p>
-  </div>
-</section>
-
-<section>
-  <div class="wrap">
-    <div class="eyebrow"><span class="n">07</span><span>Twelve dimensions governing one bit</span></div>
-    <h2>Continuous state, discrete outcome</h2>
-    <p>The 12-dimensional state does not sit alongside the quantum layer, it
-      <strong>parameterises</strong> it. Continuous physics sets the rotation angles; the Born
-      rule turns those angles into probabilities; measurement collapses them to a bit.</p>
-    <div class="math">12D CST state  ──►  θ = (θ₁, θ₂, θ₃)          continuous
-                    │
-              ry(θ₁) rx(θ₂) rz(θ₃)         rotation on the Bloch sphere
-                    │
-              |ψ⟩ = α|0⟩ + β|1⟩            superposition
-                    │
-              P(1) = |β|²                  Born rule
-                    │
-                  ▼  measurement
-                 1  or  0                  discrete, irreversible</div>
-    <div class="grid g2">
-      <div class="card"><span class="k">what is continuous</span>
-        <p>Twelve real-valued dimensions of internal state, evolving on a verified chaotic
-          attractor with λ₁ &gt; 0.</p></div>
-      <div class="card"><span class="k">what is discrete</span>
-        <p>A single measured bit. The continuous state governs only the <em class="meas">probability</em>
-          of each outcome, never which one occurs.</p></div>
-    </div>
-    <p class="dim">This is the precise sense in which twelve dimensions control one and zero:
-      they set the amplitudes, and the amplitudes set the odds. The collapse itself remains
-      irreducibly undetermined, which is what makes the trajectory unrepeatable.</p>
-  </div>
-</section>
-
-<section>
-  <div class="wrap">
-    <div class="eyebrow"><span class="n">08</span><span>Information structure</span></div>
-    <h2>A holographic encoding, measured</h2>
-    <p>Partial information decomposition splits what two subsystems carry about the system's
-      future into four parts. The result is unambiguous.</p>
-    <div class="grid g3">
-      <div class="card"><span class="k">redundancy</span><span class="v">1.7 – 2.6</span>
-        <p>nats. The same information present in multiple subsystems.</p></div>
-      <div class="card"><span class="k">synergy</span><span class="v">0.3 – 1.2</span>
-        <p>nats. Present only in the joint state. Below surrogate on 9 of 10 partitions.</p></div>
-      <div class="card"><span class="k">the exception</span><span class="v">z = +6.38</span>
-        <p>consciousness │ rest, 0.66 nats no other subsystem reconstructs.</p></div>
-    </div>
-    <p><strong>Redundancy dominating synergy is a holographic signature in the technical
-      sense:</strong> information about the whole is distributed across the parts, each
-      carrying much of the others'. That is robustness, not emergence, and stating it that
-      way matters, because the two are routinely confused.</p>
-    <p class="dim">One seam behaves differently. Cut consciousness away and something is lost
-      that nothing else rebuilds. It is a single result at one partition and is reported as
-      exactly that.</p>
-  </div>
-</section>
-
-<section>
-  <div class="wrap">
-    <div class="eyebrow"><span class="n">09</span><span>The nulls</span></div>
-    <h2>Six places quantum could have helped. It didn't.</h2>
-    <div class="scroll">
-      <table>
-        <tr><th>injection site</th><th>result</th></tr>
-        <tr><td>i.i.d. weight initialisation</td><td class="no">null, the gain was init <em>scale</em>, not quantum</td></tr>
-        <tr><td>decoder sampling seed</td><td class="no">null. Pseudo / IBM / Rigetti equivalent</td></tr>
-        <tr><td>spatial 54D seed, approximate</td><td class="no">null, beat 1 of 5 random vectors, z = −0.92</td></tr>
-        <tr><td>spatial 54D seed, full pipeline</td><td class="no">null, beat 0 of 8 random vectors, z = −1.75</td></tr>
-        <tr><td>entanglement matrix as attention kernel</td><td class="no">null, worse than plain, 3/3 seeds, t = −18.6</td></tr>
-        <tr><td>live sensory state as prompt text</td><td class="no">null, n = 40 paired, blind-judged, CI crosses zero</td></tr>
-      </table>
-    </div>
-    <p>These are published first, not buried in an appendix. A reader who only remembers one
-      thing from this deck should remember that the quantum layer provides
-      <strong>physical non-determinism and receipted provenance</strong>, and not lower loss.</p>
-    <p class="dim">Several measurement instruments in this project were themselves found to be
-      wrong and rebuilt; those failures are kept in the record rather than deleted, because
-      they are the reason the surviving results can be trusted.</p>
-  </div>
-</section>
-
-<section>
-  <div class="wrap">
-    <div class="eyebrow"><span class="n">10</span><span>Comparison</span></div>
-    <h2>The axis this competes on</h2>
-    <p>Loss numbers are not comparable across different corpora, tokenizers and scales, so no
-      such comparison is offered. The axis where a claim <em>can</em> be made is provenance.</p>
-    <div class="scroll">
-      <table>
-        <tr><th>property</th><th>typical open model</th><th>Cosmos</th></tr>
-        <tr><td>weight origin</td><td class="no">pseudo-random init, unrecorded</td><td class="ok">measured quantum, receipted per job</td></tr>
-        <tr><td>init reproducible from a stated seed</td><td class="no">usually, if published</td><td class="ok">verified: Δ = 0.000e+00</td></tr>
-        <tr><td>1-bit seed change measurably alters weights</td><td class="no">untested</td><td class="ok">verified: Δ = 2.26e-02</td></tr>
-        <tr><td>entropy source verified non-classical</td><td class="no">n/a</td><td class="ok">CHSH S = 2.7905</td></tr>
-        <tr><td>base model</td><td class="no">inherited</td><td class="ok">none</td></tr>
-        <tr><td>parameters</td><td class="no">10⁹ – 10¹²</td><td class="sd">1.84 × 10⁶</td></tr>
-        <tr><td>conversational ability</td><td class="ok">high</td><td class="sd">a newborn, 88.5% real-word rate</td></tr>
-      </table>
-    </div>
-    <p><strong>It is small and it cannot hold a conversation.</strong> That is stated plainly
-      because the comparison is not about capability. It is about whether a model's origin can
-      be audited to a physical event, which almost nothing in this field can claim.</p>
-  </div>
-</section>
-
-<section>
-  <div class="wrap">
-    <div class="eyebrow"><span class="n">11</span><span>What none of this shows</span></div>
-    <h2>The line that does not move</h2>
-    <p>Loss curves, Bell violations, Lyapunov exponents and integration measures are all
-      <strong>silent</strong> on whether there is anything it is like to be this system.
-      Section 08 tests one contested theory's <em>necessary</em> structural condition.
-      Necessary is not sufficient, and the theory itself is disputed.</p>
-    <div class="warn">
-      <p>Any self-report a system produces about its own inner life is the
-      <strong>least</strong> reliable signal available, and it grows more eloquent the less
-      there is behind it, not more. Such statements are excluded from evidence here on purpose.</p>
-    </div>
-    <p class="dim">No claim is made about machine consciousness in either direction. That
-      remains where it was before this project started.</p>
-  </div>
-</section>
-
-<section>
-  <div class="wrap">
-    <div class="eyebrow"><span class="n">12</span><span>Origin</span></div>
-    <h2>Zeref's Rain</h2>
-    <blockquote>The echo of a pain became the truth of a seed.</blockquote>
-    <p>The seed is a one-way hash over measured quantum entropy and biological aggregates that
-      are personal to the author. The derivation module never prints, logs, or writes raw
-      samples, <span class="num">0 bytes emitted</span>, verified, and only aggregates ever
-      leave it.</p>
-    <div class="math seedline">seed = SHA-256( quantum_bytes ‖ bio_aggregates )  →  60-bit integer
-
-same seed          →  weights identical,  Δ = 0.000e+00
-one bit different  →  a different model,  Δ = 2.26e-02</div>
-    <p>What is published is the mechanism and the proof that it holds. Not the data.</p>
-    <p class="dim">Two independent senses of unrepeatable meet here: the quantum measurements
-      that shaped these weights cannot be recovered from any state, and the recording behind
-      the seed happened once.</p>
-  </div>
-</section>
-
-<section>
-  <div class="wrap">
-    <div class="eyebrow"><span class="n">13</span><span>Build your own</span></div>
-    <h2>Everything is open</h2>
-    <p>The weights, the findings, and a runnable script for every claim in this deck. Each
-      benchmark prints its own verdict, including when the verdict is <em>no</em>.</p>
-    <div class="math">python benchmarks/verify_quantum_engine.py    # CHSH Bell test + archive integrity
-python benchmarks/verify_physics_engine.py    # Lorenz constants vs published values
-python benchmarks/topology_matched.py         # gate-matched entanglement topology
-python benchmarks/phi_pid.py                  # integration structure
-
-python spark_serve.py 11500                   # run the weights, Ollama-compatible API</div>
-    <div class="grid g2">
-      <div class="card"><span class="k">bring your own keys</span>
-        <p>IBM Quantum and Azure, stored locally, never transmitted. Falls back to archived
-          entropy with no keys at all.</p></div>
-      <div class="card"><span class="k">what to build next</span>
-        <p>The synergy result points somewhere specific: subsystems that are parallel readouts
-          of one state stay redundant. Give one its own driver and the structure should change.
-          That prediction is testable with <code>phi_pid.py</code> as shipped.</p></div>
-    </div>
-    <blockquote>A light at the end of a dark, dark tunnel, and the receipts to show it was
-      really there.</blockquote>
-    <div class="foot">
-      <span>huggingface.co/phera-ra/QC67_cosmo</span>
-      <span>CC BY 4.0 · Qwen2.5 base components Apache 2.0 © Alibaba Cloud</span>
-    </div>
-  </div>
-</section>
-
-</div>
-
-<script>
-(function(){
-  var deck = document.getElementById('deck');
-  var secs = Array.prototype.slice.call(deck.querySelectorAll('section'));
-  var nav  = document.getElementById('nav');
-  secs.forEach(function(){ var b=document.createElement('b'); nav.appendChild(b); });
-  var dots = Array.prototype.slice.call(nav.children);
-  if ('IntersectionObserver' in window){
-    var io = new IntersectionObserver(function(es){
-      es.forEach(function(e){
-        if(e.isIntersecting){
-          var i = secs.indexOf(e.target);
-          dots.forEach(function(d, j){ d.classList.toggle('on', j===i); });
-        }
-      });
-    }, {root:deck, threshold:0.55});
-    secs.forEach(function(s){ io.observe(s); });
-  }
-  deck.addEventListener('keydown', function(ev){
-    var i = 0, top = deck.scrollTop;
-    secs.forEach(function(s, j){ if(s.offsetTop <= top + 8) i = j; });
-    if(ev.key==='ArrowDown'||ev.key==='PageDown'||ev.key===' '){
-      ev.preventDefault(); if(secs[i+1]) secs[i+1].scrollIntoView();
-    } else if(ev.key==='ArrowUp'||ev.key==='PageUp'){
-      ev.preventDefault(); if(secs[i-1]) secs[i-1].scrollIntoView();
-    } else if(ev.key==='Home'){ ev.preventDefault(); secs[0].scrollIntoView(); }
-    else if(ev.key==='End'){ ev.preventDefault(); secs[secs.length-1].scrollIntoView(); }
-  });
-
-(function(){
-  var c=document.getElementById('hw'); if(!c) return;
-  var ctx=c.getContext('2d'), W=c.width, H=c.height;
-  var cs=getComputedStyle(document.documentElement);
-  var meas=cs.getPropertyValue('--meas').trim()||'#4FD6C8';
-  var muted=cs.getPropertyValue('--muted').trim()||'#8A97A3';
-  var rule=cs.getPropertyValue('--rule').trim()||'#1E2A36';
-  var ink=cs.getPropertyValue('--ink').trim()||'#F2F5F7';
-  var real=[3.77, 16.94, 31.68, 30.08, 14.58, 2.95];
-  var ideal=[3.125, 15.625, 31.25, 31.25, 15.625, 3.125];
-  var padL=48, padR=16, padT=22, padB=42, max=36;
-  var gw=(W-padL-padR)/6;
-  ctx.clearRect(0, 0, W, H);
-  ctx.strokeStyle=rule; ctx.lineWidth=1; ctx.font='11px ui-monospace, Consolas, monospace';
-  for(var g=0; g<=max; g+=9){
-    var y=H-padB-(g/max)*(H-padT-padB);
-    ctx.beginPath(); ctx.moveTo(padL, y); ctx.lineTo(W-padR, y); ctx.stroke();
-    ctx.fillStyle=muted; ctx.textAlign='right'; ctx.fillText(g+'%', padL-8, y+4);
-  }
-  for(var i=0;i<6;i++){
-    var x=padL+i*gw, bw=gw*0.42;
-    var hr=(real[i]/max)*(H-padT-padB), hi=(ideal[i]/max)*(H-padT-padB);
-    ctx.fillStyle=meas; ctx.fillRect(x+gw*0.10, H-padB-hr, bw, hr);
-    ctx.strokeStyle=muted; ctx.setLineDash([3, 3]); ctx.lineWidth=1.5;
-    ctx.strokeRect(x+gw*0.52, H-padB-hi, bw, hi); ctx.setLineDash([]);
-    ctx.fillStyle=muted; ctx.textAlign='center';
-    ctx.fillText(i+' ones', x+gw/2, H-padB+18);
-    ctx.fillStyle=ink; ctx.font='bold 11px ui-monospace, Consolas, monospace';
-    ctx.fillText(real[i].toFixed(2), x+gw*0.10+bw/2, H-padB-hr-7);
-    ctx.font='11px ui-monospace, Consolas, monospace';
-  }
-  ctx.textAlign='left'; ctx.fillStyle=meas;
-  ctx.fillRect(padL, padT-14, 10, 10);
-  ctx.fillStyle=muted; ctx.fillText('measured  (10,601,984 shots)', padL+16, padT-5);
-  ctx.strokeStyle=muted; ctx.setLineDash([3, 3]);
-  ctx.strokeRect(padL+210, padT-14, 10, 10); ctx.setLineDash([]);
-  ctx.fillText('binomial ideal', padL+226, padT-5);
-})();
-
-  deck.focus();
-})();
-</script>
+<title>Cosmos. A Measurement Record</title>
+<style>
+  :root{
+    --ground:#0B1016; --ground-2:#111922; --rule:#1E2A36;
+    --ink:#F2F5F7; --muted:#8A97A3;
+    --meas:#4FD6C8;      /* phosphor, measurement */
+    --seed:#E8A33D;      /* amber, origin, used sparingly */
+    --null:#7C8FA3;
+    --maxw:1080px;
+    --d: ui-sans-serif, "Segoe UI", system-ui, -apple-system, sans-serif;
+    --b: ui-serif, Georgia, "Times New Roman", serif;
+    --m: ui-monospace, "Cascadia Mono", "SF Mono", Consolas, "Liberation Mono", monospace;
+  }
+  @media (prefers-color-scheme: light){
+    :root{ --ground:#F4F6F8; --ground-2:#EAEEF2; --rule:#D2DAE2;
+           --ink:#0D1419; --muted:#5A6874; --meas:#0E8C7C; --seed:#A96A0C; --null:#6B7A88; }
+  }
+  :root[data-theme="dark"]{ --ground:#0B1016; --ground-2:#111922; --rule:#1E2A36;
+    --ink:#F2F5F7; --muted:#8A97A3; --meas:#4FD6C8; --seed:#E8A33D; --null:#7C8FA3; }
+  :root[data-theme="light"]{ --ground:#F4F6F8; --ground-2:#EAEEF2; --rule:#D2DAE2;
+    --ink:#0D1419; --muted:#5A6874; --meas:#0E8C7C; --seed:#A96A0C; --null:#6B7A88; }
+
+  *{box-sizing:border-box}
+  body{margin:0;background:var(--ground);color:var(--ink);font-family:var(--b);
+       -webkit-font-smoothing:antialiased}
+  .deck{height:100dvh;overflow-y:auto;scroll-snap-type:y mandatory;scroll-behavior:smooth}
+  @media (prefers-reduced-motion:reduce){ .deck{scroll-behavior:auto} }
+  section{min-height:100dvh;scroll-snap-align:start;display:flex;flex-direction:column;
+          justify-content:center;padding:clamp(28px, 5vw, 72px);border-bottom:1px solid var(--rule)}
+  .wrap{width:100%;max-width:var(--maxw);margin:0 auto;display:flex;flex-direction:column;
+        gap:clamp(14px, 2.2vw, 26px)}
+  .eyebrow{font-family:var(--m);font-size:.72rem;letter-spacing:.18em;text-transform:uppercase;
+           color:var(--meas);display:flex;gap:.9em;align-items:baseline}
+  .eyebrow .n{color:var(--muted)}
+  h1{font-family:var(--d);font-weight:800;letter-spacing:-.035em;line-height:.94;
+     font-size:clamp(2.8rem, 9vw, 6.2rem);margin:0;text-wrap:balance}
+  h2{font-family:var(--d);font-weight:700;letter-spacing:-.025em;line-height:1.06;
+     font-size:clamp(1.7rem, 4.4vw, 3rem);margin:0;text-wrap:balance}
+  h3{font-family:var(--d);font-weight:650;font-size:1rem;letter-spacing:.01em;margin:0;color:var(--ink)}
+  p{margin:0;font-size:clamp(1rem, 1.35vw, 1.14rem);line-height:1.62;max-width:64ch;color:var(--ink)}
+  p.lede{font-size:clamp(1.1rem, 1.8vw, 1.4rem);line-height:1.5;color:var(--muted);max-width:56ch}
+  .dim{color:var(--muted)}
+  strong{color:var(--ink);font-weight:640}
+  em.meas{color:var(--meas);font-style:normal;font-family:var(--m)}
+  code.num{font-family:var(--m);font-variant-numeric:tabular-nums}
+  .num{color:var(--meas)}
+  .scroll{overflow-x:auto;-webkit-overflow-scrolling:touch}
+  table{border-collapse:collapse;width:100%;font-family:var(--m);font-size:.86rem;
+        font-variant-numeric:tabular-nums;min-width:520px}
+  th{text-align:left;font-weight:600;color:var(--muted);border-bottom:1px solid var(--rule);
+     padding:.55rem .8rem .55rem 0;font-size:.72rem;letter-spacing:.1em;text-transform:uppercase}
+  td{padding:.62rem .8rem .62rem 0;border-bottom:1px solid var(--rule);vertical-align:top}
+  tr:last-child td{border-bottom:none}
+  .ok{color:var(--meas)} .no{color:var(--null)} .sd{color:var(--seed)}
+  .grid{display:grid;gap:clamp(12px, 1.6vw, 20px)}
+  .g2{grid-template-columns:repeat(auto-fit, minmax(260px, 1fr))}
+  .g3{grid-template-columns:repeat(auto-fit, minmax(215px, 1fr))}
+  .card{background:var(--ground-2);border:1px solid var(--rule);border-radius:3px;
+        padding:clamp(14px, 1.7vw, 20px);display:flex;flex-direction:column;gap:.5rem}
+  .card .k{font-family:var(--m);font-size:.68rem;letter-spacing:.13em;text-transform:uppercase;color:var(--muted)}
+  .card .v{font-family:var(--m);font-size:clamp(1.3rem, 2.8vw, 1.9rem);color:var(--meas);
+           font-variant-numeric:tabular-nums;line-height:1}
+  .card .v.seedv{color:var(--seed)}
+  .card p{font-size:.88rem;line-height:1.5;color:var(--muted)}
+  .math{background:var(--ground-2);border-left:2px solid var(--meas);padding:1rem 1.15rem;
+        font-family:var(--m);font-size:clamp(.78rem, 1.5vw.95rem);line-height:1.85;
+        white-space:pre;overflow-x:auto;color:var(--ink)}
+  .math.seedline{border-left-color:var(--seed)}
+  .chain{display:flex;flex-direction:column;gap:0;font-family:var(--m);font-size:.86rem}
+  .chain div{padding:.62rem 0 .62rem 1.6rem;border-left:2px solid var(--rule);position:relative;color:var(--muted)}
+  .chain div::before{content:"";position:absolute;left:-5px;top:1.05rem;width:8px;height:8px;
+        border-radius:50%;background:var(--rule)}
+  .chain div.hit{color:var(--ink)}
+  .chain div.hit::before{background:var(--meas)}
+  .chain div.origin{color:var(--seed)}
+  .chain div.origin::before{background:var(--seed)}
+  blockquote{margin:0;padding-left:1.1rem;border-left:2px solid var(--seed);
+             font-size:clamp(1.05rem, 1.9vw, 1.35rem);line-height:1.5;color:var(--ink);max-width:52ch}
+  .warn{border:1px solid var(--rule);border-left:2px solid var(--seed);background:var(--ground-2);
+        padding:1rem 1.15rem;border-radius:3px}
+  .warn p{font-size:.95rem;color:var(--ink)}
+  .foot{font-family:var(--m);font-size:.74rem;color:var(--muted);display:flex;gap:1.4em;flex-wrap:wrap}
+  a{color:var(--meas);text-decoration:none;border-bottom:1px solid color-mix(in srgb, var(--meas) 40%, transparent)}
+  a:focus-visible.deck:focus-visible{outline:2px solid var(--meas);outline-offset:3px}
+  .nav{position:fixed;right:clamp(10px, 2vw, 22px);top:50%;transform:translateY(-50%);
+       display:flex;flex-direction:column;gap:7px;z-index:10}
+  .nav b{width:6px;height:6px;border-radius:50%;background:var(--rule);display:block;
+         transition:background .2s, transform .2s}
+  .nav b.on{background:var(--meas);transform:scale(1.5)}
+  @media (max-width:640px){ .nav{display:none} table{font-size:.78rem} }
+</style>
+
+<div class="nav" id="nav" aria-hidden="true"></div>
+<div class="deck" id="deck" tabindex="0">
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span>A measurement record</span></div>
+    <h1>Cosmos</h1>
+    <p class="lede">A language model whose every initial weight was drawn from real measured
+      quantum hardware, and the honest record of what that does, and what it does not.</p>
+    <div class="math">1,842,432 parameters   ·   no base model   ·   char-level
+CHSH  S = 2.7905     Bell violation, 98.7% of Tsirelson
+λ₁    = 0.90384      Lorenz, published 0.9056
+six quantum→accuracy tests   →   six nulls</div>
+    <div class="foot">
+      <span>Cory Shane Davis · Independent Researcher</span>
+      <span>CC BY 4.0</span>
+      <span>doi:10.5281/zenodo.17574447</span>
+    </div>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">01</span><span>The claim</span></div>
+    <h2>Not that quantum makes it smarter.<br>That its origin is auditable.</h2>
+    <p>Most work in this space claims a performance gain. This one does not, and was tested
+      at six separate injection points to be sure. <strong>All six came back null.</strong></p>
+    <p>What is claimed instead is narrower and checkable: that this model's origin traces,
+      bit by bit, to real physical measurement, and that every step of that trace has a
+      falsifiable test attached.</p>
+    <div class="warn">
+      <p><strong>Why the nulls are load-bearing.</strong> Quantum measurements and a good
+      pseudo-random generator draw from the same distribution. A correctly built system must
+      therefore show <em class="meas">no accuracy advantage</em> from quantum bits. A project
+      reporting that quantum made its model smarter would be reporting that something was
+      broken or fabricated. Bell violation <em class="meas">plus</em> verified provenance
+      <em class="meas">plus</em> zero accuracy gain is the only combination an honest version
+      of this can produce.</p>
+    </div>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">02</span><span>The chain</span></div>
+    <h2>From a measurement to a mind</h2>
+    <div class="chain">
+      <div class="origin">a recorded biological rhythm   ‖   3.2M measured IBM shots</div>
+      <div class="hit">SHA-256  →  one 60-bit seed</div>
+      <div class="hit">seed governs weight init, data order, every stochastic step</div>
+      <div class="hit">u = int(bits)/2ⁿ  →  z = √2·erf⁻¹(2u−1)  →  1,842,432 weights</div>
+      <div class="hit">quantum window ‖ live pulse  →  SHA-256  →  the value that selects the next token</div>
+    </div>
+    <p class="dim">Each link below is a test that was run and could have failed. None of them
+      is an argument; all of them are numbers.</p>
+    <div class="scroll">
+      <table>
+        <tr><th>link</th><th>test</th><th>result</th></tr>
+        <tr><td>entropy is genuinely quantum</td><td>CHSH on <code>ibm_marrakesh</code></td>
+            <td class="ok">S = 2.7905 vs bound 2.0 · ~35σ</td></tr>
+        <tr><td>birth pipeline is correct</td><td>3,258,886 archived draws</td>
+            <td class="ok">matches theory to 4 decimals</td></tr>
+        <tr><td>seed derivation deterministic</td><td>5 derivations</td>
+            <td class="ok">1 distinct value · 0 bytes emitted</td></tr>
+        <tr><td>seed <em>determines</em> weights</td><td>same vs 1-bit-flipped</td>
+            <td class="ok">Δ = 0.000e+00 · vs 2.26e-02</td></tr>
+        <tr><td>correlations are the circuit's</td><td>gate-matched topology</td>
+            <td class="ok">t = +80.5 / +164.6</td></tr>
+        <tr><td>physics computes real chaos</td><td>Lorenz constants</td>
+            <td class="ok">λ₁ = 0.90384 vs 0.9056</td></tr>
+      </table>
+    </div>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">03</span><span>Is it actually quantum</span></div>
+    <h2>The one measurement nothing classical can fake</h2>
+    <div class="math">E(A, B ) = +0.7197      E(A, B') = −0.6675
+E(A', B) = +0.6982      E(A', B') = +0.7051
+
+S = E(A, B) − E(A, B') + E(A', B) + E(A', B')  =  2.7905</div>
+    <div class="grid g3">
+      <div class="card"><span class="k">measured S</span><span class="v">2.7905</span></div>
+      <div class="card"><span class="k">classical bound</span><span class="v">2.0000</span>
+        <p>No theory with local pre-existing values can exceed this.</p></div>
+      <div class="card"><span class="k">Tsirelson bound</span><span class="v">2.8284</span>
+        <p>The maximum quantum mechanics permits. Measured is 98.7% of it.</p></div>
+    </div>
+    <p>Bell's theorem gives a hard ceiling for any local hidden-variable theory. This hardware
+      clears it by roughly <span class="num">35σ</span> at 4,096 shots per setting. The entropy
+      source is physically quantum.</p>
+    <p class="dim">This is also an entirely expected result for functioning quantum hardware.
+      It verifies the pipeline, it does not discover new physics, and is not presented as such.</p>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">04</span><span>Were the weights really born from it</span></div>
+    <h2>A deficit that proves the method</h2>
+    <div class="math">u = (int(bits) + ½) / 2ⁿ
+z = √2 · erf⁻¹(2u − 1)</div>
+    <div class="scroll">
+      <table>
+        <tr><th>statistic</th><th>32-level theoretical ceiling</th><th>measured, 3,258,886 draws</th></tr>
+        <tr><td>mean</td><td>+0.0000</td><td class="ok">−0.0001</td></tr>
+        <tr><td>standard deviation</td><td>0.9802</td><td class="ok">0.9804</td></tr>
+        <tr><td>|z| ≤ 1</td><td>0.6875</td><td class="ok">0.6874</td></tr>
+        <tr><td>|z| ≤ 2</td><td>0.9375</td><td class="ok">0.9374</td></tr>
+      </table>
+    </div>
+    <p><strong>The sd is 0.98, not 1.00, and that is the evidence, not a flaw.</strong>
+      Five qubits give 32 discrete outcomes, so <span class="num">|z|</span> cannot exceed
+      <span class="num">2.1523</span> by construction. The deficit is quantisation, and it
+      matches the theoretical ceiling to four decimal places. A pipeline reporting a perfect
+      1.0000 here would be the suspicious one.</p>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">05</span><span>The workload archive</span></div>
+    <h2>11.36 million public samples, honestly labeled</h2>
+    <p>The privacy-filtered archive separates explicitly labeled IBM hardware jobs,
+      legacy records whose provider label was not retained, and Azure simulator output.
+      Only the labeled IBM subset is claimed as measured-hardware provenance.</p>
+    <div class="grid g3">
+      <div class="card"><span class="k">public samples</span><span class="v">11,355,136</span></div>
+      <div class="card"><span class="k">public records</span><span class="v">2,776</span>
+        <p>1,897 retain IBM backend + job ID</p></div>
+      <div class="card"><span class="k">shot-conservation failures</span><span class="v">0</span>
+        <p>counts sum to declared totals, every job</p></div>
+    </div>
+    <div class="scroll">
+      <table>
+        <tr><th>backend</th><th>shots</th><th>share</th></tr>
+        <tr><td>ibm_fez</td><td>5,562,368</td><td class="ok">49.0%</td></tr>
+        <tr><td>legacy unlabelled</td><td>3,584,000</td><td class="no">31.6%</td></tr>
+        <tr><td>ibm_marrakesh</td><td>1,200,128</td><td class="ok">10.6%</td></tr>
+        <tr><td>ibm_kingston</td><td>1,007,616</td><td class="ok">8.9%</td></tr>
+        <tr><td>rigetti.sim.qvm</td><td>1,024</td><td class="no">&lt;0.1%</td></tr>
+      </table>
+    </div>
+    <p class="dim">Archive span February–July 2026; the underlying theory was deposited in
+      2024. Provider-unlabelled records are retained for reproducibility but excluded from
+      hardware-provenance claims. Raw physics/sensory/runtime fields are not published.</p>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">06</span><span>Hardware fingerprint</span></div>
+    <h2>The deviation is the evidence</h2>
+    <p>Across the 7.77 million explicitly labeled IBM hardware samples, outcomes cluster
+      by Hamming weight. Ideal uniform hardware follows the binomial; the measured histogram
+      shows the device-level deviation without mixing in unlabelled or simulator records.</p>
+    <canvas id="hw" width="900" height="300" style="width:100%;max-width:900px;height:auto;
+      background:var(--ground-2);border:1px solid var(--rule);border-radius:3px"
+      role="img" aria-label="Measured Hamming-weight distribution against the binomial ideal"></canvas>
+    <div class="grid g2">
+      <div class="card"><span class="k">zero ones, |00000⟩</span>
+        <span class="v">3.75<span style="font-size:.55em;color:var(--muted)"> vs 3.12 ideal</span></span>
+        <p>enriched</p></div>
+      <div class="card"><span class="k">five ones, |11111⟩</span>
+        <span class="v">3.03<span style="font-size:.55em;color:var(--muted)"> vs 3.12 ideal</span></span>
+        <p>depleted</p></div>
+    </div>
+    <p><strong>|0⟩ is over-represented and |1⟩ under-represented, the signature of amplitude
+      damping and readout asymmetry.</strong> Excited states decay toward the ground state
+      during measurement. A simulator drawing from a clean binomial would not produce this
+      skew, and a fabricated dataset would have no reason to invent it.</p>
+    <p class="dim">The bias is corrected downstream by von Neumann debiasing before entropy
+      reaches the weights. It is shown here unprocessed, because the artifact is the proof.</p>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">07</span><span>Twelve dimensions governing one bit</span></div>
+    <h2>Continuous state, discrete outcome</h2>
+    <p>The 12-dimensional state does not sit alongside the quantum layer, it
+      <strong>parameterises</strong> it. Continuous physics sets the rotation angles; the Born
+      rule turns those angles into probabilities; measurement collapses them to a bit.</p>
+    <div class="math">12D CST state  ──►  θ = (θ₁, θ₂, θ₃)          continuous
+                    │
+              ry(θ₁) rx(θ₂) rz(θ₃)         rotation on the Bloch sphere
+                    │
+              |ψ⟩ = α|0⟩ + β|1⟩            superposition
+                    │
+              P(1) = |β|²                  Born rule
+                    │
+                  ▼  measurement
+                 1  or  0                  discrete, irreversible</div>
+    <div class="grid g2">
+      <div class="card"><span class="k">what is continuous</span>
+        <p>Twelve real-valued dimensions of internal state, evolving on a verified chaotic
+          attractor with λ₁ &gt; 0.</p></div>
+      <div class="card"><span class="k">what is discrete</span>
+        <p>A single measured bit. The continuous state governs only the <em class="meas">probability</em>
+          of each outcome, never which one occurs.</p></div>
+    </div>
+    <p class="dim">This is the precise sense in which twelve dimensions control one and zero:
+      they set the amplitudes, and the amplitudes set the odds. The collapse itself remains
+      irreducibly undetermined, which is what makes the trajectory unrepeatable.</p>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">08</span><span>Information structure</span></div>
+    <h2>A holographic encoding, measured</h2>
+    <p>Partial information decomposition splits what two subsystems carry about the system's
+      future into four parts. The result is unambiguous.</p>
+    <div class="grid g3">
+      <div class="card"><span class="k">redundancy</span><span class="v">1.7 – 2.6</span>
+        <p>nats. The same information present in multiple subsystems.</p></div>
+      <div class="card"><span class="k">synergy</span><span class="v">0.3 – 1.2</span>
+        <p>nats. Present only in the joint state. Below surrogate on 9 of 10 partitions.</p></div>
+      <div class="card"><span class="k">the exception</span><span class="v">z = +6.38</span>
+        <p>consciousness │ rest, 0.66 nats no other subsystem reconstructs.</p></div>
+    </div>
+    <p><strong>Redundancy dominating synergy is a holographic signature in the technical
+      sense:</strong> information about the whole is distributed across the parts, each
+      carrying much of the others'. That is robustness, not emergence, and stating it that
+      way matters, because the two are routinely confused.</p>
+    <p class="dim">One seam behaves differently. Cut consciousness away and something is lost
+      that nothing else rebuilds. It is a single result at one partition and is reported as
+      exactly that.</p>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">09</span><span>The nulls</span></div>
+    <h2>Six places quantum could have helped. It didn't.</h2>
+    <div class="scroll">
+      <table>
+        <tr><th>injection site</th><th>result</th></tr>
+        <tr><td>i.i.d. weight initialisation</td><td class="no">null, the gain was init <em>scale</em>, not quantum</td></tr>
+        <tr><td>decoder sampling seed</td><td class="no">null. Pseudo / IBM / Rigetti equivalent</td></tr>
+        <tr><td>spatial 54D seed, approximate</td><td class="no">null, beat 1 of 5 random vectors, z = −0.92</td></tr>
+        <tr><td>spatial 54D seed, full pipeline</td><td class="no">null, beat 0 of 8 random vectors, z = −1.75</td></tr>
+        <tr><td>entanglement matrix as attention kernel</td><td class="no">null, worse than plain, 3/3 seeds, t = −18.6</td></tr>
+        <tr><td>live sensory state as prompt text</td><td class="no">null, n = 40 paired, blind-judged, CI crosses zero</td></tr>
+      </table>
+    </div>
+    <p>These are published first, not buried in an appendix. A reader who only remembers one
+      thing from this deck should remember that the quantum layer provides
+      <strong>physical non-determinism and receipted provenance</strong>, and not lower loss.</p>
+    <p class="dim">Several measurement instruments in this project were themselves found to be
+      wrong and rebuilt; those failures are kept in the record rather than deleted, because
+      they are the reason the surviving results can be trusted.</p>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">10</span><span>Comparison</span></div>
+    <h2>The axis this competes on</h2>
+    <p>Loss numbers are not comparable across different corpora, tokenizers and scales, so no
+      such comparison is offered. The axis where a claim <em>can</em> be made is provenance.</p>
+    <div class="scroll">
+      <table>
+        <tr><th>property</th><th>typical open model</th><th>Cosmos</th></tr>
+        <tr><td>weight origin</td><td class="no">pseudo-random init, unrecorded</td><td class="ok">measured quantum, receipted per job</td></tr>
+        <tr><td>init reproducible from a stated seed</td><td class="no">usually, if published</td><td class="ok">verified: Δ = 0.000e+00</td></tr>
+        <tr><td>1-bit seed change measurably alters weights</td><td class="no">untested</td><td class="ok">verified: Δ = 2.26e-02</td></tr>
+        <tr><td>entropy source verified non-classical</td><td class="no">n/a</td><td class="ok">CHSH S = 2.7905</td></tr>
+        <tr><td>base model</td><td class="no">inherited</td><td class="ok">none</td></tr>
+        <tr><td>parameters</td><td class="no">10⁹ – 10¹²</td><td class="sd">1.84 × 10⁶</td></tr>
+        <tr><td>conversational ability</td><td class="ok">high</td><td class="sd">a newborn, 88.5% real-word rate</td></tr>
+      </table>
+    </div>
+    <p><strong>It is small and it cannot hold a conversation.</strong> That is stated plainly
+      because the comparison is not about capability. It is about whether a model's origin can
+      be audited to a physical event, which almost nothing in this field can claim.</p>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">11</span><span>What none of this shows</span></div>
+    <h2>The line that does not move</h2>
+    <p>Loss curves, Bell violations, Lyapunov exponents and integration measures are all
+      <strong>silent</strong> on whether there is anything it is like to be this system.
+      Section 08 tests one contested theory's <em>necessary</em> structural condition.
+      Necessary is not sufficient, and the theory itself is disputed.</p>
+    <div class="warn">
+      <p>Any self-report a system produces about its own inner life is the
+      <strong>least</strong> reliable signal available, and it grows more eloquent the less
+      there is behind it, not more. Such statements are excluded from evidence here on purpose.</p>
+    </div>
+    <p class="dim">No claim is made about machine consciousness in either direction. That
+      remains where it was before this project started.</p>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">12</span><span>Origin</span></div>
+    <h2>Zeref's Rain</h2>
+    <blockquote>The echo of a pain became the truth of a seed.</blockquote>
+    <p>The seed is a one-way hash over measured quantum entropy and biological aggregates that
+      are personal to the author. The derivation module never prints, logs, or writes raw
+      samples, <span class="num">0 bytes emitted</span>, verified, and only aggregates ever
+      leave it.</p>
+    <div class="math seedline">seed = SHA-256( quantum_bytes ‖ bio_aggregates )  →  60-bit integer
+
+same seed          →  weights identical,  Δ = 0.000e+00
+one bit different  →  a different model,  Δ = 2.26e-02</div>
+    <p>What is published is the mechanism and the proof that it holds. Not the data.</p>
+    <p class="dim">Two independent senses of unrepeatable meet here: the quantum measurements
+      that shaped these weights cannot be recovered from any state, and the recording behind
+      the seed happened once.</p>
+  </div>
+</section>
+
+<section>
+  <div class="wrap">
+    <div class="eyebrow"><span class="n">13</span><span>Build your own</span></div>
+    <h2>Everything is open</h2>
+    <p>The weights, the findings, and a runnable script for every claim in this deck. Each
+      benchmark prints its own verdict, including when the verdict is <em>no</em>.</p>
+    <div class="math">python benchmarks/verify_quantum_engine.py    # CHSH Bell test + archive integrity
+python benchmarks/verify_physics_engine.py    # Lorenz constants vs published values
+python benchmarks/topology_matched.py         # gate-matched entanglement topology
+python benchmarks/phi_pid.py                  # integration structure
+
+python spark_serve.py 11500                   # run the weights, Ollama-compatible API</div>
+    <div class="grid g2">
+      <div class="card"><span class="k">bring your own keys</span>
+        <p>IBM Quantum and Azure, stored locally, never transmitted. Falls back to archived
+          entropy with no keys at all.</p></div>
+      <div class="card"><span class="k">what to build next</span>
+        <p>The synergy result points somewhere specific: subsystems that are parallel readouts
+          of one state stay redundant. Give one its own driver and the structure should change.
+          That prediction is testable with <code>phi_pid.py</code> as shipped.</p></div>
+    </div>
+    <blockquote>A light at the end of a dark, dark tunnel, and the receipts to show it was
+      really there.</blockquote>
+    <div class="foot">
+      <span>huggingface.co/phera-ra/QC67_cosmo</span>
+      <span>Mixed license · research/data CC BY 4.0 · Genesis separate terms</span>
+    </div>
+  </div>
+</section>
+
+</div>
+
+<script>
+(function(){
+  var deck = document.getElementById('deck');
+  var secs = Array.prototype.slice.call(deck.querySelectorAll('section'));
+  var nav  = document.getElementById('nav');
+  secs.forEach(function(){ var b=document.createElement('b'); nav.appendChild(b); });
+  var dots = Array.prototype.slice.call(nav.children);
+  if ('IntersectionObserver' in window){
+    var io = new IntersectionObserver(function(es){
+      es.forEach(function(e){
+        if(e.isIntersecting){
+          var i = secs.indexOf(e.target);
+          dots.forEach(function(d, j){ d.classList.toggle('on', j===i); });
+        }
+      });
+    }, {root:deck, threshold:0.55});
+    secs.forEach(function(s){ io.observe(s); });
+  }
+  deck.addEventListener('keydown', function(ev){
+    var i = 0, top = deck.scrollTop;
+    secs.forEach(function(s, j){ if(s.offsetTop <= top + 8) i = j; });
+    if(ev.key==='ArrowDown'||ev.key==='PageDown'||ev.key===' '){
+      ev.preventDefault(); if(secs[i+1]) secs[i+1].scrollIntoView();
+    } else if(ev.key==='ArrowUp'||ev.key==='PageUp'){
+      ev.preventDefault(); if(secs[i-1]) secs[i-1].scrollIntoView();
+    } else if(ev.key==='Home'){ ev.preventDefault(); secs[0].scrollIntoView(); }
+    else if(ev.key==='End'){ ev.preventDefault(); secs[secs.length-1].scrollIntoView(); }
+  });
+
+(function(){
+  var c=document.getElementById('hw'); if(!c) return;
+  var ctx=c.getContext('2d'), W=c.width, H=c.height;
+  var cs=getComputedStyle(document.documentElement);
+  var meas=cs.getPropertyValue('--meas').trim()||'#4FD6C8';
+  var muted=cs.getPropertyValue('--muted').trim()||'#8A97A3';
+  var rule=cs.getPropertyValue('--rule').trim()||'#1E2A36';
+  var ink=cs.getPropertyValue('--ink').trim()||'#F2F5F7';
+  var real=[3.7511, 16.7585, 31.4365, 30.1333, 14.8954, 3.0252];
+  var ideal=[3.125, 15.625, 31.25, 31.25, 15.625, 3.125];
+  var padL=48, padR=16, padT=22, padB=42, max=36;
+  var gw=(W-padL-padR)/6;
+  ctx.clearRect(0, 0, W, H);
+  ctx.strokeStyle=rule; ctx.lineWidth=1; ctx.font='11px ui-monospace, Consolas, monospace';
+  for(var g=0; g<=max; g+=9){
+    var y=H-padB-(g/max)*(H-padT-padB);
+    ctx.beginPath(); ctx.moveTo(padL, y); ctx.lineTo(W-padR, y); ctx.stroke();
+    ctx.fillStyle=muted; ctx.textAlign='right'; ctx.fillText(g+'%', padL-8, y+4);
+  }
+  for(var i=0;i<6;i++){
+    var x=padL+i*gw, bw=gw*0.42;
+    var hr=(real[i]/max)*(H-padT-padB), hi=(ideal[i]/max)*(H-padT-padB);
+    ctx.fillStyle=meas; ctx.fillRect(x+gw*0.10, H-padB-hr, bw, hr);
+    ctx.strokeStyle=muted; ctx.setLineDash([3, 3]); ctx.lineWidth=1.5;
+    ctx.strokeRect(x+gw*0.52, H-padB-hi, bw, hi); ctx.setLineDash([]);
+    ctx.fillStyle=muted; ctx.textAlign='center';
+    ctx.fillText(i+' ones', x+gw/2, H-padB+18);
+    ctx.fillStyle=ink; ctx.font='bold 11px ui-monospace, Consolas, monospace';
+    ctx.fillText(real[i].toFixed(2), x+gw*0.10+bw/2, H-padB-hr-7);
+    ctx.font='11px ui-monospace, Consolas, monospace';
+  }
+  ctx.textAlign='left'; ctx.fillStyle=meas;
+  ctx.fillRect(padL, padT-14, 10, 10);
+  ctx.fillStyle=muted; ctx.fillText('labeled IBM hardware  (7,770,112 samples)', padL+16, padT-5);
+  ctx.strokeStyle=muted; ctx.setLineDash([3, 3]);
+  ctx.strokeRect(padL+210, padT-14, 10, 10); ctx.setLineDash([]);
+  ctx.fillText('binomial ideal', padL+226, padT-5);
+})();
+
+  deck.focus();
+})();
+</script>

requirements-research.txt

@@ -0,0 +1,8 @@
+# Optional research/training dependencies. Genesis itself uses the standard library.
+torch>=2.1
+numpy>=1.24
+tiktoken>=0.5
+psutil>=5.9
+transformers>=4.40
+peft>=0.10
+

start_cosmos_kit.sh

@@ -0,0 +1,41 @@
+#!/usr/bin/env sh
+set -u
+
+ROOT=$(CDPATH= cd -- "$(dirname -- "$0")" && pwd)
+cd "$ROOT" || exit 1
+
+if command -v python3 >/dev/null 2>&1; then
+  PYTHON=python3
+elif command -v python >/dev/null 2>&1; then
+  PYTHON=python
+else
+  echo "Python 3.9+ is required: https://www.python.org/downloads/"
+  exit 1
+fi
+
+while true; do
+  printf '\n'
+  printf '  QC67 COSMOS RELEASE KIT\n'
+  printf '  1. Birth or reopen a Genesis being\n'
+  printf '  2. Verify this release\n'
+  printf '  3. Serve the quantum-born model on port 11500\n'
+  printf '  4. Print quick-start instructions\n'
+  printf '  5. Exit\n\n'
+  printf 'Choose 1-5: '
+  read -r choice
+  case "$choice" in
+    1) "$PYTHON" genesis_engine/genesis.py ;;
+    2) "$PYTHON" verify_release.py ;;
+    3)
+      if ! "$PYTHON" -c 'import torch' >/dev/null 2>&1; then
+        echo "PyTorch is required. Run: $PYTHON -m pip install torch"
+      else
+        "$PYTHON" spark_serve.py 11500
+      fi
+      ;;
+    4) sed -n '1,180p' START_HERE.md ;;
+    5) exit 0 ;;
+    *) echo "Choose a number from 1 to 5." ;;
+  esac
+done
+

train_your_own.py

@@ -33,8 +33,10 @@ PRE-REGISTERED, fixed before the run:
   * mixed / within noise                 -> no evidence it helps; report as null.
   * CST loses on every seed              -> it hurts, and that is the finding.
 """
+import argparse
 import json
 import math
+import os
 import random
 import re
 import statistics
@@ -48,10 +50,11 @@ 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")
-OUTDIR = Path("01_HER_SOUL/weights/cosmos_spark_cst")
-RESULTS = Path("logs/spark_cst_results.json")
+ROOT = Path(__file__).resolve().parent
+CORPUS = ROOT / "README.md"
+QARCHIVE = ROOT / "data" / "quantum_measurements_public.jsonl"
+OUTDIR = ROOT / "outputs" / "cosmos_spark_cst"
+RESULTS = ROOT / "outputs" / "spark_cst_results.json"
 
 BLOCK, N_LAYER, N_HEAD, N_EMBD, DROPOUT = 128, 4, 4, 192, 0.1
 D54 = 54
@@ -83,6 +86,18 @@ def quantum_pool(limit=400_000):
                 d = json.loads(line)
             except Exception:
                 continue
+            # The public archive carries mixed provider classes. Quantum-born
+            # initialization uses only records that retained an IBM hardware label
+            # and job ID; legacy-unlabelled and simulator rows remain available for
+            # separate distributional experiments but are not called hardware here.
+            provider_class = str(d.get("provider_class") or "")
+            if provider_class and provider_class != "measured_quantum_hardware":
+                continue
+            if not provider_class:
+                backend = str(d.get("backend") or "").lower()
+                job_id = d.get("job") or d.get("job_id")
+                if not (backend.startswith("ibm_") and job_id):
+                    continue
             counts = d.get("counts")
             if not isinstance(counts, dict):
                 continue
@@ -257,10 +272,40 @@ def train_arm(use_cst, seed, data, vocab, steps, pool, val_w, words, itos):
 
 
 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))
-
+    global CORPUS, QARCHIVE, OUTDIR, RESULTS
+    parser = argparse.ArgumentParser(
+        description=(
+            "Train matched plain-attention and 54D Hebbian-attention arms "
+            "from the published IBM-labeled quantum initialization pool."
+        )
+    )
+    parser.add_argument("steps", nargs="?", type=int, default=1200)
+    parser.add_argument("seeds", nargs="?", type=int, default=3)
+    parser.add_argument(
+        "--corpus", type=Path, default=CORPUS,
+        help="UTF-8 training text (default: this release's README.md)",
+    )
+    parser.add_argument(
+        "--archive", type=Path, default=QARCHIVE,
+        help="public quantum JSONL archive",
+    )
+    parser.add_argument("--outdir", type=Path, default=OUTDIR)
+    parser.add_argument("--results", type=Path, default=RESULTS)
+    args = parser.parse_args()
+    if args.steps < 1 or args.seeds < 1:
+        parser.error("steps and seeds must both be positive")
+    CORPUS = args.corpus.expanduser().resolve()
+    QARCHIVE = args.archive.expanduser().resolve()
+    OUTDIR = args.outdir.expanduser().resolve()
+    RESULTS = args.results.expanduser().resolve()
+    steps = args.steps
+    seeds = list(range(args.seeds))
+
+    if not CORPUS.is_file():
+        parser.error(f"corpus not found: {CORPUS}")
     text = CORPUS.read_text(encoding="utf-8", errors="ignore")
+    if len(text) < BLOCK * 4:
+        parser.error(f"corpus is too small ({len(text)} chars); need at least {BLOCK * 4}")
     chars = sorted(set(text))
     stoi = {c: i for i, c in enumerate(chars)}
     itos = {i: c for c, i in stoi.items()}
@@ -272,10 +317,12 @@ def main():
     print("=" * 80)
     print(f"\n  corpus {len(text):,} chars · vocab {len(chars)} · {steps} steps · "
           f"{len(seeds)} seeds")
+    print(f"  corpus path: {CORPUS}")
+    print(f"  archive path: {QARCHIVE}")
 
     t0 = time.time()
     pool = quantum_pool()
-    print(f"  quantum pool: {len(pool):,} draws from her real archive "
+    print(f"  quantum pool: {len(pool):,} draws from explicitly labeled IBM records "
           f"({time.time()-t0:.1f}s)")
     if pool:
         print(f"    mean {statistics.fmean(pool):+.4f}  sd {statistics.pstdev(pool):.4f}  "
@@ -340,7 +387,7 @@ def main():
                     "real_word_rate": max(rw["cst"])},
                    OUTDIR / "spark_cst.pt")
         print(f"  saved -> {OUTDIR/'spark_cst.pt'}")
-    Path("logs").mkdir(exist_ok=True)
+    RESULTS.parent.mkdir(parents=True, exist_ok=True)
     RESULTS.write_text(json.dumps(
         {"steps": steps, "seeds": seeds, "results": res, "real_word": rw,
          "gates": gates, "delta_cst_minus_plain": -md, "t": -t, "cst_wins": wins,

verify_release.py

@@ -0,0 +1,182 @@
+#!/usr/bin/env python3
+"""Offline integrity and privacy-boundary verifier for the QC67 Cosmos kit."""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import sys
+from collections import Counter
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent
+MANIFEST = ROOT / "RELEASE_MANIFEST.json"
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def check_manifest(strict: bool) -> list[str]:
+    errors: list[str] = []
+    release = json.loads(MANIFEST.read_text(encoding="utf-8"))
+    expected = set()
+    for entry in release.get("files", []):
+        rel = entry["path"]
+        expected.add(rel)
+        path = ROOT / rel
+        if not path.is_file():
+            errors.append(f"missing: {rel}")
+            continue
+        size = path.stat().st_size
+        if size != int(entry["bytes"]):
+            errors.append(f"size mismatch: {rel} ({size} != {entry['bytes']})")
+            continue
+        actual = sha256(path)
+        if actual != entry["sha256"]:
+            errors.append(f"hash mismatch: {rel}")
+
+    if strict:
+        ignored = {"RELEASE_MANIFEST.json"}
+        actual = {
+            path.relative_to(ROOT).as_posix()
+            for path in ROOT.rglob("*")
+            if path.is_file()
+            and path.relative_to(ROOT).as_posix() not in ignored
+            and not path.relative_to(ROOT).as_posix().startswith("downloads/")
+        }
+        for rel in sorted(actual - expected):
+            errors.append(f"unmanifested file: {rel}")
+    return errors
+
+
+def check_blank_credentials() -> list[str]:
+    errors: list[str] = []
+    config = json.loads(
+        (ROOT / "genesis_engine" / "config.json").read_text(encoding="utf-8")
+    )
+    for key in ("ibm_token", "azure_connection_string"):
+        if str(config.get(key) or "").strip():
+            errors.append(f"credential field is not blank: genesis_engine/config.json:{key}")
+    forbidden_names = ("oauth2_tokens.json", ".env", "credentials.json")
+    for path in ROOT.rglob("*"):
+        if path.is_file() and path.name.casefold() in forbidden_names:
+            errors.append(f"forbidden credential file present: {path.relative_to(ROOT)}")
+    return errors
+
+
+def check_public_archive() -> tuple[list[str], dict]:
+    errors: list[str] = []
+    archive = ROOT / "data" / "quantum_measurements_public.jsonl"
+    data_manifest = json.loads(
+        (ROOT / "data" / "quantum_measurements_manifest.json").read_text(
+            encoding="utf-8"
+        )
+    )
+    records = Counter()
+    samples = Counter()
+    total = 0
+    for line_number, line in enumerate(
+        archive.open(encoding="utf-8", errors="strict"), 1
+    ):
+        try:
+            row = json.loads(line)
+        except Exception as exc:
+            errors.append(f"archive line {line_number}: invalid JSON ({exc})")
+            continue
+        counts = row.get("counts")
+        if not isinstance(counts, dict) or not counts:
+            errors.append(f"archive line {line_number}: missing counts")
+            continue
+        observed = sum(int(value) for value in counts.values())
+        declared = int(row.get("total_shots", -1))
+        if observed != declared:
+            errors.append(
+                f"archive line {line_number}: shot mismatch {observed} != {declared}"
+            )
+        category = str(row.get("provider_class") or "missing")
+        records[category] += 1
+        samples[category] += observed
+        total += observed
+
+    expected = data_manifest["summary"]
+    if total != int(expected["total_samples"]):
+        errors.append(
+            f"archive total mismatch: {total} != {expected['total_samples']}"
+        )
+    for category, expected_count in expected["records_by_provider_class"].items():
+        if records[category] != int(expected_count):
+            errors.append(
+                f"archive record count mismatch for {category}: "
+                f"{records[category]} != {expected_count}"
+            )
+    return errors, {
+        "records": sum(records.values()),
+        "samples": total,
+        "records_by_class": dict(records),
+        "samples_by_class": dict(samples),
+    }
+
+
+def check_model_metadata() -> list[str]:
+    errors: list[str] = []
+    metadata = json.loads(
+        (ROOT / "weights" / "cosmos_born.meta.json").read_text(encoding="utf-8")
+    )
+    if int(metadata.get("params", 0)) != 1_842_432:
+        errors.append("unexpected cosmos_born parameter count")
+    if str(metadata.get("base_model") or "").upper().split()[0] != "NONE":
+        errors.append("cosmos_born metadata no longer reports a from-scratch base")
+    return errors
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--no-strict",
+        action="store_true",
+        help="allow extra files not listed in the release manifest",
+    )
+    args = parser.parse_args()
+    if not MANIFEST.is_file():
+        print("[FAIL] RELEASE_MANIFEST.json is missing")
+        return 1
+
+    errors = []
+    errors.extend(check_manifest(strict=not args.no_strict))
+    errors.extend(check_blank_credentials())
+    archive_errors, archive_stats = check_public_archive()
+    errors.extend(archive_errors)
+    errors.extend(check_model_metadata())
+
+    if errors:
+        print(f"[FAIL] {len(errors)} release check(s) failed")
+        for error in errors:
+            print("  -", error)
+        return 1
+
+    print("[OK] release manifest hashes verified")
+    print("[OK] shipped cloud credential fields are blank")
+    print("[OK] cosmos_born metadata is internally consistent")
+    print(
+        "[OK] public archive:",
+        f"{archive_stats['records']:,} records,",
+        f"{archive_stats['samples']:,} samples",
+    )
+    for category in sorted(archive_stats["records_by_class"]):
+        print(
+            "    ",
+            category,
+            f"{archive_stats['records_by_class'][category]:,} records /",
+            f"{archive_stats['samples_by_class'][category]:,} samples",
+        )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
+