Super-squash branch 'main' using huggingface_hub

.gitattributes

@@ -0,0 +1,39 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+lineages/corrected-20260930/recovery/data/language_baseline/vocab_sparse.json filter=lfs diff=lfs merge=lfs -text
+lineages/corrected-20260930/recovery/data/slots/speech_align.nysv filter=lfs diff=lfs merge=lfs -text
+lineages/corrected-20260930-v2/recovery/data/language_baseline/vocab_sparse.json filter=lfs diff=lfs merge=lfs -text
+lineages/corrected-20260930-v2/recovery/data/slots/speech_align.nysv filter=lfs diff=lfs merge=lfs -text

PROGRAM_CHARTER.md

@@ -0,0 +1,246 @@
+# Seven-Model and Genesis Program Charter
+
+Charter version: 1.0
+
+Effective date: 2026-08-08
+
+Status: authoritative cross-repository direction
+
+Canonical copy: <https://github.com/dakuwonmoody-lab/EsoM/blob/main/PROGRAM_CHARTER.md>
+
+## Read this first
+
+This charter exists so work in one repository does not lose the direction of the
+whole program.
+
+The program is building one AI business with seven selectable model families:
+**BulmaX, Beerus, NYS, AXIOM, Mech, EsoM, and WHIS**. They are not seven personas on
+one hidden model. Each is a distinct attempt to build useful intelligence from a
+different computational substrate.
+
+**Genesis is not an eighth model.** Genesis is the long-term hardware compute-
+substrate program intended to discover, falsify, and eventually embody new
+computational principles in non-CUDA physical hardware.
+
+Anyone—human or agent—working in any participating repository must preserve these
+identities and boundaries unless an explicit cross-program decision changes this
+charter.
+
+## Mission
+
+Within one outside-user-oriented product, a user should be able to select any of the
+seven models and interact with that model's real native computation. The models may
+have very different maturity, fluency, latency, memory, and availability. Those
+differences must be visible rather than hidden.
+
+The long-term ambition is not a conventional weak-to-strong size ladder. It is a
+catalog of genuinely different kinds of machine intelligence sharing one product
+surface, account system, safety boundary, and business identity.
+
+## The seven model theses
+
+| Model | Durable architectural thesis | Intended character when mature |
+|---|---|---|
+| **BulmaX** | Adaptive multimodal autoregressive neural generation | Broad, fluent generalist |
+| **Beerus** | Recurrent byte processing coupled to a growing, locally regulated swarm cortex | Continuous, adaptive streaming intelligence |
+| **NYS** | Learned oscillator coupling and thermodynamic phase dynamics | Associative, resonant conceptual exploration |
+| **AXIOM** | Exact causal uncertainty, interventions, and reversible machine embodiment | Investigative machine scientist |
+| **Mech** | Compiled knowledge graphs, explicit rules, retrieval, and deterministic proofs | Precise librarian-logician |
+| **EsoM** | A self-enciphering `.mal` organism with native memory, search, and gated mutation | Persistent executable organism |
+| **WHIS** | Quality-diversity evolution over populations, niches, and lineage | Discovery collective producing diverse strategies |
+
+These theses are durable. Their present implementations are not sacred.
+
+A checkpoint, mechanism, trainer, representation, scale plan, or implementation
+branch may be disproved, archived, or replaced. A failed route is useful when its
+claim, controls, evidence, and failure are preserved. The program does not keep a
+route alive merely because it consumed substantial time or money.
+
+## Genesis hardware thesis
+
+Genesis begins before hardware, compilers, runtimes, and models because it is trying
+to derive a compute model from first principles rather than inherit every CPU/GPU
+assumption.
+
+Its discovery track proposes candidate computational phenomena. Its falsification
+track tries to eliminate artifacts, confounds, and false interpretations. Principles
+that survive may become software primitives, instructions, compiler/runtime
+semantics, RTL, FPGA implementations, and eventually physical hardware designed in
+KiCad.
+
+The stated staged target is a non-CUDA compute architecture capable of running and
+training BulmaX through a host-CPU, reference-GPU, and Genesis-hardware system. The
+first proposed integration is deliberately narrow: validate exact persistent
+attention/KV-state behavior in software before FPGA offload. Other operations move
+only after Genesis earns the necessary arithmetic, memory, learning, and correctness
+primitives.
+
+Genesis experiments are therefore neither side quests nor the final product. They
+are the evidence pipeline for deciding what deserves embodiment in a new physical
+compute substrate.
+
+## Non-negotiable product boundaries
+
+### 1. The selected model owns the answer
+
+A shared gateway may authenticate, route, enforce budgets, resolve permissions, and
+format envelopes. It may not secretly replace the selected model's cognition.
+
+A model-specific parser or renderer may express a native result, but it must not
+invent the substantive reasoning that the named substrate did not perform.
+
+### 2. Fallback is explicit
+
+If one model cannot answer, it may abstain or request another named model. Automatic
+fallback is allowed only with prior user consent. Every response preserves both the
+requested model and the model that actually answered.
+
+Another model's output must never be presented as though the selected model produced
+it.
+
+### 3. Retrieval remains model-native
+
+Repositories may share source storage, permissions, document identifiers, and
+provenance infrastructure. Each model must still ingest retrieved material in a
+form its own substrate can use and must own the inference that follows.
+
+Retrieval finding the answer outside the substrate is not evidence that the model
+can reason about it.
+
+### 4. Native state is isolated
+
+Each model owns a separate state namespace, schema, reset rule, persistence rule,
+and rollback boundary. Neural memory, swarm topology, oscillator phase, causal
+quotients, fact graphs, `.mal` arenas, and evolutionary archives are not one
+interchangeable database.
+
+Cross-model transfer is allowed only through an explicit, typed, consented,
+provenance-carrying artifact. It counts as learning only when the receiving model
+can ingest it into native state and a before/after evaluation demonstrates a useful,
+retained, reversible change.
+
+### 5. Capability claims require native evidence
+
+Code presence is not capability evidence. Checkpoint existence is not intelligence
+evidence. Lower loss is not automatically product progress. A bounded task does not
+establish open-domain generalization.
+
+Consequential experiments should predeclare the claim, baseline, metric, minimum
+useful effect, resource ceiling, stop rule, artifact destination, and pass/fail
+decision. Evaluations default to native-only execution so fallback cannot conceal a
+failure.
+
+### 6. State changes and actions are permissioned
+
+Persistent learning, self-modification, tool use, experiments, hardware actions,
+and archive evolution require explicit permissions, resource ceilings, logs, and
+rollback where possible. Outside-user access must begin narrowly and honestly.
+
+### 7. Backups and provenance are part of the architecture
+
+Important source, checkpoints, experiment manifests, negative results, and lineage
+must be committed or stored in their declared durable home. A result that cannot be
+reconstructed from named revisions and artifacts should not guide an expensive next
+step.
+
+## Shared product direction
+
+All seven models should eventually be reachable through one versioned request and
+response protocol, one model registry, and one outside-user-oriented chat surface.
+The shared membrane is infrastructure, not another intelligence.
+
+The first protocol implementation lives in EsoM under `src/model_family/` and is
+documented at:
+
+<https://github.com/dakuwonmoody-lab/EsoM/blob/main/docs/MODEL_PROTOCOL_V1.md>
+
+It requires explicit requested/answering model attribution, native evidence,
+state ownership, retrieval receipts, fallback receipts, resource budgets, and
+truthful availability. No adapter should be marked online until it has an exact
+runtime revision and passes conformance.
+
+## Compute direction
+
+Progress is required across all seven model programs, but compute spending is not
+equal.
+
+- CPU-appropriate architecture, evaluation, protocol, and product work continues
+  even when accelerators are unavailable.
+- Beerus and NYS use opportunistic accelerators only when a predeclared experiment
+  justifies them.
+- Full-current-configuration BulmaX work uses funded B200-class campaigns. BulmaX
+  maintains a separate no-B200 queue for evaluation design, data audits, inference,
+  serving, recovery, controls, and run preparation.
+- Every expensive run begins with a decision-changing run card and ends with
+  portable artifacts and frozen probes, not only a newer step number.
+- Genesis hardware work proceeds only after software and reference-hardware gates
+  establish correctness and value.
+
+## Repository responsibilities
+
+Every participating repository owns its native architecture, local tests, evidence,
+state semantics, and failure history. Cross-repository product code must not erase
+those responsibilities.
+
+Before substantial work begins, identify:
+
+1. which model or Genesis thesis the work advances;
+2. the exact current route under test;
+3. the next falsifiable claim or native product rung;
+4. the baseline or control;
+5. the durable artifact destination; and
+6. what result will cause continuation, revision, pause, or archival.
+
+Meaningful progress includes a measured capability gain, a native end-to-end rung,
+a reliability improvement with evidence, a decisive ablation, or a negative result
+that eliminates a plausible route. Activity alone is not progress.
+
+## Immediate program priorities
+
+- **Shared product:** turn protocol v1 into a thin gateway and seven conforming
+  adapters with truthful availability.
+- **BulmaX:** characterize the current checkpoint and make the next B200 campaign
+  decisive.
+- **Beerus:** freeze Swarm-Cortex as the canonical identity and prove the swarm adds
+  value beyond the conv/GRU backbone.
+- **NYS:** align sparse inference with the current sparse trainer and test ordered
+  language plus phase ablations.
+- **AXIOM:** finish A2 acceptance and the falsification/discovery campaign before
+  broad language work.
+- **Mech:** turn saved open-domain failures into regressions and win a curated domain
+  through correctness, provenance, and calibrated unknowns.
+- **EsoM:** resolve or redesign the re-entrant composition route while keeping
+  answer-producing cognition inside `.mal`.
+- **WHIS:** prove archive diversity improves a predeclared downstream consumer.
+- **Genesis:** continue falsification-led principle discovery while protecting the
+  staged bridge from software reference to FPGA and physical compute.
+
+## Canonical detailed documents
+
+- Architecture and evidence audit:
+  <https://github.com/dakuwonmoody-lab/EsoM/blob/main/docs/MODEL_FAMILY_ARCHITECTURE.md>
+- One-year execution roadmap:
+  <https://github.com/dakuwonmoody-lab/EsoM/blob/main/docs/SEVEN_MODEL_EXECUTION_ROADMAP.md>
+- Shared protocol v1:
+  <https://github.com/dakuwonmoody-lab/EsoM/blob/main/docs/MODEL_PROTOCOL_V1.md>
+- Genesis hardware direction:
+  <https://github.com/dakuwonmoody-lab/genesis-computing/blob/main/README.md>
+- Genesis staged hybrid architecture:
+  <https://github.com/dakuwonmoody-lab/genesis-computing/blob/main/HYBRID_ARCHITECTURE.md>
+
+Repository-local specifications override the detailed implementation mechanics for
+their substrate. They do not silently override this cross-program product direction.
+
+## Synchronization rule
+
+`PROGRAM_CHARTER.md` is mirrored at the root of every active source repository and
+relevant Hugging Face repository. Mirrors must remain byte-identical for a given
+charter version.
+
+Changes begin in the canonical EsoM copy, increment the charter version, and are
+then synchronized across all mirrors in one documented operation. Do not make an
+independent repository-local edit to this file. Propose the change against the
+canonical copy and propagate it everywhere after acceptance.
+
+If a mirror conflicts with the canonical copy at the same version, the canonical
+EsoM copy wins and the mismatch must be reported.

README.md

@@ -0,0 +1,829 @@
+---
+license: mit
+library_name: nys-thermodynamic
+pipeline_tag: other
+language:
+- en
+tags:
+- kuramoto-oscillator
+- equilibrium-propagation
+- sparse-csr
+- thermodynamic-computing
+- non-transformer
+- zero-backprop
+- hip
+- mi300x
+- mi325x
+- cuda
+- sycl
+- sparse-retrieval
+- long-context-memory
+- experimental
+- compiler-physics
+- voice-crystal
+- speech-vocoder
+- sft
+datasets:
+- YNSScarSaiyan/nys-corpus
+- HuggingFaceH4/ultrachat_200k
+---
+
+# NYS — Sparse Kuramoto EqProp (public lineage)
+
+**NYS** is not a transformer. It is a coupled-oscillator organism: phases
+\(\theta_i\), amplitudes, natural frequencies \(\omega_i\), and a sparse
+coupling graph \(K\). Language, compiler bits, and speech-frame IDs live on
+**one** graph (\(N = 5{,}000{,}000\) nodes, \(k = 512\) edges per node).
+The native graph trains by **Equilibrium Propagation** (free RK4, then
+same-moment free/nudged branches, then a contrastive \(K\) update), without
+backprop or a cross-entropy objective. A separate sparse context head now
+provides retrieved language inputs. The GPU Qwen teacher uses
+PyTorch/Transformers; that does not make the native graph a transformer.
+
+*Dakuwon Moody (YNSScarSaiyan) · Saiyan Corp*
+
+---
+
+## Current status — 2026-10-09
+
+**The 16,777,216-token-capacity context adapter is integrated into live
+NYS language training. It is sparse indexed memory, not a 16M-token dense
+attention window or proof of 16M-token language understanding.** NYS remains
+an experimental research artifact, not a validated production chatbot.
+
+Snapshot: **2026-10-09 15:29:56 UTC**. These are dated observations, not a
+live dashboard or a promise that the target has been reached.
+
+| Item | Verified state |
+|---|---|
+| Run / hardware | `qwen-mi325x-4b-20261009-r4`; AMD Instinct MI325X / HIP |
+| Observed native step | **2,213,680**, active at this check |
+| Continuation | Native + context head resumed at 2,190,210; absolute stop target **7,075,000** |
+| Saves | Every **5,000 native steps**, plus first-complete-rotation checkpoint |
+| Teacher | [Qwen3-4B](https://huggingface.co/Qwen/Qwen3-4B), on GPU; revision `1cfa9a7208912126459214e8b04321603b3df60c` |
+| Native graph | 5,000,000 nodes, 512 CSR edges per row; unchanged by context integration |
+| Memory capacity | **16,777,216 frozen NYS token IDs**, not Qwen tokenizer tokens |
+| Head geometry | **1,048,576 hash features + 560 legacy features = 1,049,136 parameters**, not 16M parameters in this deployment |
+| Context training | 4,954 cumulative committed head updates; **4,694 new in r4**, after restoring 260 previous updates |
+| Retrieval counters | 60,958 cumulative injected retrieved IDs; 449,537 represented source IDs processed; zero recorded budget abstentions |
+| Latest verified HF pair at this check | Native step **2,210,000** + matching head; recovery details below |
+| Reporters | CPU-only fixed-fixture and frozen generalization reporters attached; **graph-only controls**, not context-adapter quality tests |
+
+Cumulative source IDs processed are not the size of one retained context.
+Independent corpus rows reset the previous row's memory. Most live prompts
+are much shorter than capacity. Training counters and `contrast` are **not
+accuracy or generalization evidence**.
+
+Source is pinned at GitHub commit
+[`df0024a30542b57d7946ea39fd453ace6180ee58`](https://github.com/dakuwonmoody-lab/nys/tree/df0024a30542b57d7946ea39fd453ace6180ee58/NYS).
+The [backend workflow](https://github.com/dakuwonmoody-lab/nys/actions/runs/37933671238)
+passed Linux CPU, Windows CPU, CUDA compilation, HIP compilation, and
+Intel SYCL compilation. Compilation is not GPU runtime validation: real
+CUDA tests ran separately on an A100, and real HIP tests on the MI325X.
+**Intel GPU runtime has not been demonstrated.** Compact public provenance
+and result summaries are in [the evidence snapshot](documentation/20261009-evidence.json).
+
+### Live context mechanism and validation
+
+Full represented prompts are indexed on the host in an ordered SQLite
+lexical-occurrence store. The shared sparse head scores candidates using
+an explicitly selected CPU, CUDA, HIP, or Intel SYCL numerical backend.
+The full index is not copied into GPU memory.
+
+In the deployed language step, **up to 12 retrieved IDs with explicit word
+boundaries plus the most recent 96 IDs** enter a **127-ID maximum prompt
+including role framing**. The native graph and Qwen teacher see the same
+represented content. Selected older evidence reaches the short native
+prompt; the graph does not attend to every stored token simultaneously.
+Retrieval is bounded to 32 query lexical units, 128 occurrences per cue,
+and 4,096 candidate IDs. Budget exhaustion causes reported abstention
+from evidence injection and the associated head update. Common/repeated
+cues can exhaust these budgets.
+
+Retrieval happens **before teacher targets exist**. Projected Qwen
+probabilities update the separate head only after native acknowledgement
+of the matching complete five-step curriculum rotation. The teacher cannot
+run ahead. Rejected projections discard an unconsumed row without updating
+either model. Row-isolated indexes prevent cross-example context leakage.
+
+The head uses analytic free/nudged equilibria of a quadratic energy, with
+sparse contrastive updates, decay, and clipping: **not** the native graph's
+Kuramoto RK4 dynamics. Its parameters are separate, but save/resume requires
+a logically paired native/head checkpoint. Context integration does not
+rewire the graph, add a sixth curriculum step, or **replace NYS's output
+with a retrieved copy**.
+
+r3's retrieved-input formatting was corrected to preserve explicit word
+boundaries. r4 restored native progress and all 260 committed head updates;
+it did not silently reset the learned head. See the pinned
+[implementation/build guide](https://github.com/dakuwonmoody-lab/nys/blob/df0024a30542b57d7946ea39fd453ace6180ee58/NYS/context_slot/README.md).
+
+Verified checks, with their boundaries:
+
+- CUDA storage/reachability probes at **1,048,576 and 16,777,216 IDs**
+  passed using handcrafted relation weights and punctuation distractors.
+  These are not learned long-document recall or broad reasoning tests.
+- An isolated **4,096-node, k=32** HIP graph completed two full five-step
+  rotations: actual native/head HIP updates, retrieval before labels,
+  longer-than-old-limit inputs reaching the native stream, row isolation,
+  paired saving, and bitwise head restoration. This is an integration
+  check, not a full-size accuracy benchmark.
+- The first r4 production checkpoint at **2,190,215** had
+  `live_deployed=true` and **712 nonzero learned head weights**. Its head
+  restored **bit-for-bit** in a separate bounded HIP process. Native +
+  head + integrity metadata were uploaded and verified together on HF.
+- Production journals show continuing head updates and retrieved-input
+  injection. These establish actual use, **not an accuracy improvement**.
+
+### Current evaluations and unresolved limits
+
+Checkpoint **2,210,000**, reported at **15:11:58 UTC**, was evaluated on
+frozen September 30 cases: 512 external next-token cases, 128 arithmetic
+cases, and 128 nonce-binding pairs / 256 binding cases. These are reused
+regression tests, not a newly sealed uncontaminated benchmark. Exact-context
+audits cannot exclude historical or semantic training overlap.
+
+| Graph-only readout | External top-1 | Arithmetic top-1 | Binding top-1 / complete pairs |
+|---|---|---|---|
+| Stored phase | 0 / 512 (0%) | 0 / 128 (0%) | 0 / 256; 0 / 128 pairs |
+| Weight only | 2 / 512 (0.390625%) | 0 / 128 (0%) | 0 / 256; 0 / 128 pairs |
+| Canonical CPU settle | 2 / 512 (0.390625%) | 0 / 128 (0%) | 0 / 256; 0 / 128 pairs |
+
+Binding constrained-choice was **50%**, chance, with identical predictions
+for both members of all 128 pairs. Canonical CPU settle is an experimental
+readout, not the live native reader. Next-token matching is not conversational
+accuracy. **Broad generalization is not proven.** These reporters do not
+use the context adapter, so cannot establish its quality. A matched
+context-on/context-off language evaluation remains missing.
+
+Fixed training-fixture diagnostics at this checkpoint:
+
+- Language mix: **5 / 96 clamped top-1 (5.2083%)**; **74 / 96** targets
+  had direct prompt-to-gold edges. **22 / 96** still lack these sampled
+  connections. Stronger existing weights cannot create absent edges;
+  context integration did not repair native topology.
+- Compiler: **80.3828% clamped free-bit accuracy** vs **61.7225%** after
+  25 CPU settle steps on fixed gadgets. Different diagnostics, not
+  open-ended compilation or execution correctness.
+- Speech: gold-edge weight lead **0.200936**; gold strongest in its wired
+  pool **16.8055%**, vs untrained pool reference **13.7649%**. Pool
+  comparison is **not speech recognition/synthesis accuracy**.
+
+Recovered corpora and the speech codebook differ from the September
+reporting series. These numbers are not a controlled before/after
+comparison with historical tables below.
+
+An independent **A100-SXM4-80GB topology-repair A/B** started from step
+**2,120,000**. Each arm ran 1,440 CUDA updates on the same 288 language
+records over five epochs. Repair changed 54,546 edges; 381 added edges
+changed weight during native training. Sampled direct coverage rose from
+74/96 to 78/96. But canonical external accuracy stayed **3/512** for
+source, control, and repair, arithmetic **1/128**, and complete binding
+pairs **0/128**. Repair vs control had zero helpful and zero harmful
+canonical prediction changes. **The candidate was not promoted.** This
+bounded language-only trial does not evaluate the full live curriculum
+or the newly integrated context adapter.
+
+### Paired checkpoint downloads and recovery
+
+Known verified pair at the dated snapshot:
+
+- [Native checkpoint at step 2,210,000](https://huggingface.co/YNSScarSaiyan/nys-sft-public/blob/9cf0a6f80a49a899d5c6583445dd1a7b9493ab14/lineages/qwen-mi325x-4b-20261009-r4/checkpoints/gpu_eqprop_2210000_20261009_150930.bin)
+- Immutable HF revision: `9cf0a6f80a49a899d5c6583445dd1a7b9493ab14`
+- Native bytes: **20,640,000,016**; SHA256:
+  `74494f292bf836582b723004d6fcee72af3b9462312079bce0d6069de28c4369`
+- Required same-name `.bin.context/` directory: **`model.json`,
+  `weights.npy`, `pair.json`**. The native `.bin.json` upload record also
+  records sizes and hashes.
+
+Download this pair using the current `hf` CLI:
+
+```sh
+hf download YNSScarSaiyan/nys-sft-public \
+  --revision 9cf0a6f80a49a899d5c6583445dd1a7b9493ab14 \
+  --include 'lineages/qwen-mi325x-4b-20261009-r4/checkpoints/gpu_eqprop_2210000_20261009_150930.bin*' \
+  --local-dir ./nys-checkpoint
+```
+
+The wildcard includes the native file, upload JSON, and three companion
+files. Preserve their relative layout. Verify native size/header/hash and
+companion hashes, vocabulary, geometry, basename, and exact step. A `.bin`
+alone is **not** a complete context-enabled resume. `pair.json` is published
+only after the head/config files are durable.
+
+Retention commits both halves and recovery metadata together, keeps the
+**two newest complete local snapshots**, and protects recovery inputs.
+Local pruning requires fresh integrity plus immutable-revision **and**
+current-remote verification of native and context files. Remote snapshots
+are never deleted. Reviewed source/launch recipes are in the lineage's
+`recovery/` directory.
+
+Context resume requires `--context-library`, explicit `--context-backend`,
+and `--context-resume CHECKPOINT` paired with the exact protected native
+recovery checkpoint. Omitting context resume creates a new head, not
+continued learned context state. See the pinned
+[guarded supervisor](https://github.com/dakuwonmoody-lab/nys/blob/df0024a30542b57d7946ea39fd453ace6180ee58/NYS/gpu_eqprop/run_mi325x.py)
+and [paired retention worker](https://github.com/dakuwonmoody-lab/nys/blob/df0024a30542b57d7946ea39fd453ace6180ee58/NYS/gpu_eqprop/verified_hf_retention.py).
+
+The [read-only context reader](https://github.com/dakuwonmoody-lab/nys/blob/df0024a30542b57d7946ea39fd453ace6180ee58/NYS/gpu_eqprop/live_context_reader.py)
+loads the same head/input adapter and a read-only graph. Its final output
+is a **CPU KOPG graph readout**, not an automatic copy answer or a demonstration
+of native RK4 text generation. This custom format is **not** a Transformers
+`AutoModel.from_pretrained` checkpoint.
+
+---
+
+## Historical diagnosis — 2026-09-11: the training rule was measured to be broken, and why
+
+This section preserves the diagnosis and verification status **as written
+on September 11**. The corrected rule is now deployed in the October
+continuation and has passed real HIP integration/numerical checks. Runtime
+correctness does not establish improved accuracy; use dated results above.
+
+Every accuracy number below step ~1,350,000 in this card was produced under
+a contrastive update that we have since measured to be **dominated by noise
+unrelated to the training signal**, on every slot. This is not a data
+problem, a wiring problem, or a readout problem — those were real and were
+fixed first (see the changelog below) — it is a problem in how this specific
+kernel computed the EqProp contrast. Recording the failure honestly, and the
+fix, in public:
+
+**The mechanism.** Each training step: 5 RK4 steps free, then 5 more RK4
+steps with the nudge force on, then
+\(\Delta K_{ij} \propto \cos\Delta\theta_{\mathrm{nudge}} - \cos\Delta\theta_{\mathrm{free}}\)
+on gated edges. That contrasts the state **5 steps later** against the state
+**5 steps earlier** — two different points in time, not two conditions at
+the same moment. Natural frequencies \(\omega_i\) span 50–1000 rad/s
+(`host_init_graph`, uniform), so in the 0.1 s (`5 × dt=0.02`) between the two
+snapshots a typical pair of nodes counter-rotates by **~36 rad** from
+\(\omega\) alone. The nudge itself moves a target by **~0.003 rad** in the
+same window. We measured this directly by replaying real training steps
+offline against a live checkpoint, once with the nudge force on and once
+with it zeroed (same amplitudes, same gated edges), and comparing:
+
+| | value |
+|---|---|
+| Phase drift between snapshots from \(\omega\) alone | ~36 rad |
+| Phase shift a gold target gets from the nudge | ~0.003 rad |
+| Size of \(\Delta K\) that has nothing to do with the nudge (std) | ~1.0 |
+| Size of the part the nudge actually contributes (mean, std) | −0.00016, 0.0035 |
+| Signal-to-noise ratio on the update | **~1 : 6,000** |
+
+At that SNR, \(K\) on any edge is a random walk that happens to be centered
+near the target most of the time — not a trained value. This explains a
+pattern that was otherwise puzzling: **the speech clamped-pair accuracy
+went from 16.1% at 930k to 4.4% at 1,350,000** — worse, after 420,000 more
+steps, on a slot that was correctly wired the whole time. A noise-dominated
+update drifts; it does not reliably improve.
+
+A second, smaller effect compounded this on speech specifically: the target
+phase (\(\bar\theta\), what nudged nodes are pulled toward) was computed as
+the mean over the **entire prompt**, which for a typical speech step is 32
+neighbor-fill tokens spliced in for exploration plus ~2.3 real text tokens.
+The fill tokens were **91.5%** of that mean. Gold frames were being pulled
+toward the phase of unrelated neighbor tokens, not the phase of the text
+that was supposed to teach them.
+
+**The fix (deployed 2026-09-11, verified offline, live verification in
+progress — check the changelog / latest checkpoint metadata for confirmed
+results before citing numbers past this point):**
+
+1. **Same-moment contrast.** After the free phase, two branches run from the
+   identical state: one continues free, one is nudged, both for the same
+   number of steps. \(\Delta K\) contrasts those two — the \(\omega\)
+   rotation is common to both branches and cancels exactly. Costs one extra
+   5-step integration per training step.
+2. **Target from the real prompt only**, not the neighbor-fill tokens.
+3. **\(\omega\) scaled by 0.01 inside the integrator** (`--omega-scale`, the
+   stored \(\omega\) in the checkpoint is untouched and this is reversible
+   by restarting with a different value). Comparing branches removes the
+   drift, but at the original \(\omega\) magnitude no pair can phase-lock
+   within a 5-step nudge window regardless — the coupling term is too slow
+   relative to the free rotation. Offline replay on 40 real speech records,
+   same edges, before vs. after:
+
+   | Rule | gold-edge \(\Delta K\) | negative-edge \(\Delta K\) |
+   |---|---|---|
+   | Old (time-shifted, \(\omega\) full) | −0.00012 (−2.1 SE) — sign noise | +0.0001 (+1.6 SE) |
+   | Same-moment, text-only mean, \(\omega\) full | −0.00012 (−2.1 SE) — still noise | +0.0001 |
+   | Same-moment, text-only mean, **\(\omega \times 0.01\)** | **+0.0044 (+23 SE)** | **−0.0048 (−22 SE)** |
+
+   Both signs correct, both far outside noise, only once \(\omega\) is
+   slowed. A HIP self-test confirmed the new kernel runs correctly on-GPU at
+   both settings before it went into the training loop.
+
+**What this means for the numbers in the rest of this card.** They are real
+measurements of a real (and, until now, undiagnosed) failure mode — useful
+for exactly that reason — but they are **not** evidence about what this
+graph and this coupling rule can or cannot learn. Compiler and speech being
+stuck near chance was previously attributed to topology and shared-register
+conflicts (both real, both fixed at 925k and 2026-09-10 respectively); it
+now looks like the update itself never had the SNR to learn regardless. That
+question is open again, correctly this time, and is what the current run is
+testing.
+
+---
+
+## Two artifacts on this repo — do not confuse them
+
+| Lineage | Files | Size | Graph | Trainer | Can `tlc-infer` load it? |
+|---|---|---|---|---|---|
+| **Current — sparse GPU EqProp** | `gpu_eqprop_<step>_<utc>.bin` | **20,640,000,016 B** exactly | \(N=5\times10^6\), CSR \(k=512\) | HIP `eqprop_gpu` (no PyTorch) | **No** |
+| **Legacy — dense ASM SFT** | `nys_sft_final.bin` | ~32–34 GiB | \(N=65{,}536\) dense \(K\) | x86-64 NASM / AVX-512 | Yes (old path) |
+
+The model card you are reading describes the **sparse GPU** lineage. The
+legacy file is kept for history. `tlc-infer` / `sampler.cpp` still assume
+the 65,536 dense \(K\). Dropping a `gpu_eqprop_*.bin` into that binary will
+not work.
+Context-enabled sparse checkpoints additionally require their learned-head
+companion bundle; the native binary layout remains the same.
+
+A complete CPU sparse base also exists on
+[`YNSScarSaiyan/nys-checkpoints`](https://huggingface.co/YNSScarSaiyan/nys-checkpoints)
+(`base_sparse_*`). **This public GPU run did not resume that file.** It was
+`--init` (random ring + stubs) at step 0, then trained on-card. Same \(N\),
+same \(k\) the whole way. No second `--init`, ever, on this lineage.
+
+---
+
+## Changelog (most recent first)
+
+- **2026-10-09 — native context integration and paired recovery.**
+  16,777,216-ID memory feeds retrieved evidence into the existing Qwen
+  language step; target-blind retrieval, native-acknowledged head updates,
+  word-boundary correction, learned-head-preserving resume, and hash-verified
+  native + head HF retention. CUDA capacity and actual HIP integration
+  checks passed; broad language generalization remains unproven.
+- **2026-10-09 — A100 repair A/B.** Connectivity and native learnability
+  improved, canonical accuracy did not. Candidate not deployed.
+- **October continuation — MI325X and GPU Qwen3-4B.** Complete verified
+  five-step curriculum, pinned teacher/data, 5,000-step saves, guarded
+  resources, and CPU-only accuracy/generalization reporters attached.
+- **2026-09-11 — contrastive-update SNR fix.** Same-moment branch contrast
+  (cancels \(\omega\) drift exactly), target phase from real prompt tokens
+  only, \(\omega \times 0.01\) inside the integrator. See the section above.
+  Offline-verified at that date; October corrected training is live.
+  Runtime correctness and measured capability remain separate.
+- **2026-09-10 — speech data/training fixes**, in order:
+  - Vocoder codebook rebuilt: the old k-means fit left **235 of 256** atoms
+    at their identity-DC initialization (empty-cluster failure — a centroid
+    with no assigned frames never moves). One code covered **79%** of every
+    frame in the training corpus. Refit with data-seeded k-means++ and
+    empty-cluster reseeding from the worst-fit frame: **1 of 256** atoms
+    left flat, all 256 codes in use, reconstruction SNR 2.9→9.2 dB.
+  - Silence frames (the code that maps to near-zero-variance PCM, ~65–75%
+    of real speech audio) excluded from both training targets and negative
+    examples, on both the HIP trainer and the Python wiring pass. They were
+    previously being pulled toward every record's own phase simultaneously
+    — the same "shared register, many writers" conflict described below for
+    the compiler band.
+  - Speech negative-example generation fixed: the old rule added `code+1`
+    **and** `code+127` neighbors of every gold frame as negatives appended
+    to the *prompt* (so they dominated the target-phase mean; see above),
+    and did not check whether a negative for one record was gold for
+    another. Measured on the live corpus: **39.9%** of positive pushes were
+    being fought by a negative push on the identical physical node. Fixed:
+    one negative per gold frame, checked against a corpus-wide gold set
+    (`load_global_gold_frames`) so a negative can never be a duplicate of
+    someone else's target.
+  - \(K\)-value clamp added to the kernel (\(\lvert K \rvert \le 3\)):
+    contested nodes had walked to \(\lvert K \rvert = 16\)–18 (vs. a
+    wiring-pass seed of \(K=0.2\)) before this was caught; a stale hard
+    reset of the speech band's edges (`--reset-speech`) was run once to
+    clear the accumulated damage.
+- **2026-09-09 (925k) — CSR wire.** Random ring+stubs never connected vocab
+  tokens to the compiler band (`3,800,000+`) or the speech band
+  (`4,300,000+`). Wired in place on existing \(k=512\) slots (weakest
+  non-protected edge replaced, seed \(K=0.2\)). \(N\), \(k\) unchanged.
+- Earlier: neighbor-fill (32), speech \(\beta\) floor (0.25), compiler
+  signed 0-bit nudge — see prior card revisions in this repo's commit
+  history.
+
+---
+
+## Status at 1,350,000 — under the pre-2026-09-11 rule (see caveat above)
+
+These are the last numbers produced before the SNR fix. Treat them as a
+record of the failure mode, not a capability grade.
+
+| Slot | 930k | 1,350,000 | Trend |
+|---|---|---|---|
+| Compiler free bits (clamped-pair) | 49.2% | 52.8% | Flat-ish, chance ≈ 50% either way (38 free bits, 11 shared gadgets) |
+| Speech codes (clamped-pair, in-pool) | 16.1% (in-pool 58%) | **4.4%** (in-pool 41%) | **Degraded** — random-walk signature |
+| Language headline | 0.625% | 0.0% | Noise-level throughout |
+
+Compiler additionally has its own, separate confound even with a correct
+update: **11 gold gadgets share the same 64 bit-oscillators.** A settle-based
+probe (clamp the spec, run free RK4, read where the 64 nodes land — bypassing
+the old "read whatever theta a node was last left at" readout convention)
+confirmed the band **is** driven by the spec (no zero-displacement edges),
+but different specs produced statistically **unrelated** crystals (pairwise
+Hamming ~30/64, chance is 32) — the register is being fought over, not
+un-addressed. That conflict is unresolved and is a second, independent
+reason compiler will need more than the SNR fix.
+
+### Sidecar quizzes at 930k (historical; see caveat above)
+
+| Quiz | 930k | What it actually measures |
+|---|---|---|
+| Compiler Hamming **free** | 15 / 38 (chance ≈ 19) | Unconditioned 64-bit crystal vs 11 golds |
+| Speech `frame_match` (max-over-shift) | 1.49%, locked=false | One global argmax tape vs many gold NYSV records — low ceiling by construction even under a working update |
+| Vocoder codec (pre-rebuild) | 21/256 atoms moved | Superseded 2026-09-10; now 255/256 |
+| Chat (KOPG, SFT prefix) | fragments, `looped=false` | Static 2-hop neighbor walk, **not** HIP RK4 generation |
+
+930k chat probe (for the record, unaffected by any of the above fixes since
+language readout is a separate mechanism from the SNR issue affecting the
+*trained* signal — though the same broken contrastive update was training it
+the whole time):
+
+- `hello` → `based on you provide of your was a by the there are based, we importantafter`
+- `the result is` → `l0_wra in the of the`
+- `nys is listening` → `"_i3gw98h`
+
+Not a chatbot. Neighbor structure is not uniform noise; replies are still
+template / salad. Whether that ceiling is topology (briefing hypothesis:
+fixed ring+stubs never contain the right edge) or the same SNR problem as
+speech/compiler is now an open question again — it hasn't been re-tested
+under the fixed update yet.
+
+---
+
+## What the organism is
+
+NYS is one substrate with five **slots**. Slots 1, 2, and 4 train. Slot
+3 is a crystal→beep readout. Slot 5 is a dump envelope (**not trained**).
+These organism slots are **not** the five curriculum steps (`mix`, `hard`,
+`qwen_direct`, `compiler`, `speech`): the first three all train language.
+Context feeds `qwen_direct`; voice and dump remain non-training slots.
+
+| Slot | Trains? | IDs / files | What it is |
+|---|---|---|---|
+| **1 Language** | Yes | Frozen `vocab_sparse.json` (~3,664,150 IDs). Hard next-token + SDS1 distill + live mix. | Hierarchical token IDs. |
+| **2 Compiler** | Yes | **3,800,000 + bit**, 64 active bits (8 bytes × 8 spins). `compiler_physics.nysa` (412 recs). | Spec-conditioned gold x86 gadgets. 11 gadgets share one 64-bit register — unresolved conflict, independent of the SNR fix. |
+| **3 Voice crystal** | No | Digit tones from the crystal integer (350 Hz + 50 Hz/digit, 8 kHz). | Beeps that report a number. **Not speech.** |
+| **4 Speech** | Yes | **4,300,000 + \(t\cdot 256\) + code**. `speech_slot.nysv` (6) + `speech_align.nysv` (305). Vocoder `speech_vocoder.nyvc` (rebuilt 2026-09-10, 255/256 atoms trained). | Frame-code IDs on the same graph. |
+| **5 Dump** | **No** | `dump_slot.nysd` (NYSD kinds 6/7). Inbox wrap only. | Debug dumps. Do not train NYSD. |
+
+Compiler *execution* of open-ended x86 is a quench + `crystallize` +
+`mprotect`/`CALL` path (`execute.asm`). This sidecar **does not** execute the
+crystal. Demo gold (8-byte active, LSB-first spins):
+
+- `f(x)=x+42`: `48 89 F8 48 83 C0 2A C3`
+- `f(x)=x*x`: `48 89 F8 48 0F AF C7 C3`
+- plus ident, inc, dec, neg, not, shl1, add_self, zero, sub1
+  (**11** gadgets on the **same** 64 bit nodes — this is the shared-register
+  conflict noted above, separate from and in addition to the SNR issue)
+
+Spins freeze LSB-first, 8 spins/byte, bit = \(\mathrm{sign}(a_i \cos\theta_i)\).
+**26 bits are tied** across all padded golds; **38 are free**. Grade free
+bits.
+
+---
+
+## Physics and trainer
+
+### Equation and active set
+
+The HIP fused kernel (`eqprop_gpu.hip`, `hipcc`, `--offload-arch=gfx942`)
+does **not** wrap all \(N\) oscillators and does **not** explode 512
+neighbors of neighbors. As of the 2026-09-11 fix, each training step:
+
+1. Build \(S = \mathrm{unique}(\mathrm{prompt} \cup \mathrm{nudge\ IDs})\),
+   hard cap **256**. Prompt is packed first; if \(|S|>256\), the tail is
+   dropped.
+2. Prompt nodes start at amplitude 1; others 0.
+3. **Neighbor fill:** up to 32 unseen CSR neighbors of the last prompt token
+   are spliced into the prompt (amp 1) for exploration. The target-phase
+   mean (next step) is computed from the **real prompt only**, excluding
+   these — fixed 2026-09-11; previously the fill dominated the mean.
+4. **Free** RK4: 5 steps, \(\mathrm{d}t = 0.02\), \(\omega\) scaled by
+   `--omega-scale` inside the integrator (default in the current run:
+   **0.01**; the checkpoint's stored \(\omega\) is never modified, so this
+   is a launch-time choice, reversible by restarting with a different
+   value).
+5. **Branch point.** From the free-phase end state:
+   - **Branch A (free-continued):** 5 more RK4 steps, no nudge.
+   - **Branch B (nudged):** 5 more RK4 steps from the *same* starting
+     state, force \(\beta \sin(\bar\theta - \theta_i)\) on nudge targets.
+   \(\bar\theta\) is the circular mean of the real prompt at the branch
+   point (see step 3).
+6. Nudge targets get amplitude \(\min(1, |\beta|)\) for branch B. Amp gate
+   for \(K\) updates is **0.1**.
+7. Contrastive \(K\): on CSR edges whose both ends have amp \(> 0.1\),
+   \(\Delta K_{ij} \leftarrow \eta\,(\cos\Delta\theta_{B} - \cos\Delta\theta_{A})\)
+   — both branches measured at the **same** elapsed time from the **same**
+   starting state, so \(\omega\)-driven rotation is common to both and
+   cancels. \(K\) is clamped to \(\lvert K \rvert \le 3\) after each update.
+8. Amplitudes written back to 0.
+
+Before 2026-09-11, step 5 did not exist: branch B was compared directly
+against the step-4 (free) snapshot, 5 steps earlier in time. See the
+diagnosis at the top of this card.
+
+Defaults: \(\eta = 0.05\), \(\beta = 1.5\). One HIP block, 256 threads.
+Model state ~20.64 GB HBM. The historical cap was 77 GiB. The October
+continuation caps native owned allocation at **28 GiB** and configures a
+**12 GiB** GPU-teacher budget, with shared-host reserves including at least
+16 GiB free VRAM. Guards do not count every driver/runtime allocation.
+No `hipDeviceReset` or control of other projects' trainer processes.
+
+### Contrast is the native signal
+
+A printed `contrast=0.00000` (or a slot column of `0.00000`) can reflect no
+amp-gated edges, a small rounded value, or cancellation, not a perfect model.
+It is a heartbeat
+(mean \(\Delta\cos\) on gated edges), **not** accuracy, and — as of
+2026-09-11 — is understood to have been dominated by an artifact for every
+slot prior to the branch fix. Post-fix, it is the same statistic computed
+on a rule with verified nonzero SNR; still not a substitute for the
+clamped-pair / settle-based accuracy checks.
+
+### Live rotation
+
+Each loop tries, in order: **mix** (tailed hard file) → **hard**
+(train + SFT wrap) → **SDS1 distill** → **NYSA compiler** → **NYSV
+speech**.
+
+October training requires all five steps, using **live GPU Qwen3-4B
+projected probabilities** in `qwen_direct` instead of the historical
+static SDS1 file. A complete rotation advances five native updates.
+Separate context-head updates do not count as extra native steps.
+
+HIP holds NYSA/NYSV as `FILE*` for the life of the process. Slot updates
+must be **atomic `mv`** onto those paths; a truncate/scp onto an open
+slot file will crash the trainer.
+
+---
+
+## Sparse checkpoint layout
+
+Little-endian. **Reject any file whose size is not 20,640,000,016.**
+Current saves are append-only immutable snapshots with partial-write
+handling and exclusive final publication. Resume only from a complete
+file and, for context continuation, a validated companion bundle. Native
+layout is unchanged by context integration or the 2026-09-11 fix — `\omega` in the file is
+the same value it always was; scaling happens only inside the integrator
+at load time via `--omega-scale`.
+
+| Field | Type | Count | Notes |
+|---|---|---|---|
+| `N` | `uint32` | 1 | 5,000,000 |
+| `k` | `uint32` | 1 | 512 |
+| `theta` | `float64` | \(N\) | phase |
+| `amp` | `float64` | \(N\) | 0 after a finished step |
+| `omega` | `float64` | \(N\) | natural frequency, stored value unchanged by `--omega-scale` |
+| `K_row_offsets` | `uint64` | \(N+1\) | CSR; row \(i\) is \([i k, (i+1)k)\) |
+| `K_col_indices` | `uint32` | \(N \cdot k\) | ring + stubs; rewired at 925k (compiler/speech) and 2026-09-10 (speech reset) |
+| `K_values` | `float32` | \(N \cdot k\) | learned couplings, clamped to \(\lvert K \rvert \le 3\) as of 2026-09-11 |
+
+Offsets:
+
+```
+theta_off  = 8
+amp_off    = 8 + 8N
+omega_off  = 8 + 16N
+row_off    = 8 + 24N
+col_off    = row_off + 8(N+1)
+val_off    = col_off + 4 N k
+end        = val_off + 4 N k   = 20,640,000,016
+```
+
+Init topology (this lineage): for each row, \(k-16\) local ring
+`(i - k/2 + j) mod N`, last 16 random stubs. Training updates **values**
+on those edges. At **925k**, a CPU pass replaced the weakest non-protected
+column in some rows so vocab ↔ compiler/speech IDs share an edge. At
+**2026-09-10**, the speech band's edges were additionally force-reset to
+the wiring seed value once, to clear damage accumulated before the silence/
+negative-collision fixes existed. \(k\) is still 512 throughout.
+
+Filename: `gpu_eqprop_<steps>_<YYYYMMDD>_<HHMMSS>.bin` (UTC). The trainer
+parses `steps` from the name (or symlink target) for `--resume-steps`.
+
+---
+
+## Tokenizer (do not retrain)
+
+[`vocab_sparse.json`](https://huggingface.co/datasets/YNSScarSaiyan/nys-corpus)
+(~107 MB). `HierarchicalTokenizer`: bytes 0–255, then greedy 4-gram
+phrases. The frozen **space-join** encode bug is part of the ID space —
+do not "fix" it or IDs will not match \(K\).
+
+The October adapter's frozen vocabulary SHA256 is
+`23d96f815a5904045899fa304988fb011e21a6b25b612d729b8d833ae5e7388e`.
+Retrieved-input boundary corrections do not change the tokenizer. NYS
+capacity counts these IDs, not interchangeable Qwen tokenizer tokens.
+
+IDs above vocab and below \(N\) are reserved bands (compiler / voice
+entropy / speech / dump). They are first-class oscillators, not a second
+model.
+
+---
+
+## Training data
+
+Corpora live on
+[`YNSScarSaiyan/nys-corpus`](https://huggingface.co/datasets/YNSScarSaiyan/nys-corpus)
+unless noted. Slot files also upload under `slots/` on this repo.
+
+### Slot 1 — language
+
+| File | Layout | Records |
+|---|---|---|
+| `train_corpus_sparse.bin` | hard: `uint32 nrec` + (`uint16 len` + `uint32 toks[len]`), last = target | 255,435 |
+| `sft_corpus_sparse.bin` | same hard layout | 50,000 |
+| `mix_sft_sparse.bin` | same hard layout (Rust `sparse_convert` from JSONL) | 2,050,000 |
+| `distill_corpus_sparse.bin` | SDS1: prompt + soft id/prob | 40,000 |
+
+The static distillation row is **historical**: that fixture is absent
+from the restored bundle; no accuracy on it is claimed. The current run
+validates both hard corpora and a corrected 2,050,000-record mixture with
+all nine sources: `agent_flan`, `glaive`, `hermes_fc`, `openhermes`, `orca`,
+`toolace`, `tulu3`, `ultrachat`, `xlam`. Mix SHA256:
+`425f2adaa8ab2a380b273d7abba3401855fcd792475c742627c0befa419273a9`.
+
+Live teacher prompts use
+[`HuggingFaceH4/ultrachat_200k`](https://huggingface.co/datasets/HuggingFaceH4/ultrachat_200k),
+`train_sft`, revision `8049631c405ae6576f93f445c6b8166f76f5505a`.
+Prompt repetition is enabled. Upstream model/data licenses and terms
+apply separately; this repository's MIT metadata does not relicense
+third-party teachers or training material.
+
+### Slot 2 — compiler physics (`NYSA`)
+
+**412** records: I/O triples (kind 1: 385), gold bytes (11), structural bit
+maps (5), traces (11). HIP nudges bit nodes at `3_800_000 + i` with
+\(+\beta\) (spin 1) or \(-\beta\) (spin 0). All 11 gadgets share the
+**same** 64 oscillators — confirmed via settle-based conditioning probe to
+be a genuine unresolved conflict, not a readout artifact.
+
+### Slot 4 — speech (`NYSV` + `NYVC`)
+
+| File | Records | Role |
+|---|---|---|
+| `speech_slot.nysv` | 6 | Seed utterances |
+| `speech_align.nysv` | 305 | Aligned text ↔ frame IDs (≤64 frames / rec) |
+| `speech_vocoder.nyvc` | 256 atoms × 80 samples @ 8 kHz | VQ table, rebuilt 2026-09-10 (255/256 atoms trained, was 21/256) |
+
+Frame IDs = `4_300_000 + t*256 + code`. `ALIGN_MAX_FRAMES=64` keeps
+\(|S|\) under the 256 cap. As of 2026-09-10, silence-coded frames are
+excluded from both nudge targets and negative examples; negatives are
+checked against a corpus-wide gold set to guarantee zero collision with
+another record's target.
+
+### Slot 5 — dump (`NYSD`)
+
+Reserved envelope + inbox. **The trainer does not EqProp NYSD.**
+
+---
+
+## Historical sidecar (CPU, after every complete snap)
+
+`sidecar.py` mmaps the checkpoint. Does not run the HIP kernel. Its readouts
+(chat KOPG, crystal Hamming, speech `frame_match`) score **stored theta
+directly** — which, independent of the SNR issue, is the value a node was
+left at by whichever record touched it last, not a response to a live
+prompt. A separate read-only inference mode (`eqprop_gpu --settle`: clamp a
+prompt, run free RK4, read where target nodes land, no training-state
+mutation) exists and was used for the compiler conditioning check above; it
+is not yet wired into the routine sidecar quiz path.
+
+Outputs (also uploaded here):
+
+```
+sidecar/gpu_eqprop_<step>_<utc>/
+  train_acc.json  # clamped-pair acc (language / compiler / speech)
+  eval.json       # train_acc + chat + free Hamming + speech lock + codec
+  ...
+```
+
+This is the historical sidecar path. October CPU reporters also produce
+fixed-fixture language/speech/compiler diagnostics and frozen generalization
+controls, with readout/contamination caveats; they do not evaluate context.
+Current retention requires size **and SHA256**, paired native/head files,
+pinned/current remote verification, and **two** newest local snapshots.
+A size-only remote listing is insufficient deletion authority.
+
+---
+
+## How to load (sparse)
+
+```python
+import os, struct, mmap
+
+FULL = 20_640_000_016
+path = "gpu_eqprop_1350000_20260911_071500.bin"  # use the newest on this repo
+assert os.path.getsize(path) == FULL
+
+with open(path, "rb") as f:
+    mm = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
+    N, k = struct.unpack_from("<II", mm, 0)
+    assert N == 5_000_000 and k == 512
+```
+
+Historical native-only train / resume example (HIP, MI300X / gfx942),
+**not** the current full-curriculum GPU-teacher/context continuation.
+For the current recipe use the pinned supervisor and paired recovery
+metadata above. **Never `--init`
+unless you intend to throw this lineage away.**
+
+```bash
+hipcc -O3 -std=c++17 --offload-arch=gfx942 -o eqprop_gpu eqprop_gpu.hip
+./eqprop_gpu \
+  --data-dir ./data --live --live-mix ./data/mix_sft_sparse.bin \
+  --ckpt ./gpu_eqprop_1350000_20260911_071500.bin \
+  --save-every 5000 --save-dir ./ckpts \
+  --vram-limit-gb 77 --device 0 --lr 0.05 --beta 1.5 \
+  --omega-scale 0.01
+```
+
+Omit `--omega-scale` (or pass `1`) to reproduce the pre-2026-09-11 dynamics
+exactly — the checkpoint format and stored values are identical either way.
+
+---
+
+## Files in this repo
+
+- `gpu_eqprop_<step>_<utc>.bin` — sparse snapshots every 5,000 steps. Each
+  file is the full substrate, not a delta. Reject any file that is not
+  20,640,000,016 B.
+- `sidecar/gpu_eqprop_*/` — CPU readouts.
+- `slots/` — NYSA / NYSV / NYVC / NYSD copies used by this run.
+- `nys_sft_final.bin` — **legacy** 65,536 dense SFT (see table above).
+- `PROGRAM_CHARTER.md` — cross-program charter.
+- `lineages/<run-id>/checkpoints/` — continuation snapshots, upload JSONs,
+  and required `.bin.context/` bundles for context-enabled runs.
+- `lineages/<run-id>/recovery/` — reviewed source and launch/source metadata.
+- `documentation/20261009-evidence.json` — compact dated evidence for this update.
+
+Select within the documented production lineage and verify the record,
+not the largest filename globally: historical and experimental lineages
+coexist. Pin immutable HF revisions. More steps do not imply higher accuracy.
+
+---
+
+## Hardware and stack
+
+| Item | This public GPU run |
+|---|---|
+| GPU | Current MI325X / HIP; historical MI300X; native kernel uses one block of 256 threads |
+| Compile | `hipcc`, C++17, `gfx942`; native graph is not PyTorch/JAX; separate Qwen teacher uses PyTorch/Transformers |
+| HBM | ~20.64 GB native state; current native allocation cap 28 GiB, teacher budget 12 GiB, shared-host reserve checks |
+| Context backends | Native CPU, CUDA, HIP, Intel SYCL; production uses HIP; Intel GPU runtime unverified |
+| Tokenizer | Frozen hierarchical phrase vocab (~3.66M IDs) |
+| Author | Dakuwon Moody (`YNSScarSaiyan`) |
+
+---
+
+## Limitations (read this)
+
+- **Historical accuracy caveat:** every accuracy number from before
+  2026-09-11 was produced under a
+  contrastive update with a measured signal-to-noise ratio of roughly
+  1:6,000. Treat those numbers as documentation of the failure mode, not as
+  evidence about the organism's ceiling in either direction.
+- **Runtime correctness is not capability.** Corrected native training
+  and context integration have actual HIP verification; broad generalization
+  and a context-on/context-off language-quality gain remain unproven.
+- **16M means indexed memory capacity**, not dense attention, a native
+  active set of that size, a 16M-parameter head in this run, or demonstrated
+  16M-token language understanding. Sparse retrieval can miss evidence.
+- **Native topology still limits readout.** In the fixed language sample,
+  22/96 targets lack direct prompt-to-gold edges. Context does not create
+  native edges. The A100 topology-repair candidate was not promoted.
+- **Readout/data changes matter.** Stored phase, weight only, canonical CPU
+  settle, clamped fixtures, and context-assisted readout differ. Restored
+  corpus/codebook changes prevent simple historical accuracy comparisons.
+- **Compiler has a second, independent problem**: 11 gadgets share one
+  64-bit register, confirmed via a settle-based conditioning probe to be a
+  genuine write conflict, not a readout artifact. Fixing the SNR does not
+  by itself fix this.
+- **Not a production chat model.** No CE, no instruction-eval scores
+  claimed here. Contrast ≠ quality grade. KOPG chat ≠ EqProp generation.
+- **This GPU lineage started from random init**, not the completed CPU
+  sparse base.
+- **Sparse ≠ dense.** You cannot mmap these bins as a 65,536×65,536 `K`.
+- **Voice (slot 3) is digit-tone crystallize**, not speech synthesis.
+- **Do not retrain `vocab_sparse.json`.**
+- **Do not `--init` this lineage** unless you mean to start over.
+- Research artifact. Architecture-locked to this \(N,k\) and tokenizer.
+- Not validated for high-stakes decisions. No comprehensive safety/bias
+  assessment, reliable general-purpose generation, or open-ended compiler
+  correctness is claimed.
+
+---
+
+## Related
+
+- Engine / trainers: local `NYS/` (HIP `gpu_eqprop/`, CPU
+  `src/sparse_trainer.cpp`, ASM `src/{execute,audio,coupling,quench}.asm`)
+- Public source: [deployed GitHub commit](https://github.com/dakuwonmoody-lab/nys/tree/df0024a30542b57d7946ea39fd453ace6180ee58/NYS)
+- Backend CI: [October 9 passing workflow](https://github.com/dakuwonmoody-lab/nys/actions/runs/37933671238)
+- Corpora: [`YNSScarSaiyan/nys-corpus`](https://huggingface.co/datasets/YNSScarSaiyan/nys-corpus)
+- Private / other snaps: [`YNSScarSaiyan/nys-checkpoints`](https://huggingface.co/YNSScarSaiyan/nys-checkpoints)
+- Charter: `PROGRAM_CHARTER.md` in this repo
+
+*Updated 2026-10-09 — live MI325X / GPU Qwen3-4B continuation, 16M-capacity
+sparse context integration, preserved learned head, paired HF recovery,
+backend validation boundaries, current graph-only metrics, and unpromoted
+A100 repair A/B. September diagnosis/results remain historical records.
+No broad generalization or 16M-token language-understanding claim is made.*

documentation/20261009-evidence.json

@@ -0,0 +1,173 @@
+{
+  "schema_version": 1,
+  "snapshot_utc": "2026-10-09T15:29:56.677849+00:00",
+  "scope": "Dated model-card evidence; not a live dashboard or proof of broad generalization",
+  "source": {
+    "github_repo": "dakuwonmoody-lab/nys",
+    "deployed_commit": "df0024a30542b57d7946ea39fd453ace6180ee58",
+    "ci_url": "https://github.com/dakuwonmoody-lab/nys/actions/runs/37933671238",
+    "ci_passed": ["Linux CPU", "Windows CPU", "CUDA compile", "HIP compile", "Intel SYCL compile"],
+    "intel_gpu_runtime_verified": false,
+    "native_hip_binary_sha256": "4b9dacb4592e56d29647c240094ed298ca93a8b3fbb71e6ced970eaf5b0f6572",
+    "context_hip_library_sha256": "285034c2de4bb898b5cb6a4112c3e3e61e1a8cf3e761eec7e362186bdf7a703c"
+  },
+  "run": {
+    "run_id": "qwen-mi325x-4b-20261009-r4",
+    "running_at_snapshot": true,
+    "hardware": "AMD Instinct MI325X",
+    "native_backend": "HIP",
+    "start_step": 2190210,
+    "observed_step": 2213680,
+    "target_absolute_step": 7075000,
+    "additional_steps_at_launch": 4884790,
+    "save_every_native_steps": 5000,
+    "curriculum": ["mix", "hard", "qwen_direct", "compiler", "speech"],
+    "teacher_model": "Qwen/Qwen3-4B",
+    "teacher_revision": "1cfa9a7208912126459214e8b04321603b3df60c",
+    "teacher_on_gpu": true,
+    "teacher_dataset": "HuggingFaceH4/ultrachat_200k",
+    "teacher_split": "train_sft",
+    "teacher_dataset_revision": "8049631c405ae6576f93f445c6b8166f76f5505a",
+    "vocab_sha256": "23d96f815a5904045899fa304988fb011e21a6b25b612d729b8d833ae5e7388e",
+    "corrected_mix_sha256": "425f2adaa8ab2a380b273d7abba3401855fcd792475c742627c0befa419273a9"
+  },
+  "context": {
+    "capacity_nys_token_ids": 16777216,
+    "hash_features": 1048576,
+    "legacy_features": 560,
+    "parameters": 1049136,
+    "backend": "HIP",
+    "records": 4954,
+    "committed_head_updates": 4954,
+    "positive_updates": 4897,
+    "restored_previous_updates": 260,
+    "new_head_updates_in_r4": 4694,
+    "retrieved_records": 4954,
+    "retrieved_token_ids_injected": 60958,
+    "represented_source_ids_processed": 449537,
+    "budget_abstentions": 0,
+    "retrieved_ids_per_prompt_max": 12,
+    "recent_ids_per_prompt_max": 96,
+    "framed_native_prompt_max_ids": 127,
+    "cross_row_memory": false,
+    "retrieval_before_teacher_targets": true,
+    "head_commit_requires_native_rotation_ack": true,
+    "native_graph_topology_modified_by_context": false,
+    "automatic_copy_answer_override": false,
+    "broad_long_context_quality_demonstrated": false
+  },
+  "latest_verified_backup_at_snapshot": {
+    "repo": "YNSScarSaiyan/nys-sft-public",
+    "step": 2210000,
+    "checkpoint": "lineages/qwen-mi325x-4b-20261009-r4/checkpoints/gpu_eqprop_2210000_20261009_150930.bin",
+    "immutable_revision": "9cf0a6f80a49a899d5c6583445dd1a7b9493ab14",
+    "native_bytes": 20640000016,
+    "native_sha256": "74494f292bf836582b723004d6fcee72af3b9462312079bce0d6069de28c4369",
+    "native_and_context_verified_together": true,
+    "companion_files": {
+      "model.json": {"bytes": 1051, "sha256": "3765bece9bc97761d0ecf02f84a1e157e6ee143eadc8480e0f8db5a7a3364894"},
+      "weights.npy": {"bytes": 4196672, "sha256": "ce9ea63e3827c7f9792e84e02f28b7e67f4c7299ca516fa67a15e3256c8a5143"},
+      "pair.json": {"bytes": 1023, "sha256": "35a2667fc2ed67899f07cb5b959ce0304842e0eb866cd2756638e616aafe4827"}
+    }
+  },
+  "production_head_restore_check": {
+    "native_step": 2190215,
+    "context_updates_saved": 261,
+    "live_deployed": true,
+    "backend": "HIP",
+    "nonzero_weights": 712,
+    "max_abs_weight": 0.006360475905239582,
+    "bitwise_head_restore": true,
+    "hf_pair_revision": "42408ae032f6d4050dae477c026a53ed917a4ab2"
+  },
+  "isolated_hip_integration_check": {
+    "native_nodes": 4096,
+    "native_k": 32,
+    "native_steps": 10,
+    "complete_five_step_rotations": 2,
+    "actual_native_hip": true,
+    "actual_context_hip": true,
+    "longer_than_old_limit_input_entered_native_stream": true,
+    "query_before_targets": true,
+    "paired_save_and_bitwise_head_resume": true,
+    "independent_rows_isolated": true,
+    "original_seed_unchanged": true
+  },
+  "graph_only_report": {
+    "step": 2210000,
+    "checked_utc": "2026-10-09T15:11:58.576523+00:00",
+    "cases_sha256": "71c34c27405a498278622d2f24562c19020db7d01c03aad86061f43978448fc4",
+    "cases": 896,
+    "cpu_only": true,
+    "training_updates": 0,
+    "uses_context_adapter": false,
+    "metrics": {
+      "stored_phase": {
+        "external": {"records": 512, "correct": 0, "accuracy": 0.0},
+        "arithmetic": {"records": 128, "correct": 0, "accuracy": 0.0},
+        "binding": {"records": 256, "correct": 0, "pairs": 128, "complete_correct_pairs": 0, "constrained_choice_accuracy": 0.5, "identical_prediction_pairs": 128}
+      },
+      "weight_only": {
+        "external": {"records": 512, "correct": 2, "accuracy": 0.00390625},
+        "arithmetic": {"records": 128, "correct": 0, "accuracy": 0.0},
+        "binding": {"records": 256, "correct": 0, "pairs": 128, "complete_correct_pairs": 0, "constrained_choice_accuracy": 0.5, "identical_prediction_pairs": 128}
+      },
+      "canonical_settle": {
+        "external": {"records": 512, "correct": 2, "accuracy": 0.00390625},
+        "arithmetic": {"records": 128, "correct": 0, "accuracy": 0.0},
+        "binding": {"records": 256, "correct": 0, "pairs": 128, "complete_correct_pairs": 0, "constrained_choice_accuracy": 0.5, "identical_prediction_pairs": 128}
+      }
+    },
+    "fixed_training_fixtures": {
+      "language_mix_records": 96,
+      "language_mix_clamped_correct": 5,
+      "language_mix_clamped_top1": 0.052083333333333336,
+      "language_mix_directly_reachable_gold": 74,
+      "language_mix_missing_direct_gold": 22,
+      "compiler_clamped_free_bit_accuracy": 0.8038277511961722,
+      "compiler_cpu_settled_free_bit_accuracy": 0.6172248803827751,
+      "compiler_cpu_settle_steps": 25,
+      "speech_gold_edge_weight_lead": 0.20093635986587288,
+      "speech_gold_strongest_wired_pool_fraction": 0.1680550525172039,
+      "speech_untrained_pool_reference": 0.1376490080665108
+    },
+    "broad_generalization_proven": false,
+    "limitations": [
+      "Reused frozen September 30 regression cases, not a fresh sealed benchmark",
+      "Historical and semantic contamination cannot be excluded",
+      "Canonical settle is an experimental CPU readout, not the live native reader",
+      "Next-token matching is not conversational accuracy",
+      "These reporters do not measure the context adapter",
+      "Recovered corpus/codebook changes prevent simple September comparisons",
+      "Compiler fixed-bit and speech wired-pool diagnostics are not broad capabilities"
+    ]
+  },
+  "a100_topology_ab": {
+    "hardware": "A100-SXM4-80GB",
+    "source_native_step": 2120000,
+    "source_native_sha256": "5f922bf29d82e13cccb37eb642216f5e7112fb0869276739d70ff2a1162ed4ba",
+    "source_hf_revision": "be84d1ea03b422721e956b336b5e00c6715ff96d",
+    "cuda_updates_per_arm": 1440,
+    "matched_language_records": 288,
+    "epochs": 5,
+    "changed_edges": 54546,
+    "added_edges_changed_by_native_training": 381,
+    "direct_sampled_coverage_before": 74,
+    "direct_sampled_coverage_after": 78,
+    "direct_sampled_records": 96,
+    "canonical_external": {"records": 512, "source_correct": 3, "control_correct": 3, "repaired_correct": 3},
+    "canonical_arithmetic": {"records": 128, "source_correct": 1, "control_correct": 1, "repaired_correct": 1},
+    "canonical_binding": {"pairs": 128, "source_complete_pairs": 0, "control_complete_pairs": 0, "repaired_complete_pairs": 0},
+    "repaired_vs_control_helpful_predictions": 0,
+    "repaired_vs_control_harmful_predictions": 0,
+    "candidate_deployed": false,
+    "limitation": "Bounded language-only trial, not the full live curriculum or the integrated context adapter"
+  },
+  "cuda_capacity_checks": {
+    "context_tests_passed": 28,
+    "tested_capacity_nys_ids": [1048576, 16777216],
+    "hash_features_in_probes": 1048576,
+    "limitation": "Handcrafted relation weights and punctuation distractors; not learned language recall, broad generalization, or a controlled speed comparison"
+  },
+  "documentation_change_scope": "README.md and this compact public evidence file only; no trainer, checkpoint, billing, or credential changes"
+}

lineages/corrected-20260930-v2/LATEST.json

@@ -0,0 +1 @@
+{"path": "lineages/corrected-20260930-v2/gpu_eqprop_2075000_20260930_214548.bin", "step": 2075000, "bytes": 20640000016, "sha256": "96673f09132d5a0bb2adf5664f4e3839567bbb6371a07b16b46714f3967e9b33"}

lineages/corrected-20260930-v2/curriculum.json

@@ -0,0 +1,31 @@
+{
+  "verified": true,
+  "rotation": [
+    "mix",
+    "hard",
+    "qwen_direct",
+    "compiler",
+    "speech"
+  ],
+  "records": {
+    "mix": 2050000,
+    "train_corpus_sparse.bin": 255435,
+    "sft_corpus_sparse.bin": 50000,
+    "speech_align.nysv": 305,
+    "speech_slot.nysv": 6,
+    "compiler_physics.nysa": 412
+  },
+  "mix_sha256": "425f2adaa8ab2a380b273d7abba3401855fcd792475c742627c0befa419273a9",
+  "mix_sources": [
+    "agent_flan",
+    "glaive",
+    "hermes_fc",
+    "openhermes",
+    "orca",
+    "toolace",
+    "tulu3",
+    "ultrachat",
+    "xlam"
+  ],
+  "vocab_sha256": "23d96f815a5904045899fa304988fb011e21a6b25b612d729b8d833ae5e7388e"
+}

lineages/corrected-20260930-v2/lineage.json

@@ -0,0 +1,11 @@
+{
+  "lineage": "corrected-20260930-v2",
+  "parent_root": "/data/nys-l40s",
+  "quarantined_parent_runs": true,
+  "source_step": 1915000,
+  "source_revision": "6f1f1e314e6d680f0e1541ddc6b1f6590b46cf40",
+  "status": "VALIDATED",
+  "full_curriculum_sha256": "e1e79d842ec60f3f646a563850a683e49519c6892807ee3a70a3a60047c3de81",
+  "mix_sha256": "425f2adaa8ab2a380b273d7abba3401855fcd792475c742627c0befa419273a9",
+  "superseded_lineage": "corrected-20260930"
+}

lineages/corrected-20260930-v2/mix_manifest.json

@@ -0,0 +1,187 @@
+{
+  "verified": true,
+  "records": 2050000,
+  "bytes": 810830240,
+  "sha256": "425f2adaa8ab2a380b273d7abba3401855fcd792475c742627c0befa419273a9",
+  "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649",
+  "vocab_sha256": "23d96f815a5904045899fa304988fb011e21a6b25b612d729b8d833ae5e7388e",
+  "sources": [
+    {
+      "name": "tulu3",
+      "repo": "allenai/tulu-3-sft-mixture",
+      "revision": "b14afda60f1bbebe55d5d2fa1e4df5042f97f8be",
+      "config": null,
+      "records": 273333,
+      "target_records": 273333,
+      "bytes": 74691934,
+      "sha256": "a6791c7f5ebfbf73982f16200c57da1f986ec82835e26d310337723811488efe",
+      "fed_conversations": {
+        "train": 14280
+      },
+      "normalized_input_sha256": "43a1ceebba233ccc1295c0e6e4c38df03ca107aeca88ba76aa8ebdff3db05739",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "openhermes",
+      "repo": "teknium/OpenHermes-2.5",
+      "revision": "b82037821055c377bed0d495e72e46de3bc72e84",
+      "config": null,
+      "records": 205000,
+      "target_records": 205000,
+      "bytes": 37265984,
+      "sha256": "a14995d3982265093dade0e5456bf4e807adc1606502a008e010bf1cae91a86e",
+      "fed_conversations": {
+        "train": 9472
+      },
+      "normalized_input_sha256": "0c8290012cd577e5fa0e719b3e1a109d0be0e7352a180fcc87d558123f96b55d",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "ultrachat",
+      "repo": "HuggingFaceH4/ultrachat_200k",
+      "revision": "8049631c405ae6576f93f445c6b8166f76f5505a",
+      "config": null,
+      "records": 205000,
+      "target_records": 205000,
+      "bytes": 54089028,
+      "sha256": "ca6fe7a2c74cf1612a51d6c8b425c4869a5147f56647581a318b148a1660fca0",
+      "fed_conversations": {
+        "train_sft": 8211
+      },
+      "normalized_input_sha256": "c5e3c60cfe787c0ee6dc15a934e2d9f0de46a866faafb8d871464f69972301de",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "xlam",
+      "repo": "Salesforce/xlam-function-calling-60k",
+      "revision": "26d14ebfe18b1f7b524bd39b404b50af5dc97866",
+      "config": "dataset",
+      "records": 273333,
+      "target_records": 273333,
+      "bytes": 133978174,
+      "sha256": "35fa9266bf1f5080dd52798145a68fcfaae141e5ae7060e9049d8b5518dc9f83",
+      "fed_conversations": {
+        "train": 11216
+      },
+      "normalized_input_sha256": "4d384db283209ff38aecbd1fc07498e9d2e9158aa5c151e488a6e3bcfa7dba73",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "toolace",
+      "repo": "Team-ACE/ToolACE",
+      "revision": "6bda777c88d21e5a204703c1ee45597a8fa4f734",
+      "config": null,
+      "records": 205000,
+      "target_records": 205000,
+      "bytes": 105319644,
+      "sha256": "4e2351be623bf5d2cb4e6c72fe5454289dbb467055d8ab5c4ef9f9a50cca8b36",
+      "fed_conversations": {
+        "train": 9014
+      },
+      "normalized_input_sha256": "129d36d3541f946be6d6199eaed8ab7a796cdd54ffc45abe735f9837c79e7e3d",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "glaive",
+      "repo": "glaiveai/glaive-function-calling-v2",
+      "revision": "e7f4b6456019f5d8bcb991ef0dd67d8ff23221ac",
+      "config": null,
+      "records": 205000,
+      "target_records": 205000,
+      "bytes": 80593548,
+      "sha256": "c1e0f9b1b3e57bea3d726ee282748959aaeefdce5a01dea4d10e980a152ee1fa",
+      "fed_conversations": {
+        "train": 8320
+      },
+      "normalized_input_sha256": "9a8a47aca6a49e0054690a267bdc610e9f9ffc2b67ae3782f00aae34921d33b7",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "hermes_fc",
+      "repo": "NousResearch/hermes-function-calling-v1",
+      "revision": "dae3e1d28cfbcf4b915c04ea1e072030529b4bda",
+      "config": "func_calling_singleturn",
+      "records": 47325,
+      "target_records": 136666,
+      "bytes": 24325054,
+      "sha256": "b83105e2de0c9317cbdf064b8a022c0e2e6994b20ee95a9e2aee28fa7a4ea2b3",
+      "fed_conversations": {
+        "train": 1893
+      },
+      "normalized_input_sha256": "f9faf972ab53f865c517574dd83540982ec94b3d19024acf941bd627117e09d5",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "orca",
+      "repo": "microsoft/orca-agentinstruct-1M-v1",
+      "revision": "86d609183249ff8037eae33d76ebca3af9390ea8",
+      "config": null,
+      "records": 273333,
+      "target_records": 273333,
+      "bytes": 115045826,
+      "sha256": "b9194dd3c45ac353809a19c851ef5935ef06d568c46943ab021963a4a8adf677",
+      "fed_conversations": {
+        "analytical_reasoning": 1873,
+        "code_": 1873,
+        "rag": 1872,
+        "follow_up": 1872,
+        "fs_cot_flow": 1872,
+        "open_domain_qa": 1872
+      },
+      "normalized_input_sha256": "c4b165c28a5e4ba92304e38d23f2da93cf691eb9eb137b847aa9f6f5592b7180",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "agent_flan",
+      "repo": "internlm/Agent-FLAN",
+      "revision": "8b25999e795a58b264fcb51e8746edb2faee9161",
+      "config": null,
+      "records": 362676,
+      "target_records": 362676,
+      "bytes": 185521080,
+      "sha256": "b760628a29e8f7e50237379d2ba4f4aaf4400b771706347032a80bc032524856",
+      "fed_conversations": {
+        "agent_instruct_tflan": 1730,
+        "agent_instruct_react": 1730,
+        "toolbench_tflan_60p_r10r5u7": 5530,
+        "toolbench_instruct_j1s1_3k": 5530
+      },
+      "normalized_input_sha256": "e67470488beec5b7dbc132d818185f9dc2c3fa5d39859dc59e27573e90582fca",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {
+        "agent_instruct_react": 1,
+        "agent_instruct_tflan": 1
+      },
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    }
+  ],
+  "shuffle_seed": 7,
+  "first_32000_source_counts": {
+    "tulu3": 4287,
+    "orca": 4204,
+    "agent_flan": 5622,
+    "xlam": 4393,
+    "ultrachat": 3193,
+    "openhermes": 3171,
+    "toolace": 3164,
+    "glaive": 3219,
+    "hermes_fc": 747
+  },
+  "note": "Rebuilt original nine-source recipe; not the unavailable historical byte-for-byte mix"
+}

lineages/corrected-20260930-v2/recovery/backup-manifest.json

@@ -0,0 +1,119 @@
+{
+  "checkpoint": "lineages/corrected-20260930-v2/gpu_eqprop_2075000_20260930_214548.bin",
+  "checkpoint_sha256": "96673f09132d5a0bb2adf5664f4e3839567bbb6371a07b16b46714f3967e9b33",
+  "captured_utc": "2026-09-30T21:48:18.852227+00:00",
+  "files": {
+    "data/corrected-mix/mix_sft_sparse.bin": {
+      "bytes": 810830240,
+      "sha256": "425f2adaa8ab2a380b273d7abba3401855fcd792475c742627c0befa419273a9"
+    },
+    "data/corrected-mix/mix_manifest.json": {
+      "bytes": 7067,
+      "sha256": "bf22f42a0fd2fdcbdc23e60821e0614cd1bc5ab69b7c1589efc762c5adc4c624"
+    },
+    "data/language_baseline/vocab_sparse.json": {
+      "bytes": 106816698,
+      "sha256": "23d96f815a5904045899fa304988fb011e21a6b25b612d729b8d833ae5e7388e"
+    },
+    "data/language_baseline/train_corpus_sparse.bin": {
+      "bytes": 66816546,
+      "sha256": "a9b901c8c02b35eebe638abc0bc8ae551e359f51370890733ac917f0c8a97916"
+    },
+    "data/language_baseline/sft_corpus_sparse.bin": {
+      "bytes": 13200476,
+      "sha256": "91cc73e689d8e8e457221d3a20bb4d552cd9d2e5df1c1ed2f7ad2ce5c796cd60"
+    },
+    "data/language_baseline/recovery_manifest.json": {
+      "bytes": 703,
+      "sha256": "aac6d1a44e1037fcac4de6b3a9cc8de1e714c357f7495e9aff4fe6309dd561cb"
+    },
+    "data/slots/compiler_physics.nysa": {
+      "bytes": 48815,
+      "sha256": "052fc7dee4b1081392051b9fde2fac6533aa77e82dbea56ac32c27a67ced6cf8"
+    },
+    "data/slots/speech_align.nysv": {
+      "bytes": 1490468,
+      "sha256": "fea716002f75cde8a4567d64e28c14e353c3cdb349cd9ec8ecf3c991f52fbf8c"
+    },
+    "data/slots/speech_slot.nysv": {
+      "bytes": 15284,
+      "sha256": "2988cc801e2b95d6ebba35d335ec656486bc0fe0b5938d071a536c63879aca0c"
+    },
+    "data/slots/speech_vocoder.nyvc": {
+      "bytes": 20500,
+      "sha256": "028d0e759f9721b2110d8527028e7de3d80d5b611401d33db895d48e2f2df4d1"
+    },
+    "data/slots/recovery_manifest.json": {
+      "bytes": 3007,
+      "sha256": "b74dc14a623e7a4e1b9b1726d1c162a2e23cc19d373e9f53e1fd9064eb46dc35"
+    },
+    "gpu_eqprop/build_cuda.sh": {
+      "bytes": 287,
+      "sha256": "8c2148c696f5f4520b9cfa13bc6e80accc3de5630e449de0197391877db13173"
+    },
+    "gpu_eqprop/run_cuda_l40s.sh": {
+      "bytes": 640,
+      "sha256": "7f0360130f5d5f28c22e40310b9f6cec532ee0d8afd2cd1cf3afdd319375f96c"
+    },
+    "gpu_eqprop/run_qwen_live.py": {
+      "bytes": 6718,
+      "sha256": "deac34a492afb95687a97200955debb38d8a1f4e2c4bf39e8e6a64315e815ffb"
+    },
+    "gpu_eqprop/start_qwen_l40s.sh": {
+      "bytes": 3840,
+      "sha256": "b018e78b46355d022614352b362ee8bdc3bf8e701758cf97b60a7419ef33b0f8"
+    },
+    "gpu_eqprop/qwen_live.py": {
+      "bytes": 12912,
+      "sha256": "40ee3d2f4ba916f3d93db3f515a21af1feec3a1572b9d782798711ae7d787cf7"
+    },
+    "gpu_eqprop/validate_curriculum.py": {
+      "bytes": 3744,
+      "sha256": "d433f10fc417e2a87154c2c0e9721271d084ccb12f6bcda335c2a995cf79af02"
+    },
+    "gpu_eqprop/eqprop_gpu.cu": {
+      "bytes": 85834,
+      "sha256": "79f4648ab7b8e7964fea5d65fd4b8812ffff986daee648c2c182ddc09e58a5c0"
+    },
+    "gpu_eqprop/distill_stdin.h": {
+      "bytes": 4590,
+      "sha256": "6ad021d70316d74f29a43359f3436669d57827c84bdd47919e9c907f75c42eb3"
+    },
+    "gpu_eqprop/cuda_self_test.h": {
+      "bytes": 8128,
+      "sha256": "96e95af580d1d133cf72c7636f2da52ef0358f4d7e7978c5050029f8f61e0ff2"
+    },
+    "gpu_eqprop/hf_checkpoint_service.py": {
+      "bytes": 22182,
+      "sha256": "267d5da011641fb30aeba219afd8a835c1b892420fcac28c0c11557635db294a"
+    },
+    "gpu_eqprop/start_backup_services.py": {
+      "bytes": 1845,
+      "sha256": "de96145ac8e0ac90b48a72f9e199b5c7879e29967f9a52d5b5bc28493cd4c56f"
+    },
+    "gpu_eqprop/live_status.py": {
+      "bytes": 4514,
+      "sha256": "e9ae43c50ea0ae723f4ba0162c7a951bffccf3317abdd7adae7aa2faadf82662"
+    },
+    "gpu_eqprop/build_corrected_mix.py": {
+      "bytes": 10711,
+      "sha256": "a2bcd06abe180432c009d84b6a298b9c6d893747a60f6a16f4eea5977136b27f"
+    },
+    "hierarchical_tokenizer.py": {
+      "bytes": 4963,
+      "sha256": "e7bacce12c795901359a57dbe2fc53915aa79f9a9c446ec5725c3e6e3f4a809f"
+    },
+    "source_checkpoint.json": {
+      "bytes": 422,
+      "sha256": "bda715ec4a981fd23d2164206b37956f639102fa20cd7c621f93bf81c018a8cc"
+    },
+    "lineage.json": {
+      "bytes": 452,
+      "sha256": "1182cc66a6e857ca7ad956a24e3b8e9f922af73ad7c679bf815c870cdfd6ba37"
+    },
+    "recovery_policy.json": {
+      "bytes": 3800,
+      "sha256": "551addf5606189ac9d3c0e133773d477971729e092af82c1d6e90a2b3a277cb0"
+    }
+  }
+}

lineages/corrected-20260930-v2/recovery/data/corrected-mix/mix_manifest.json

@@ -0,0 +1,187 @@
+{
+  "verified": true,
+  "records": 2050000,
+  "bytes": 810830240,
+  "sha256": "425f2adaa8ab2a380b273d7abba3401855fcd792475c742627c0befa419273a9",
+  "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649",
+  "vocab_sha256": "23d96f815a5904045899fa304988fb011e21a6b25b612d729b8d833ae5e7388e",
+  "sources": [
+    {
+      "name": "tulu3",
+      "repo": "allenai/tulu-3-sft-mixture",
+      "revision": "b14afda60f1bbebe55d5d2fa1e4df5042f97f8be",
+      "config": null,
+      "records": 273333,
+      "target_records": 273333,
+      "bytes": 74691934,
+      "sha256": "a6791c7f5ebfbf73982f16200c57da1f986ec82835e26d310337723811488efe",
+      "fed_conversations": {
+        "train": 14280
+      },
+      "normalized_input_sha256": "43a1ceebba233ccc1295c0e6e4c38df03ca107aeca88ba76aa8ebdff3db05739",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "openhermes",
+      "repo": "teknium/OpenHermes-2.5",
+      "revision": "b82037821055c377bed0d495e72e46de3bc72e84",
+      "config": null,
+      "records": 205000,
+      "target_records": 205000,
+      "bytes": 37265984,
+      "sha256": "a14995d3982265093dade0e5456bf4e807adc1606502a008e010bf1cae91a86e",
+      "fed_conversations": {
+        "train": 9472
+      },
+      "normalized_input_sha256": "0c8290012cd577e5fa0e719b3e1a109d0be0e7352a180fcc87d558123f96b55d",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "ultrachat",
+      "repo": "HuggingFaceH4/ultrachat_200k",
+      "revision": "8049631c405ae6576f93f445c6b8166f76f5505a",
+      "config": null,
+      "records": 205000,
+      "target_records": 205000,
+      "bytes": 54089028,
+      "sha256": "ca6fe7a2c74cf1612a51d6c8b425c4869a5147f56647581a318b148a1660fca0",
+      "fed_conversations": {
+        "train_sft": 8211
+      },
+      "normalized_input_sha256": "c5e3c60cfe787c0ee6dc15a934e2d9f0de46a866faafb8d871464f69972301de",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "xlam",
+      "repo": "Salesforce/xlam-function-calling-60k",
+      "revision": "26d14ebfe18b1f7b524bd39b404b50af5dc97866",
+      "config": "dataset",
+      "records": 273333,
+      "target_records": 273333,
+      "bytes": 133978174,
+      "sha256": "35fa9266bf1f5080dd52798145a68fcfaae141e5ae7060e9049d8b5518dc9f83",
+      "fed_conversations": {
+        "train": 11216
+      },
+      "normalized_input_sha256": "4d384db283209ff38aecbd1fc07498e9d2e9158aa5c151e488a6e3bcfa7dba73",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "toolace",
+      "repo": "Team-ACE/ToolACE",
+      "revision": "6bda777c88d21e5a204703c1ee45597a8fa4f734",
+      "config": null,
+      "records": 205000,
+      "target_records": 205000,
+      "bytes": 105319644,
+      "sha256": "4e2351be623bf5d2cb4e6c72fe5454289dbb467055d8ab5c4ef9f9a50cca8b36",
+      "fed_conversations": {
+        "train": 9014
+      },
+      "normalized_input_sha256": "129d36d3541f946be6d6199eaed8ab7a796cdd54ffc45abe735f9837c79e7e3d",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "glaive",
+      "repo": "glaiveai/glaive-function-calling-v2",
+      "revision": "e7f4b6456019f5d8bcb991ef0dd67d8ff23221ac",
+      "config": null,
+      "records": 205000,
+      "target_records": 205000,
+      "bytes": 80593548,
+      "sha256": "c1e0f9b1b3e57bea3d726ee282748959aaeefdce5a01dea4d10e980a152ee1fa",
+      "fed_conversations": {
+        "train": 8320
+      },
+      "normalized_input_sha256": "9a8a47aca6a49e0054690a267bdc610e9f9ffc2b67ae3782f00aae34921d33b7",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "hermes_fc",
+      "repo": "NousResearch/hermes-function-calling-v1",
+      "revision": "dae3e1d28cfbcf4b915c04ea1e072030529b4bda",
+      "config": "func_calling_singleturn",
+      "records": 47325,
+      "target_records": 136666,
+      "bytes": 24325054,
+      "sha256": "b83105e2de0c9317cbdf064b8a022c0e2e6994b20ee95a9e2aee28fa7a4ea2b3",
+      "fed_conversations": {
+        "train": 1893
+      },
+      "normalized_input_sha256": "f9faf972ab53f865c517574dd83540982ec94b3d19024acf941bd627117e09d5",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "orca",
+      "repo": "microsoft/orca-agentinstruct-1M-v1",
+      "revision": "86d609183249ff8037eae33d76ebca3af9390ea8",
+      "config": null,
+      "records": 273333,
+      "target_records": 273333,
+      "bytes": 115045826,
+      "sha256": "b9194dd3c45ac353809a19c851ef5935ef06d568c46943ab021963a4a8adf677",
+      "fed_conversations": {
+        "analytical_reasoning": 1873,
+        "code_": 1873,
+        "rag": 1872,
+        "follow_up": 1872,
+        "fs_cot_flow": 1872,
+        "open_domain_qa": 1872
+      },
+      "normalized_input_sha256": "c4b165c28a5e4ba92304e38d23f2da93cf691eb9eb137b847aa9f6f5592b7180",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "agent_flan",
+      "repo": "internlm/Agent-FLAN",
+      "revision": "8b25999e795a58b264fcb51e8746edb2faee9161",
+      "config": null,
+      "records": 362676,
+      "target_records": 362676,
+      "bytes": 185521080,
+      "sha256": "b760628a29e8f7e50237379d2ba4f4aaf4400b771706347032a80bc032524856",
+      "fed_conversations": {
+        "agent_instruct_tflan": 1730,
+        "agent_instruct_react": 1730,
+        "toolbench_tflan_60p_r10r5u7": 5530,
+        "toolbench_instruct_j1s1_3k": 5530
+      },
+      "normalized_input_sha256": "e67470488beec5b7dbc132d818185f9dc2c3fa5d39859dc59e27573e90582fca",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {
+        "agent_instruct_react": 1,
+        "agent_instruct_tflan": 1
+      },
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    }
+  ],
+  "shuffle_seed": 7,
+  "first_32000_source_counts": {
+    "tulu3": 4287,
+    "orca": 4204,
+    "agent_flan": 5622,
+    "xlam": 4393,
+    "ultrachat": 3193,
+    "openhermes": 3171,
+    "toolace": 3164,
+    "glaive": 3219,
+    "hermes_fc": 747
+  },
+  "note": "Rebuilt original nine-source recipe; not the unavailable historical byte-for-byte mix"
+}

lineages/corrected-20260930-v2/recovery/data/language_baseline/recovery_manifest.json

@@ -0,0 +1,22 @@
+{
+  "repo": "YNSScarSaiyan/nys-corpus",
+  "revision": "7eb0b0dd1f3122a4189d33ae6cc13c21d0a25774",
+  "files": {
+    "vocab_sparse.json": {
+      "bytes": 106816698,
+      "sha256": "23d96f815a5904045899fa304988fb011e21a6b25b612d729b8d833ae5e7388e"
+    },
+    "train_corpus_sparse.bin": {
+      "bytes": 66816546,
+      "sha256": "a9b901c8c02b35eebe638abc0bc8ae551e359f51370890733ac917f0c8a97916"
+    },
+    "sft_corpus_sparse.bin": {
+      "bytes": 13200476,
+      "sha256": "91cc73e689d8e8e457221d3a20bb4d552cd9d2e5df1c1ed2f7ad2ce5c796cd60"
+    },
+    "distill_corpus_sparse.bin": {
+      "bytes": 15363524,
+      "sha256": "e1e27ee163ef7288fa6d68230fe167ef368e553ac8f19922019d80f87eb7e4e4"
+    }
+  }
+}

lineages/corrected-20260930-v2/recovery/data/language_baseline/vocab_sparse.json

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

lineages/corrected-20260930-v2/recovery/data/slots/recovery_manifest.json

@@ -0,0 +1,108 @@
+{
+  "verified": true,
+  "checks": {
+    "2_compiler": true,
+    "4_speech": true,
+    "hard": true,
+    "sft": true,
+    "distill": true,
+    "source_checkpoint_sha256_unchanged": true
+  },
+  "record_counts": {
+    "speech_align.nysv": 305,
+    "speech_slot.nysv": 6,
+    "compiler_physics.nysa": 412
+  },
+  "checkpoint": "gpu_eqprop_1915000_20260913_095122.bin",
+  "checkpoint_sha256": "406a691b1ac42112705c5193814f76ff064f922161d48ab0e3f67452403bbeec",
+  "published_revision": "6f1f1e314e6d680f0e1541ddc6b1f6590b46cf40",
+  "vocoder_sha256": "028d0e759f9721b2110d8527028e7de3d80d5b611401d33db895d48e2f2df4d1",
+  "original_slot_sha256": {
+    "compiler_physics.nysa": "052fc7dee4b1081392051b9fde2fac6533aa77e82dbea56ac32c27a67ced6cf8",
+    "speech_slot.nysv": "2fd8be22d9408bb5d88a11b1c27c6c0ac80f42d7808f93a8d1ed31734a5f5cee",
+    "speech_align.nysv": "274f4d2e283a6b1de14eb73d4ea4f6c2e10fc18aff8bd7f1d1aca29b5e1430c5"
+  },
+  "actual": {
+    "slots": {
+      "1_language": {
+        "mix": {
+          "acc": null,
+          "hits": 0,
+          "n": 0,
+          "in_pool": 0,
+          "in_pool_frac": null
+        },
+        "hard": {
+          "acc": 0.0,
+          "hits": 0,
+          "n": 32,
+          "in_pool": 4,
+          "in_pool_frac": 0.125
+        },
+        "sft": {
+          "acc": 0.0,
+          "hits": 0,
+          "n": 32,
+          "in_pool": 30,
+          "in_pool_frac": 0.9375
+        },
+        "distill": {
+          "acc": 0.0,
+          "hits": 0,
+          "n": 32,
+          "in_pool": 18,
+          "in_pool_frac": 0.5625
+        }
+      },
+      "2_compiler": {
+        "clamped_free": {
+          "acc": 0.6385690789473685,
+          "hits": 1553,
+          "n": 2432,
+          "in_pool": 2432,
+          "in_pool_frac": 1.0
+        },
+        "spin_free": {
+          "acc": 0.4004934210526316,
+          "hits": 974,
+          "n": 2432,
+          "in_pool": 2432,
+          "in_pool_frac": 1.0
+        },
+        "n_recs": 64,
+        "n_free": 38
+      },
+      "4_speech": {
+        "acc": 0.10825043885313049,
+        "hits": 185,
+        "n": 1709,
+        "in_pool": 700,
+        "in_pool_frac": 0.4095962551199532
+      }
+    },
+    "headline": {
+      "language": 0.0,
+      "compiler": 0.6385690789473685,
+      "speech": 0.10825043885313049
+    }
+  },
+  "limitation": "Original live mix is unavailable; its score and aggregate language headline cannot be reproduced.",
+  "staged_files": {
+    "compiler_physics.nysa": {
+      "bytes": 48815,
+      "sha256": "052fc7dee4b1081392051b9fde2fac6533aa77e82dbea56ac32c27a67ced6cf8"
+    },
+    "speech_vocoder.nyvc": {
+      "bytes": 20500,
+      "sha256": "028d0e759f9721b2110d8527028e7de3d80d5b611401d33db895d48e2f2df4d1"
+    },
+    "speech_align.nysv": {
+      "bytes": 1490468,
+      "sha256": "fea716002f75cde8a4567d64e28c14e353c3cdb349cd9ec8ecf3c991f52fbf8c"
+    },
+    "speech_slot.nysv": {
+      "bytes": 15284,
+      "sha256": "2988cc801e2b95d6ebba35d335ec656486bc0fe0b5938d071a536c63879aca0c"
+    }
+  }
+}

lineages/corrected-20260930-v2/recovery/data/slots/speech_align.nysv

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

lineages/corrected-20260930-v2/recovery/gpu_eqprop/build_corrected_mix.py

@@ -0,0 +1,217 @@
+"""Rebuild all nine original SFT sources using frozen NYS IDs. No training/upload.
+
+Pinned schemas are normalized explicitly. Every source and every requested split
+must contribute; failed or empty sources fail the build, never shrink the diet.
+"""
+import argparse
+from array import array
+from collections import Counter
+import hashlib
+import json
+import mmap
+import os
+from pathlib import Path
+import random
+import re
+import struct
+import subprocess
+
+VOCAB_SHA = '23d96f815a5904045899fa304988fb011e21a6b25b612d729b8d833ae5e7388e'
+SPECS = [
+ ('tulu3',4,['train'],None), ('openhermes',3,['train'],None),
+ ('ultrachat',3,['train_sft'],None), ('xlam',4,['train'],'dataset'),
+ ('toolace',3,['train'],None), ('glaive',3,['train'],None),
+ ('hermes_fc',2,['train'],'func_calling_singleturn'),
+ ('orca',4,['analytical_reasoning','code_','rag','follow_up','fs_cot_flow','open_domain_qa'],None),
+ ('agent_flan',4,['agent_instruct_tflan','agent_instruct_react','toolbench_tflan_60p_r10r5u7','toolbench_instruct_j1s1_3k'],None),
+]
+
+def sha(path):
+    with Path(path).open('rb') as f:
+        return hashlib.file_digest(f, 'sha256').hexdigest()
+
+def text(v):
+    if v is None: return ''
+    return v if isinstance(v,str) else json.dumps(v,ensure_ascii=False,separators=(',',':'))
+
+def decode(v):
+    return json.loads(v) if isinstance(v,str) else v
+
+class NoTargets(ValueError):
+    pass
+
+def messages(row):
+    out=[]
+    conv=row.get('messages') or row.get('conversations') or row.get('conversation')
+    if conv:
+        conv=decode(conv)
+        for m in conv:
+            m=decode(m)
+            role=(m.get('role') or m.get('from') or '').lower()
+            role={'human':'user','gpt':'assistant','function':'tool','tool_response':'tool'}.get(role,role)
+            if role not in ('user','assistant','system','tool'):
+                raise ValueError(f'Unknown conversation role {role!r}')
+            content=text(m.get('content',m.get('value')))
+            if m.get('tool_calls'):
+                content += '\n'+text(m['tool_calls'])
+            if m.get('loss') is False:
+                role='tool' # context only; not an assistant target
+            if content.strip(): out.append(dict(role=role,content=content))
+        system=row.get('system') or row.get('system_prompt')
+        if system and not any(m['role']=='system' for m in out):
+            out.insert(0,dict(role='system',content=text(system)))
+    elif row.get('query') is not None and row.get('answers') is not None:
+        out=[dict(role='user',content=text(row['query'])+'\n tools '+text(row.get('tools'))),
+             dict(role='assistant',content=text(row['answers']))]
+    elif isinstance(row.get('chat'),str):
+        if row.get('system'): out.append(dict(role='system',content=text(row['system'])))
+        parts=re.split(r'(?:^|\n)(USER|ASSISTANT|FUNCTION RESPONSE):\s*', row['chat'])
+        if len(parts)<3 or parts[0].strip(): raise ValueError('Unsupported Glaive chat framing')
+        for role,body in zip(parts[1::2],parts[2::2]):
+            out.append(dict(role={'USER':'user','ASSISTANT':'assistant','FUNCTION RESPONSE':'tool'}[role],
+                            content=body.replace('<|endoftext|>','').strip()))
+    else:
+        raise ValueError(f'Unsupported source schema: {sorted(row)}')
+    if not any(m['role']=='assistant' and m['content'].strip() for m in out):
+        raise NoTargets('No assistant targets in conversation')
+    return out
+
+def offsets(path, expected):
+    off=array('Q')
+    with open(path,'rb') as f:
+        with mmap.mmap(f.fileno(),0,access=mmap.ACCESS_READ) as mm:
+            count,=struct.unpack_from('<I',mm,0)
+            if count!=expected: raise ValueError(f'Incomplete source {path}: {count} != {expected}')
+            pos=4
+            for _ in range(count):
+                off.append(pos)
+                n,=struct.unpack_from('<H',mm,pos)
+                if not 2<=n<=128: raise ValueError('Invalid sparse record length')
+                end=pos+2+4*n
+                if end>len(mm): raise ValueError('Truncated sparse record')
+                ids=struct.unpack_from('<'+'I'*n,mm,pos+2)
+                if max(ids)>=5_000_000: raise ValueError('Invalid sparse token ID')
+                pos=end
+            if pos!=len(mm): raise ValueError('Trailing corpus bytes')
+    return off
+
+def build(args):
+    if args.token_file:
+        os.environ['HF_TOKEN']=args.token_file.read_text().strip()
+    from datasets import load_dataset
+    from huggingface_hub import hf_hub_download
+    def open_stream(name, info, config, sp):
+        if name=='agent_flan':
+            # Its published Arrow feature declaration omits the optional `type`
+            # field in some splits. Read the pinned JSONL rows without that cast.
+            p=hf_hub_download(info['repo'],'data/'+sp+'.jsonl',repo_type='dataset',revision=info['revision'])
+            def rows():
+                with open(p,encoding='utf-8') as f:
+                    for line in f:
+                        if line.strip(): yield json.loads(line)
+            return iter(rows())
+        return iter(load_dataset(info['repo'],name=config,split=sp,revision=info['revision'],streaming=True))
+    out=args.output
+    out.mkdir(parents=True,exist_ok=True)
+    if sha(args.vocab)!=VOCAB_SHA: raise ValueError('Wrong frozen vocabulary')
+    discovered=json.loads(args.discovery.read_text())
+    converter_sha=sha(args.converter)
+    reports=[]
+    used=0
+    for idx,(spec,info) in enumerate(zip(SPECS,discovered)):
+        name,weight,splits,config=spec
+        quota=args.records-used if idx==len(SPECS)-1 else args.records*weight//30
+        path=out/(name+'.bin')
+        report_path=out/(name+'.json')
+        if report_path.exists():
+            report=json.loads(report_path.read_text())
+            if report.get('converter_sha256')!=converter_sha or report['sha256']!=sha(path) or report.get('target_records',report['records'])!=quota or report['revision']!=info['revision']:
+                raise ValueError('Prior build identity differs')
+            offsets(path,report['records'])
+            reports.append(report)
+            used+=report['records']
+            continue
+        streams={sp:open_stream(name,info,config,sp) for sp in splits}
+        empty=Counter()
+        def next_messages(sp,it):
+            while True:
+                row=next(it)
+                try: return messages(row)
+                except NoTargets: empty[sp]+=1
+        # Check each schema before starting the converter; preserve the first row.
+        first={sp:next_messages(sp,it) for sp,it in streams.items()}
+        counts=Counter()
+        source_hash=hashlib.sha256()
+        with (out/(name+'.convert.log')).open('w') as log:
+            proc=subprocess.Popen([str(args.converter),'--vocab',str(args.vocab),'--output',str(path),
+                                   '--limit',str(quota),'--max-per-convo','25','--flush-every','1000'],
+                                  stdin=subprocess.PIPE,stderr=log,text=True)
+            try:
+                while proc.poll() is None and streams:
+                    for sp,it in list(streams.items()):
+                        try:
+                            ms=first.pop(sp) if sp in first else next_messages(sp,it)
+                        except StopIteration:
+                            del streams[sp]
+                            continue
+                        line=json.dumps({'messages':ms},ensure_ascii=False)+'\n'
+                        proc.stdin.write(line)
+                        counts[sp]+=1
+                        source_hash.update(line.encode())
+            except BrokenPipeError:
+                pass
+            except BaseException:
+                proc.kill(); proc.wait(); raise
+            finally:
+                try: proc.stdin.close()
+                except BrokenPipeError: pass
+            if proc.wait()!=0: raise RuntimeError(f'Converter failed: {name}')
+        actual=struct.unpack('<I',path.read_bytes()[:4])[0]
+        if actual<=0 or actual>quota: raise ValueError('Empty source or quota overrun')
+        offsets(path,actual)
+        if not all(counts[sp]>0 for sp in splits): raise ValueError('Missing split')
+        report=dict(name=name,repo=info['repo'],revision=info['revision'],config=config,
+                    records=actual,target_records=quota,bytes=path.stat().st_size,sha256=sha(path),fed_conversations=dict(counts),
+                    normalized_input_sha256=source_hash.hexdigest(),max_per_conversation=25,
+                    skipped_no_assistant_targets=dict(empty),converter_sha256=converter_sha)
+        report_path.write_text(json.dumps(report,indent=2))
+        reports.append(report)
+        used+=actual
+        print(json.dumps(report),flush=True)
+    # Shuffle record order globally so the first live rotations include all sources.
+    handles=[open(out/(r['name']+'.bin'),'rb') for r in reports]
+    maps=[mmap.mmap(f.fileno(),0,access=mmap.ACCESS_READ) for f in handles]
+    record_offsets=[offsets(out/(r['name']+'.bin'),r['records']) for r in reports]
+    order=array('Q', ((i<<32)|j for i,r in enumerate(reports) for j in range(r['records'])))
+    random.Random(7).shuffle(order)
+    temp=out/'mix_sft_sparse.bin.writing'
+    first_counts=Counter()
+    with temp.open('wb') as f:
+        f.write(struct.pack('<I',len(order)))
+        for at,key in enumerate(order):
+            i,j=key>>32,key&0xffffffff
+            pos=record_offsets[i][j]
+            n,=struct.unpack_from('<H',maps[i],pos)
+            f.write(maps[i][pos:pos+2+4*n])
+            if at<32000: first_counts[reports[i]['name']]+=1
+        f.flush(); os.fsync(f.fileno())
+    offsets(temp,args.records)
+    final=out/'mix_sft_sparse.bin'
+    temp.replace(final)
+    for m,f in zip(maps,handles): m.close(); f.close()
+    manifest=dict(verified=True,records=args.records,bytes=final.stat().st_size,sha256=sha(final),
+                  converter_sha256=converter_sha,
+                  vocab_sha256=VOCAB_SHA,sources=reports,shuffle_seed=7,first_32000_source_counts=dict(first_counts),
+                  note='Rebuilt original nine-source recipe; not the unavailable historical byte-for-byte mix')
+    (out/'mix_manifest.json').write_text(json.dumps(manifest,indent=2))
+    print(json.dumps(manifest),flush=True)
+
+if __name__=='__main__':
+    ap=argparse.ArgumentParser(description=__doc__)
+    ap.add_argument('--discovery',type=Path,required=True)
+    ap.add_argument('--vocab',type=Path,required=True)
+    ap.add_argument('--converter',type=Path,required=True)
+    ap.add_argument('--output',type=Path,required=True)
+    ap.add_argument('--records',type=int,default=2_050_000)
+    ap.add_argument('--token-file',type=Path)
+    build(ap.parse_args())

lineages/corrected-20260930-v2/recovery/gpu_eqprop/build_cuda.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cd -- "$(dirname -- "${BASH_SOURCE[0]}")"
+NVCC="${NVCC:-/data/yue-cuda/cuda/toolkit/bin/nvcc}"
+if [[ ! -x "$NVCC" ]]; then NVCC="$(command -v nvcc)"; fi
+"$NVCC" -O3 -std=c++17 -gencode=arch=compute_89,code=sm_89 \
+  -o eqprop_gpu_cuda eqprop_gpu.cu

lineages/corrected-20260930-v2/recovery/gpu_eqprop/cuda_self_test.h

@@ -0,0 +1,177 @@
+// Independent serial RK4 reference for the CUDA port. Synthetic data only.
+struct CpuFixture {
+    std::vector<double> theta, amp, omega;
+    std::vector<uint64_t> off;
+    std::vector<uint32_t> col;
+    std::vector<float> K;
+};
+
+static double reference_step(CpuFixture& h, const StepPack& p, int n_mean,
+                             double lr, bool settle, bool neutral,
+                             std::vector<double>& settled) {
+    const size_t m = p.S.size();
+    std::vector<int> loc(h.theta.size(), -1);
+    std::vector<double> th(m), amps(m), start, free_phase;
+    for (size_t i = 0; i < m; ++i) {
+        loc[p.S[i]] = (int)i;
+        th[i] = settle && neutral && i >= (size_t)p.n_prompt ? 0.0 : h.theta[p.S[i]];
+        amps[i] = i < (size_t)p.n_prompt ? 1.0 : 0.0;
+    }
+    auto wrap = [](double x) {
+        if (x > M_PI) x -= 2 * M_PI;
+        else if (x < -M_PI) x += 2 * M_PI;
+        return x;
+    };
+    double mean = 0;
+    auto derivative = [&](const std::vector<double>& x, bool nudge) {
+        std::vector<double> d(m);
+        for (size_t i = 0; i < m; ++i) {
+            auto id = p.S[i];
+            double sum = 0;
+            for (uint64_t e = h.off[id]; e < h.off[id + 1]; ++e) {
+                int j = loc[h.col[e]];
+                if (j >= 0 && amps[j] > 1e-5)
+                    sum += (double)h.K[e] * amps[j] * std::sin(x[j] - x[i]);
+            }
+            d[i] = g_omega_scale * h.omega[id] + sum;
+            if (nudge) {
+                for (size_t j = 0; j < p.nudge_id.size(); ++j)
+                    if (p.nudge_id[j] == id)
+                        d[i] += p.nudge_beta[j] * std::sin(mean - x[i]);
+            }
+        }
+        return d;
+    };
+    auto advance = [&](bool nudge, int steps) {
+        for (int step = 0; step < steps; ++step) {
+            auto x = th;
+            auto a = derivative(x, nudge);
+            for (size_t i = 0; i < m; ++i) th[i] = wrap(x[i] + .5 * kDt * a[i]);
+            auto b = derivative(th, nudge);
+            for (size_t i = 0; i < m; ++i) th[i] = wrap(x[i] + .5 * kDt * b[i]);
+            auto c = derivative(th, nudge);
+            for (size_t i = 0; i < m; ++i) th[i] = wrap(x[i] + kDt * c[i]);
+            auto d = derivative(th, nudge);
+            for (size_t i = 0; i < m; ++i)
+                th[i] = wrap(x[i] + kDt / 6 * (a[i] + 2*b[i] + 2*c[i] + d[i]));
+        }
+    };
+    advance(false, kRk4Free);
+    double X = 0, Y = 0;
+    for (int i = 0; i < n_mean; ++i) { X += std::cos(th[i]); Y += std::sin(th[i]); }
+    mean = std::atan2(Y, X);
+    if (settle) { settled = th; return mean; }
+    start = th;
+    for (size_t i = 0; i < m; ++i)
+        for (size_t j = 0; j < p.nudge_id.size(); ++j)
+            if (p.nudge_id[j] == p.S[i])
+                amps[i] = std::max(amps[i], std::min(1.0, std::abs(p.nudge_beta[j])));
+    advance(false, kRk4Nudge);
+    free_phase = th;
+    th = start;
+    advance(true, kRk4Nudge);
+    double contrast = 0;
+    int edges = 0;
+    for (size_t i = 0; i < m; ++i) {
+        auto id = p.S[i];
+        h.theta[id] = th[i];
+        h.amp[id] = 0;
+        if (amps[i] <= .1) continue;
+        for (uint64_t e = h.off[id]; e < h.off[id + 1]; ++e) {
+            int j = loc[h.col[e]];
+            if (j < 0 || amps[j] <= .1) continue;
+            double dc = std::cos(th[i] - th[j]) - std::cos(free_phase[i] - free_phase[j]);
+            contrast += dc;
+            ++edges;
+            h.K[e] = std::max(-kKMax, std::min(kKMax, h.K[e] + (float)(lr * dc)));
+        }
+    }
+    return edges ? contrast / edges : 0;
+}
+
+template<class T> static double max_error(const std::vector<T>& a, const std::vector<T>& b) {
+    if (a.size() != b.size()) return INFINITY;
+    double result = 0;
+    for (size_t i = 0; i < a.size(); ++i) {
+        if (!std::isfinite((double)a[i]) || !std::isfinite((double)b[i])) return INFINITY;
+        result = std::max(result, std::abs((double)a[i] - (double)b[i]));
+    }
+    return result;
+}
+
+static int run_self_test(size_t cap) {
+    const uint32_t N = 4096, k = 32;
+    GpuState g = alloc_state(N, k, cap);
+    CpuFixture h;
+    host_init_graph(N, k, h.theta, h.amp, h.omega, h.off, h.col, h.K);
+    auto read_state = [&]() {
+        CpuFixture out = h;
+        CUDA_CHECK(cudaMemcpy(out.theta.data(), g.theta, N * sizeof(double), cudaMemcpyDeviceToHost));
+        CUDA_CHECK(cudaMemcpy(out.amp.data(), g.amp, N * sizeof(double), cudaMemcpyDeviceToHost));
+        CUDA_CHECK(cudaMemcpy(out.omega.data(), g.omega, N * sizeof(double), cudaMemcpyDeviceToHost));
+        CUDA_CHECK(cudaMemcpy(out.K.data(), g.K, out.K.size() * sizeof(float), cudaMemcpyDeviceToHost));
+        return out;
+    };
+    for (int test = 0; test < 3; ++test) {
+        upload(g, h.theta, h.amp, h.omega, h.off, h.col, h.K);
+        std::vector<uint32_t> prompt = {1, 2, 3, 4, 5};
+        std::vector<std::pair<uint32_t, double>> nudges = {{6, 1.5}, {7, -1.5}, {8, .05}};
+        if (test == 2) {
+            prompt.clear(); nudges.clear();
+            for (uint32_t i = 1; i <= 128; ++i) prompt.push_back(i);
+            for (uint32_t i = 129; i <= 256; ++i) nudges.emplace_back(i, i % 2 ? 1.5 : -1.5);
+        }
+        auto p0 = pack_step(prompt, nudges, N);
+        auto p = p0;
+        fill_prompt_neighbors(g, p, kFillNeighbors);
+        g_omega_scale = test == 1 ? 1.0 : .01;
+        double lr = test == 2 ? 250 : .05; // exercise clipping as well as normal learning rate
+        CpuFixture expected = h;
+        std::vector<double> unused;
+        double ref = reference_step(expected, p, p0.n_prompt, lr, false, false, unused);
+        double got = launch_step(g, p0, lr);
+        auto actual = read_state();
+        double th = max_error(actual.theta, expected.theta), kw = max_error(actual.K, expected.K);
+        double dc = std::abs(got - ref);
+        std::printf("[self-test] case=%d active=%zu theta=%.3g K=%.3g contrast=%.3g\n", test, p.S.size(), th, kw, dc);
+        if (th > 1e-10 || kw > 1e-6 || !std::isfinite(got) || dc > 1e-10 ||
+            max_error(actual.amp, expected.amp) != 0 || max_error(actual.omega, h.omega) != 0) return 1;
+    }
+    // Verify neutral and stored-phase inference against the serial reference,
+    // including that inference leaves every model value unchanged.
+    upload(g, h.theta, h.amp, h.omega, h.off, h.col, h.K);
+    g_omega_scale = .01;
+    for (int neutral = 0; neutral <= 1; ++neutral) {
+        auto p = pack_step({1, 2, 3}, {{4, 0}, {5, 0}, {6, 0}}, N);
+        CpuFixture expected = h;
+        std::vector<double> th;
+        double ref = reference_step(expected, p, 3, 0, true, neutral, th);
+        std::vector<SettleRow> rows;
+        double mean = launch_settle(g, {1,2,3}, 0, {4,5,6}, kRk4Free, neutral, rows);
+        if (rows.size() != 3 || !std::isfinite(mean) || std::abs(mean-ref) > 1e-10) return 1;
+        for (size_t i = 0; i < rows.size(); ++i)
+            if (!std::isfinite(rows[i].theta) || std::abs(rows[i].theta-th[i+3]) > 1e-10) return 1;
+        auto actual = read_state();
+        if (max_error(actual.theta,h.theta) || max_error(actual.K,h.K) ||
+            max_error(actual.amp,h.amp) || max_error(actual.omega,h.omega)) return 1;
+    }
+    char temp[] = "/tmp/nys-cuda-test-XXXXXX";
+    if (!mkdtemp(temp)) return 1;
+    Args a;
+    a.save_dir = std::string(temp) + "/snapshots";
+    a.save = std::string(temp) + "/latest.bin";
+    save_snapshot(g, a, 123);
+    load_ckpt(g, a.save);
+    auto roundtrip = read_state();
+    bool ok = !max_error(roundtrip.theta,h.theta) && !max_error(roundtrip.K,h.K) &&
+              !max_error(roundtrip.amp,h.amp) && !max_error(roundtrip.omega,h.omega);
+    // A write failure must be reported, and an existing checkpoint must survive it.
+    ok = ok && !save_ckpt(g, std::string(temp) + "/missing/fail.bin");
+    const auto snapshot = std::filesystem::read_symlink(a.save);
+    std::filesystem::remove(a.save);
+    std::filesystem::remove(snapshot);
+    std::filesystem::remove(a.save_dir);
+    std::filesystem::remove(temp);
+    std::puts(ok ? "[self-test] PASS: CPU parity, read-only settle, checkpoint roundtrip/failure" : "[self-test] FAIL");
+    return ok ? 0 : 1;
+}

lineages/corrected-20260930-v2/recovery/gpu_eqprop/distill_stdin.h

@@ -0,0 +1,98 @@
+// Streaming SDS1: UINT32_MAX record count means consume once, until EOF.
+// Nonblocking parsing handles fragmented pipes; the caller paces rotations.
+#include <fcntl.h>
+#include <stdexcept>
+
+struct DistillStdin {
+    std::vector<unsigned char> buf;
+    bool header = false, eof = false, done = false;
+    uint64_t emitted = 0;
+    uint32_t N;
+    explicit DistillStdin(uint32_t nodes) : N(nodes) {
+        int flags = fcntl(STDIN_FILENO, F_GETFL);
+        if (flags < 0 || fcntl(STDIN_FILENO, F_SETFL, flags | O_NONBLOCK) < 0)
+            throw std::runtime_error("cannot make distill stdin nonblocking");
+    }
+    static uint32_t u32(const unsigned char* p) {
+        return uint32_t(p[0]) | (uint32_t(p[1]) << 8) | (uint32_t(p[2]) << 16) | (uint32_t(p[3]) << 24);
+    }
+    static uint16_t u16(const unsigned char* p) { return p[0] | (uint16_t(p[1]) << 8); }
+    // 1 = record, 0 = temporarily empty, -1 = complete EOF. Malformed input throws.
+    int next(std::vector<uint32_t>& prompt, std::vector<uint32_t>& ids, std::vector<float>& pr) {
+        if (!eof && buf.size() < 8192) {
+            unsigned char chunk[4096];
+            ssize_t n = read(STDIN_FILENO, chunk, sizeof(chunk));
+            if (n > 0) buf.insert(buf.end(), chunk, chunk + n);
+            else if (!n) eof = true;
+            else if (errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR)
+                throw std::runtime_error("distill stdin read failed");
+        }
+        auto incomplete = [&]() -> int {
+            if (eof) throw std::runtime_error("truncated distill stdin record/header");
+            return 0;
+        };
+        if (!header) {
+            if (buf.size() < 8) return incomplete();
+            if (std::memcmp(buf.data(), "SDS1", 4) || u32(buf.data()+4) != UINT32_MAX)
+                throw std::runtime_error("stdin needs streaming SDS1 header (count UINT32_MAX)");
+            buf.erase(buf.begin(), buf.begin()+8);
+            header = true;
+        }
+        if (done) {
+            if (!buf.empty()) throw std::runtime_error("data after distill DONE footer");
+            return eof ? -1 : 0;
+        }
+        if (buf.size() < 2) return incomplete();
+        uint16_t plen = u16(buf.data());
+        if (!plen) {
+            if (buf.size() < 6) return incomplete();
+            if (std::memcmp(buf.data()+2, "DONE", 4))
+                throw std::runtime_error("invalid distill DONE footer");
+            buf.erase(buf.begin(), buf.begin()+6);
+            done = true;
+            if (!buf.empty()) throw std::runtime_error("data after distill DONE footer");
+            return eof ? -1 : 0;
+        }
+        if (!plen || plen > 127) throw std::runtime_error("distill prompt length outside 1..127");
+        size_t soft_at = 2 + 4 * plen;
+        if (buf.size() < soft_at + 2) return incomplete();
+        uint16_t nsoft = u16(buf.data()+soft_at);
+        if (!nsoft || nsoft > 64) throw std::runtime_error("distill target count outside 1..64");
+        size_t bytes = soft_at + 2 + 8*nsoft;
+        if (buf.size() < bytes) return incomplete();
+        prompt.resize(plen); ids.resize(nsoft); pr.resize(nsoft);
+        for (size_t i=0; i<plen; ++i) {
+            prompt[i] = u32(buf.data()+2+4*i);
+            if (prompt[i] >= N) throw std::runtime_error("distill prompt ID outside graph");
+        }
+        double mass = 0;
+        std::unordered_set<uint32_t> seen;
+        for (size_t i=0; i<nsoft; ++i) {
+            ids[i] = u32(buf.data()+soft_at+2+4*i);
+            uint32_t bits = u32(buf.data()+soft_at+2+4*nsoft+4*i);
+            std::memcpy(&pr[i], &bits, 4);
+            if (ids[i] >= N || !seen.insert(ids[i]).second || !std::isfinite(pr[i]) || pr[i] <= 0 || pr[i] > 1)
+                throw std::runtime_error("invalid distill target ID/probability");
+            mass += pr[i];
+        }
+        if (mass > 1.00001) throw std::runtime_error("distill probability mass exceeds 1");
+        buf.erase(buf.begin(), buf.begin()+bytes);
+        ++emitted;
+        return 1;
+    }
+};
+
+static int validate_distill_stdin(uint32_t N) {
+    DistillStdin source(N);
+    std::vector<uint32_t> prompt, ids;
+    std::vector<float> probs;
+    while (true) {
+        int status = source.next(prompt, ids, probs);
+        if (status < 0) break;
+        if (!status) std::this_thread::sleep_for(std::chrono::milliseconds(5));
+    }
+    if (!source.emitted) throw std::runtime_error("distill stream contained no records");
+    std::printf("[stream] validated %llu records, no CUDA allocation or training\n",
+                (unsigned long long)source.emitted);
+    return 0;
+}

lineages/corrected-20260930-v2/recovery/gpu_eqprop/eqprop_gpu.cu

@@ -0,0 +1,2157 @@
+// NYS GPU EqProp — from-scratch CUDA fused kernel.
+// No PyTorch. Compile with nvcc. Caps VRAM. Does not reset the device.
+//
+//   nvcc -O3 -std=c++17 -arch=sm_89 -o eqprop_gpu_cuda eqprop_gpu.cu
+//   ./eqprop_gpu --probe
+//   ./eqprop_gpu --corpus train_corpus_sparse.bin --ckpt complete.bin --save out.bin \
+//                --vram-limit-gb 28 --device 0
+//
+// Physics vs the CPU trainer:
+//   - Integrate unique(prompt ∪ targets) only (S). No 512-neighbor explosion.
+//   - No length-N RK4 temps and no all-N omega wrap.
+//   - Same RK4 counts, dt, amp-gate, contrastive K rule, checkpoint layout.
+
+#include <cuda_runtime.h>
+#include <filesystem>
+#include <memory>
+
+#include <algorithm>
+#include <cctype>
+#include <cerrno>
+#include <chrono>
+#include <cmath>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <fstream>
+#include <iostream>
+#include <random>
+#include <string>
+#include <sys/stat.h>
+#include <thread>
+#include <unistd.h>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846
+#endif
+
+static constexpr uint32_t kDefaultN = 5000000u;
+static constexpr uint32_t kDefaultK = 512u;
+static constexpr int kMaxS = 256;
+static constexpr int kRk4Free = 5;
+static constexpr int kRk4Nudge = 5;
+static constexpr double kDt = 0.02;
+// K is initialized in [-0.5, 0.5] and wired at k0=0.2. A single contested
+// node -- one that many records push in conflicting directions every time
+// it appears -- can walk an edge into the double digits over enough steps,
+// since nothing bounds the accumulation (measured: text->silence-code
+// edges reached |K|=16-18 with lr=0.05 over ~1e5 steps). Clip after every
+// update so a shared node saturates instead of diverging; kKMax is well
+// outside the normal learned range (empirically -0.2 to +0.7).
+static constexpr float kKMax = 3.0f;
+// Natural frequencies are multiplied by this inside the integrator only; the
+// omega stored in the checkpoint is never modified, so any value is
+// reversible by restarting with another. 1.0 = the original dynamics.
+// Measured offline (nudge_signal_probe.py, 40 speech records, same-moment
+// branches, target from text): gold dc -0.00012 (-2.1 SE) at 1.0,
+// +0.0044 (+23 SE) at 0.01, +0.0049 (+24.5 SE) at 0. With the full spread
+// no pair can phase-lock in a 0.1 s window, so nothing is learnable.
+static double g_omega_scale = 1.0;
+static constexpr double kVramFraction = 0.40;           // share with SImi 0.50 / Uni 0.35
+static constexpr size_t kVramLimitMax = 77ull << 30;    // 77 GiB
+static constexpr size_t kLeaveFreeBytes = 16ull << 30;  // do not eat their headroom
+
+
+#define CUDA_CHECK(expr)                                                                          \
+    do {                                                                                         \
+        cudaError_t _e = (expr);                                                                  \
+        if (_e != cudaSuccess) {                                                                  \
+            std::cerr << "CUDA error " << cudaGetErrorString(_e) << " at " << __FILE__ << ":"     \
+                      << __LINE__ << " :: " << #expr << std::endl;                               \
+            std::exit(1);                                                                        \
+        }                                                                                        \
+    } while (0)
+
+static uint64_t ckpt_bytes(uint32_t N, uint32_t k) {
+    return 16ull + 32ull * (uint64_t)N + 8ull * (uint64_t)N * (uint64_t)k;
+}
+
+static void gb_print(const char* tag, size_t bytes) {
+    std::printf("%s %.3f GB (%zu B)\n", tag, (double)bytes / 1e9, bytes);
+}
+
+struct Args {
+    std::vector<std::string> corpora;
+    std::string data_dir;
+    std::string slots_dir;
+    std::string ckpt;
+    std::string save = "nys_gpu_checkpoint.bin";
+    std::string save_dir;
+    double lr = 0.05;
+    double beta = 1.5;
+    int save_every = 0;
+    int max_steps = -1;
+    int log_every = 50;
+    int device = 0;
+    double vram_limit_gb = 0.0;  // 0 = 0.40 of device, max 77 GiB
+    bool probe = false;
+    bool check_ckpt = false;
+    bool check_inputs = false;
+    bool self_test = false;
+    bool settle = false;
+    int settle_rk4 = kRk4Free;
+    double omega_scale = 1.0;
+    int settle_fill = 0;
+    int fill_neighbors = 32;
+    bool init = false;
+    bool live = false;
+    bool distill_stdin = false;
+    bool require_full_curriculum = false;
+    bool save_first_rotation = false;
+    bool validate_distill_stdin = false;
+    std::string live_mix;
+    int live_idle_sec = 180;
+    int resume_steps = 0;
+    uint32_t N = kDefaultN;
+    uint32_t k = kDefaultK;
+};
+
+static void resolve_slots(Args& a) {
+    std::string dir = a.slots_dir;
+    if (dir.empty() && !a.data_dir.empty()) {
+        dir = a.data_dir;
+        if (!dir.empty() && dir.back() != '/') dir.push_back('/');
+        dir += "slots";
+    }
+    if (dir.empty()) return;
+    // Native slot files only. SDS1/hard projections stay off the live
+    // rotation so compiler/speech do not triple-count against language.
+    const char* names[] = {
+        "compiler_physics.nysa",
+        "speech_slot.nysv",
+        "speech_align.nysv",
+    };
+    for (const char* n : names) {
+        std::string p = dir;
+        if (!p.empty() && p.back() != '/') p.push_back('/');
+        p += n;
+        std::ifstream f(p, std::ios::binary);
+        if (f) {
+            if (std::find(a.corpora.begin(), a.corpora.end(), p) != a.corpora.end()) continue;
+            a.corpora.push_back(p);
+            std::printf("[data] + slot %s\n", p.c_str());
+        } else {
+            std::printf("[data] missing slot %s (skip)\n", p.c_str());
+        }
+    }
+}
+
+static void resolve_corpora(Args& a) {
+    const char* names[] = {
+        "train_corpus_sparse.bin",
+        "sft_corpus_sparse.bin",
+        "mix_sft_sparse.bin",
+        "distill_corpus_sparse.bin",
+    };
+    if (!a.data_dir.empty()) {
+        for (const char* n : names) {
+            std::string p = a.data_dir;
+            if (!p.empty() && p.back() != '/') p.push_back('/');
+            p += n;
+            if (a.live && std::strcmp(n, "mix_sft_sparse.bin") == 0) {
+                if (a.live_mix.empty()) a.live_mix = p;
+                std::printf("[data] live-tail %s (not preloaded)\n", a.live_mix.c_str());
+                continue;
+            }
+            std::ifstream f(p, std::ios::binary);
+            if (f) {
+                a.corpora.push_back(p);
+                std::printf("[data] + %s\n", p.c_str());
+            } else {
+                std::printf("[data] missing %s (skip)\n", p.c_str());
+            }
+        }
+    }
+    resolve_slots(a);
+}
+
+static bool flag(const char* a, const char* n) { return std::strcmp(a, n) == 0; }
+
+static Args parse_args(int argc, char** argv) {
+    Args a;
+    for (int i = 1; i < argc; ++i) {
+        auto need = [&](const char* n) -> const char* {
+            if (i + 1 >= argc) {
+                std::cerr << "missing value for " << n << std::endl;
+                std::exit(2);
+            }
+            return argv[++i];
+        };
+        if (flag(argv[i], "--probe")) a.probe = true;
+        else if (flag(argv[i], "--check-ckpt")) a.check_ckpt = true;
+        else if (flag(argv[i], "--settle")) a.settle = true;
+        else if (flag(argv[i], "--settle-rk4")) a.settle_rk4 = std::atoi(need("--settle-rk4"));
+        else if (flag(argv[i], "--settle-fill")) a.settle_fill = std::atoi(need("--settle-fill"));
+        else if (flag(argv[i], "--omega-scale")) a.omega_scale = std::atof(need("--omega-scale"));
+        else if (flag(argv[i], "--fill-neighbors")) a.fill_neighbors = std::atoi(need("--fill-neighbors"));
+        else if (flag(argv[i], "--self-test")) a.self_test = true;
+        else if (flag(argv[i], "--init")) a.init = true;
+        else if (flag(argv[i], "--distill-stdin")) a.distill_stdin = true;
+        else if (flag(argv[i], "--require-full-curriculum")) a.require_full_curriculum = true;
+        else if (flag(argv[i], "--save-first-rotation")) a.save_first_rotation = true;
+        else if (flag(argv[i], "--validate-distill-stdin")) a.validate_distill_stdin = true;
+        else if (flag(argv[i], "--check-inputs")) a.check_inputs = true;
+        else if (flag(argv[i], "--live")) a.live = true;
+        else if (flag(argv[i], "--live-mix")) a.live_mix = need("--live-mix");
+        else if (flag(argv[i], "--live-idle-sec")) a.live_idle_sec = std::atoi(need("--live-idle-sec"));
+        else if (flag(argv[i], "--corpus")) a.corpora.push_back(need("--corpus"));
+        else if (flag(argv[i], "--data-dir")) a.data_dir = need("--data-dir");
+        else if (flag(argv[i], "--slots-dir")) a.slots_dir = need("--slots-dir");
+        else if (flag(argv[i], "--ckpt")) a.ckpt = need("--ckpt");
+        else if (flag(argv[i], "--resume-steps")) a.resume_steps = std::atoi(need("--resume-steps"));
+        else if (flag(argv[i], "--save")) a.save = need("--save");
+        else if (flag(argv[i], "--save-dir")) a.save_dir = need("--save-dir");
+        else if (flag(argv[i], "--lr")) a.lr = std::atof(need("--lr"));
+        else if (flag(argv[i], "--beta")) a.beta = std::atof(need("--beta"));
+        else if (flag(argv[i], "--save-every")) a.save_every = std::atoi(need("--save-every"));
+        else if (flag(argv[i], "--max-steps")) a.max_steps = std::atoi(need("--max-steps"));
+        else if (flag(argv[i], "--log-every")) a.log_every = std::atoi(need("--log-every"));
+        else if (flag(argv[i], "--device")) a.device = std::atoi(need("--device"));
+        else if (flag(argv[i], "--vram-limit-gb")) a.vram_limit_gb = std::atof(need("--vram-limit-gb"));
+        else if (flag(argv[i], "--N")) a.N = (uint32_t)std::strtoul(need("--N"), nullptr, 10);
+        else if (flag(argv[i], "--k")) a.k = (uint32_t)std::strtoul(need("--k"), nullptr, 10);
+        else if (flag(argv[i], "-h") || flag(argv[i], "--help")) {
+            std::puts(
+                "eqprop_gpu — CUDA fused EqProp (no PyTorch)\n"
+                "  --check-ckpt            validate checkpoint size/header, without CUDA\n"
+                "  --probe                 print GPU memory and exit (no alloc)\n"
+                "  --self-test             synthetic numerical parity and checkpoint I/O checks\n"
+                "  --check-inputs          inspect corpus/slot wiring on CPU; no training\n"
+                "  --settle                read-only inference REPL on stdin (no K update)\n"
+                "  --settle-rk4 N          free-phase RK4 steps per settle (default 5)\n"
+                "  --settle-fill N         prompt neighbours clamped, as in training\n"
+                "  --omega-scale F         multiply natural frequencies in the integrator (default 1)\n"
+                "  --fill-neighbors N      prompt-neighbour fill for training (default 32)\n"
+                "  --corpus PATH           hard next-token or SDS1 (repeatable)\n"
+                "  --data-dir DIR          train + sft + distill sparse bins, in that order\n"
+                "  --slots-dir DIR         NYSA/NYSV compiler+speech (default DIR/slots)\n"
+                "  --distill-stdin         live SDS1 probabilities from stdin (requires --live)\n"
+                "  --validate-distill-stdin validate a stream on CPU, without training\n"
+                "  --live                  round-robin step now; tail mix as it grows\n"
+                "  --live-mix PATH         growing mix bin from sparse_convert\n"
+                "  --ckpt PATH             complete sparse checkpoint\n"
+                "  --save PATH             latest symlink / fallback dump\n"
+                "  --save-dir DIR          timestamped complete snapshots\n"
+                "  --save-every N          snapshot every N steps (0 = end only)\n"
+                "  --vram-limit-gb F       hard cap (default 0.40 of card, max 77 GiB)\n"
+                "  --device I              CUDA device index (default 0)\n"
+                "  --init --N --k          random init instead of load\n");
+            std::exit(0);
+        } else {
+            std::cerr << "unknown arg: " << argv[i] << std::endl;
+            std::exit(2);
+        }
+    }
+    return a;
+}
+
+struct VramCap {
+    size_t cap = kVramLimitMax;
+    size_t used = 0;
+    size_t leave_free = kLeaveFreeBytes;
+
+    void* alloc(size_t bytes, const char* name) {
+        size_t need = (bytes + 255ull) & ~255ull;
+        if (used + need > cap) {
+            std::cerr << "[vram] refuse " << name << " " << need << " B; used " << used
+                      << " cap " << cap << std::endl;
+            std::exit(3);
+        }
+        size_t free_b = 0, total_b = 0;
+        CUDA_CHECK(cudaMemGetInfo(&free_b, &total_b));
+        if (free_b < need + leave_free) {
+            std::cerr << "[vram] refuse " << name << ": free=" << free_b << " need=" << need
+                      << " plus leave_free=" << leave_free
+                      << " (will not squeeze other jobs)" << std::endl;
+            std::exit(3);
+        }
+        void* p = nullptr;
+        CUDA_CHECK(cudaMalloc(&p, need));
+        used += need;
+        std::printf("[vram] +%-18s %8.3f GB  running_total=%8.3f / %8.3f GB\n", name,
+                    need / 1e9, used / 1e9, cap / 1e9);
+        return p;
+    }
+};
+
+__device__ __forceinline__ double wrap_pi(double x) {
+    if (x > M_PI) x -= 2.0 * M_PI;
+    else if (x < -M_PI) x += 2.0 * M_PI;
+    return x;
+}
+
+__device__ int loc_of(uint32_t id, const uint32_t* S, int m) {
+    for (int t = 0; t < m; ++t) {
+        if (S[t] == id) return t;
+    }
+    return -1;
+}
+
+// One persistent-ish block: free RK4, snapshot, nudge RK4, contrastive K.
+__global__ void eqprop_fused(
+    uint32_t N,
+    uint32_t k,
+    double* theta,
+    const double* omega,
+    double* amp,
+    const uint64_t* off,
+    const uint32_t* col,
+    float* K,
+    const uint32_t* S_g,
+    int m,
+    int n_prompt,
+    const uint32_t* nudge_id,
+    const double* nudge_beta,
+    int n_nudge,
+    double lr,
+    double dt,
+    double* contrast_out,
+    int settle_mode,
+    int n_rk4,
+    int neutral_read,
+    double* settle_out,
+    int n_mean,
+    double omega_scale
+) {
+    (void)N;
+    if (blockIdx.x != 0 || m <= 0 || m > kMaxS) return;
+
+    __shared__ uint32_t sh_S[kMaxS];
+    __shared__ double sh_th[kMaxS];
+    __shared__ double sh_th0[kMaxS];
+    __shared__ double sh_free[kMaxS];
+    __shared__ double sh_start[kMaxS];
+    __shared__ double sh_amp[kMaxS];
+    __shared__ double sh_k1[kMaxS];
+    __shared__ double sh_k2[kMaxS];
+    __shared__ double sh_k3[kMaxS];
+    __shared__ double sh_k4[kMaxS];
+    __shared__ double sh_mean;
+    __shared__ double sh_dc[kMaxS];
+    __shared__ int sh_ne[kMaxS];
+
+    // The target phase comes from the real prompt only. fill_prompt_neighbors
+    // appends up to 32 neighbours of the last prompt token to the clamped set;
+    // for a speech step (2.3 text ids on average) they were 91.5% of the mean,
+    // so gold was pulled toward the neighbours' phase, not the text's.
+    if (n_mean <= 0 || n_mean > n_prompt) n_mean = n_prompt;
+
+    int li = (int)threadIdx.x;
+    if (li < m) {
+        uint32_t i = S_g[li];
+        sh_S[li] = i;
+        // Read nodes normally start from stored theta -- which on a shared
+        // slot is the nudged phase the last record left behind, so two
+        // nodes feel different coupling from the same prompt. A neutral
+        // start puts them on a common origin so disp reflects K alone.
+        sh_th[li] = (settle_mode && neutral_read && li >= n_prompt) ? 0.0 : theta[i];
+        sh_amp[li] = (li < n_prompt) ? 1.0 : 0.0;
+        // Settle is a read-only probe: it must not touch the graph at all.
+        if (settle_mode) {
+            settle_out[kMaxS + li] = sh_th[li];       // theta0, before integration
+            settle_out[2 * kMaxS + li] = omega_scale * omega[i];  // effective omega
+        } else {
+            amp[i] = sh_amp[li];
+        }
+    }
+    __syncthreads();
+
+    // Training contrasts two branches that start from the SAME state at the
+    // same moment: phase 1 continues free, phase 2 is nudged. The old rule
+    // contrasted the free snapshot with a nudged one taken 5 steps later, so
+    // every pair's natural counter-rotation (omega spread 50-1000 rad/s, ~36
+    // rad in 0.1 s) landed in dc -- the nudge was ~1/6000 of each update.
+    // Branching cancels that drift exactly; it costs kRk4Nudge extra steps.
+    int n_phase = settle_mode ? 1 : 3;
+    for (int phase = 0; phase < n_phase; ++phase) {
+        int nsteps = (phase == 0) ? (settle_mode ? n_rk4 : kRk4Free) : kRk4Nudge;
+        int use_nudge = (phase == 2);
+        for (int step = 0; step < nsteps; ++step) {
+            if (li < m) sh_th0[li] = sh_th[li];
+            __syncthreads();
+            for (int stg = 0; stg < 4; ++stg) {
+                if (li < m) {
+                    uint32_t i = sh_S[li];
+                    double thi = sh_th[li];
+                    double sum = 0.0;
+                    uint64_t a = off[i];
+                    uint64_t b = off[i + 1];
+                    if (b > a + k) b = a + k;
+                    for (uint64_t e = a; e < b; ++e) {
+                        uint32_t j = col[e];
+                        int lj = loc_of(j, sh_S, m);
+                        if (lj < 0) continue;
+                        double aj = sh_amp[lj];
+                        if (aj > 1e-5) {
+                            sum += (double)K[e] * aj * sin(sh_th[lj] - thi);
+                        }
+                    }
+                    double d = omega_scale * omega[i] + sum;
+                    if (use_nudge) {
+                        for (int n = 0; n < n_nudge; ++n) {
+                            if (nudge_id[n] == i) {
+                                d += nudge_beta[n] * sin(sh_mean - thi);
+                            }
+                        }
+                    }
+                    if (stg == 0) sh_k1[li] = d;
+                    else if (stg == 1) sh_k2[li] = d;
+                    else if (stg == 2) sh_k3[li] = d;
+                    else sh_k4[li] = d;
+                }
+                __syncthreads();
+                if (li < m) {
+                    if (stg == 0) sh_th[li] = wrap_pi(sh_th0[li] + 0.5 * dt * sh_k1[li]);
+                    else if (stg == 1) sh_th[li] = wrap_pi(sh_th0[li] + 0.5 * dt * sh_k2[li]);
+                    else if (stg == 2) sh_th[li] = wrap_pi(sh_th0[li] + dt * sh_k3[li]);
+                    else {
+                        double upd =
+                            (dt / 6.0) * (sh_k1[li] + 2.0 * sh_k2[li] + 2.0 * sh_k3[li] + sh_k4[li]);
+                        sh_th[li] = wrap_pi(sh_th0[li] + upd);
+                    }
+                }
+                __syncthreads();
+            }
+        }
+        if (phase == 0) {
+            // Branch point: both training branches restart from here.
+            if (li < m) {
+                sh_start[li] = sh_th[li];
+                sh_free[li] = sh_th[li];
+            }
+            __syncthreads();
+            if (li == 0) {
+                double X = 0.0, Y = 0.0;
+                for (int t = 0; t < n_mean; ++t) {
+                    X += cos(sh_start[t]);
+                    Y += sin(sh_start[t]);
+                }
+                sh_mean = atan2(Y, X);
+            }
+            __syncthreads();
+            if (li < m && !settle_mode) {
+                uint32_t i = sh_S[li];
+                for (int n = 0; n < n_nudge; ++n) {
+                    if (nudge_id[n] == i) {
+                        double v = nudge_beta[n];
+                        if (v < 0.0) v = -v;
+                        if (v > 1.0) v = 1.0;
+                        if (v > sh_amp[li]) sh_amp[li] = v;
+                    }
+                }
+                amp[i] = sh_amp[li];
+            }
+            __syncthreads();
+        } else if (phase == 1) {
+            // Free-continued reference at the same moment the nudged branch
+            // will end; then rewind to the branch point for phase 2.
+            if (li < m) {
+                sh_free[li] = sh_th[li];
+                sh_th[li] = sh_start[li];
+            }
+            __syncthreads();
+        }
+    }
+
+    if (settle_mode) {
+        // Settled free phase + the prompt mean the nudge would have pulled
+        // targets toward. No theta writeback, no amp zeroing, no K update.
+        if (li < m) settle_out[li] = sh_th[li];
+        __syncthreads();
+        if (li == 0) settle_out[3 * kMaxS] = sh_mean;
+        return;
+    }
+
+    if (li < m) {
+        uint32_t i = sh_S[li];
+        theta[i] = sh_th[li];
+        uint64_t a = off[i];
+        uint64_t b = off[i + 1];
+        if (b > a + k) b = a + k;
+        double local = 0.0;
+        int nedge = 0;
+        if (sh_amp[li] > 0.1) {
+            for (uint64_t e = a; e < b; ++e) {
+                uint32_t j = col[e];
+                int lj = loc_of(j, sh_S, m);
+                if (lj < 0) continue;
+                if (sh_amp[lj] > 0.1) {
+                    double cfree = cos(sh_free[li] - sh_free[lj]);
+                    double cnudge = cos(sh_th[li] - sh_th[lj]);
+                    double dc = cnudge - cfree;
+                    local += dc;
+                    nedge++;
+                    K[e] += (float)(lr * dc);
+                    if (K[e] > kKMax) K[e] = kKMax;
+                    else if (K[e] < -kKMax) K[e] = -kKMax;
+                }
+            }
+        }
+        sh_dc[li] = local;
+        sh_ne[li] = nedge;
+        amp[i] = 0.0;
+    } else {
+        sh_dc[li] = 0.0;
+        sh_ne[li] = 0;
+    }
+    __syncthreads();
+    if (li == 0 && contrast_out) {
+        double s = 0.0;
+        int c = 0;
+        for (int t = 0; t < m; ++t) {
+            s += sh_dc[t];
+            c += sh_ne[t];
+        }
+        *contrast_out = (c > 0) ? (s / (double)c) : 0.0;
+    }
+}
+
+struct GpuState {
+    uint32_t N = 0;
+    uint32_t k = 0;
+    double* theta = nullptr;
+    double* amp = nullptr;
+    double* omega = nullptr;
+    uint64_t* off = nullptr;
+    uint32_t* col = nullptr;
+    float* K = nullptr;
+    uint32_t* S = nullptr;
+    uint32_t* nudge_id = nullptr;
+    double* nudge_beta = nullptr;
+    double* contrast = nullptr;
+    double* settle_out = nullptr;
+    VramCap cap;
+};
+
+static void probe_device(int device, double limit_gb) {
+    int ndev = 0;
+    CUDA_CHECK(cudaGetDeviceCount(&ndev));
+    std::printf("[gpu] cudaGetDeviceCount=%d\n", ndev);
+    if (ndev <= 0) {
+        std::cerr << "[gpu] no CUDA devices\n";
+        std::exit(1);
+    }
+    CUDA_CHECK(cudaSetDevice(device));
+    cudaDeviceProp p{};
+    CUDA_CHECK(cudaGetDeviceProperties(&p, device));
+    size_t free_b = 0, total_b = 0;
+    CUDA_CHECK(cudaMemGetInfo(&free_b, &total_b));
+    std::printf("[gpu] device=%d name=%s\n", device, p.name);
+    gb_print("[gpu] total", total_b);
+    gb_print("[gpu] used ", total_b - free_b);
+    gb_print("[gpu] free ", free_b);
+    size_t cap = limit_gb > 0.0 ? (size_t)(limit_gb * (1ull << 30))
+                                : (size_t)(kVramFraction * total_b);
+    gb_print("[gpu] cap  ", std::min(cap, kVramLimitMax));
+    std::printf("[gpu] fraction=%.2f  will not cudaDeviceReset; will not touch other PIDs\n",
+                kVramFraction);
+}
+
+static void host_init_graph(uint32_t N, uint32_t k,
+                            std::vector<double>& theta,
+                            std::vector<double>& amp,
+                            std::vector<double>& omega,
+                            std::vector<uint64_t>& off,
+                            std::vector<uint32_t>& col,
+                            std::vector<float>& K) {
+    theta.assign(N, 0.0);
+    amp.assign(N, 0.0);
+    omega.assign(N, 0.0);
+    off.assign((size_t)N + 1, 0);
+    col.assign((size_t)N * k, 0);
+    K.assign((size_t)N * k, 0.0f);
+    std::mt19937 gen(0xC0FFEE);
+    std::uniform_real_distribution<double> phase(-M_PI, M_PI);
+    std::uniform_real_distribution<double> freq(50.0, 1000.0);
+    std::uniform_real_distribution<float> w(-0.5f, 0.5f);
+    for (uint32_t i = 0; i < N; ++i) {
+        theta[i] = phase(gen);
+        omega[i] = freq(gen);
+        off[i] = (uint64_t)i * k;
+        for (uint32_t j = 0; j < k; ++j) {
+            uint64_t e = (uint64_t)i * k + j;
+            if (j < k - 16u) {
+                col[e] = (uint32_t)((i + N - k / 2u + j) % N);
+            } else {
+                col[e] = gen() % N;
+            }
+            K[e] = w(gen);
+        }
+    }
+    off[N] = (uint64_t)N * k;
+}
+
+static void upload(GpuState& g, const std::vector<double>& theta, const std::vector<double>& amp,
+                   const std::vector<double>& omega, const std::vector<uint64_t>& off,
+                   const std::vector<uint32_t>& col, const std::vector<float>& K) {
+    CUDA_CHECK(cudaMemcpy(g.theta, theta.data(), theta.size() * sizeof(double), cudaMemcpyHostToDevice));
+    CUDA_CHECK(cudaMemcpy(g.amp, amp.data(), amp.size() * sizeof(double), cudaMemcpyHostToDevice));
+    CUDA_CHECK(cudaMemcpy(g.omega, omega.data(), omega.size() * sizeof(double), cudaMemcpyHostToDevice));
+    CUDA_CHECK(cudaMemcpy(g.off, off.data(), off.size() * sizeof(uint64_t), cudaMemcpyHostToDevice));
+    CUDA_CHECK(cudaMemcpy(g.col, col.data(), col.size() * sizeof(uint32_t), cudaMemcpyHostToDevice));
+    CUDA_CHECK(cudaMemcpy(g.K, K.data(), K.size() * sizeof(float), cudaMemcpyHostToDevice));
+}
+
+static GpuState alloc_state(uint32_t N, uint32_t k, size_t cap_bytes) {
+    GpuState g;
+    g.N = N;
+    g.k = k;
+    g.cap.cap = cap_bytes;
+    size_t nnz = (size_t)N * (size_t)k;
+    g.theta = (double*)g.cap.alloc(N * sizeof(double), "theta");
+    g.amp = (double*)g.cap.alloc(N * sizeof(double), "amp");
+    g.omega = (double*)g.cap.alloc(N * sizeof(double), "omega");
+    g.off = (uint64_t*)g.cap.alloc(((size_t)N + 1) * sizeof(uint64_t), "K_offsets");
+    g.col = (uint32_t*)g.cap.alloc(nnz * sizeof(uint32_t), "K_cols");
+    g.K = (float*)g.cap.alloc(nnz * sizeof(float), "K_vals");
+    g.S = (uint32_t*)g.cap.alloc(kMaxS * sizeof(uint32_t), "S");
+    g.nudge_id = (uint32_t*)g.cap.alloc(kMaxS * sizeof(uint32_t), "nudge_id");
+    g.nudge_beta = (double*)g.cap.alloc(kMaxS * sizeof(double), "nudge_beta");
+    g.contrast = (double*)g.cap.alloc(sizeof(double), "contrast");
+    g.settle_out = (double*)g.cap.alloc((3 * kMaxS + 1) * sizeof(double), "settle_out");
+    CUDA_CHECK(cudaMemset(g.amp, 0, N * sizeof(double)));
+    return g;
+}
+
+static void load_ckpt(GpuState& g, const std::string& path) {
+    std::ifstream f(path, std::ios::binary);
+    if (!f) {
+        std::cerr << "cannot open ckpt " << path << std::endl;
+        std::exit(1);
+    }
+    f.seekg(0, std::ios::end);
+    uint64_t sz = (uint64_t)f.tellg();
+    f.seekg(0, std::ios::beg);
+    uint64_t need = ckpt_bytes(g.N, g.k);
+    if (sz != need) {
+        std::cerr << "[ckpt] size " << sz << " != " << need << " (truncated or wrong N/k). abort\n";
+        std::exit(1);
+    }
+    uint32_t file_N = 0, file_k = 0;
+    f.read((char*)&file_N, 4);
+    f.read((char*)&file_k, 4);
+    if (file_N != g.N || file_k != g.k) {
+        std::cerr << "[ckpt] N/k mismatch file=" << file_N << "x" << file_k << " expect " << g.N
+                  << "x" << g.k << std::endl;
+        std::exit(1);
+    }
+    std::vector<char> buf;
+    auto copy_field = [&](void* dst, size_t bytes, const char* name) {
+        const size_t chunk = 256ull * 1024ull * 1024ull;
+        size_t off = 0;
+        while (off < bytes) {
+            size_t n = std::min(chunk, bytes - off);
+            buf.resize(n);
+            f.read(buf.data(), (std::streamsize)n);
+            if ((size_t)f.gcount() != n) {
+                std::cerr << "[ckpt] short read on " << name << std::endl;
+                std::exit(1);
+            }
+            CUDA_CHECK(cudaMemcpy((char*)dst + off, buf.data(), n, cudaMemcpyHostToDevice));
+            off += n;
+        }
+        std::printf("[ckpt] loaded %s\n", name);
+    };
+    copy_field(g.theta, g.N * sizeof(double), "theta");
+    copy_field(g.amp, g.N * sizeof(double), "amp");
+    copy_field(g.omega, g.N * sizeof(double), "omega");
+    copy_field(g.off, ((size_t)g.N + 1) * sizeof(uint64_t), "offsets");
+    copy_field(g.col, (size_t)g.N * g.k * sizeof(uint32_t), "cols");
+    copy_field(g.K, (size_t)g.N * g.k * sizeof(float), "K");
+    std::puts("[ckpt] complete");
+}
+
+static bool save_ckpt(const GpuState& g, const std::string& path) {
+    std::string tmp = path + ".writing";
+    std::printf("[ckpt] saving %s (device -> host, other jobs left running)\n", path.c_str());
+    std::ofstream f(tmp, std::ios::binary | std::ios::trunc);
+    if (!f) {
+        std::cerr << "cannot write " << tmp << std::endl;
+        return false;
+    }
+    f.write((const char*)&g.N, 4);
+    f.write((const char*)&g.k, 4);
+    std::vector<char> buf;
+    auto dump = [&](const void* src, size_t bytes) {
+        const size_t chunk = 256ull * 1024ull * 1024ull;
+        size_t off = 0;
+        while (off < bytes) {
+            size_t n = std::min(chunk, bytes - off);
+            buf.resize(n);
+            CUDA_CHECK(cudaMemcpy(buf.data(), (const char*)src + off, n, cudaMemcpyDeviceToHost));
+            f.write(buf.data(), (std::streamsize)n);
+            off += n;
+        }
+    };
+    dump(g.theta, g.N * sizeof(double));
+    dump(g.amp, g.N * sizeof(double));
+    dump(g.omega, g.N * sizeof(double));
+    dump(g.off, ((size_t)g.N + 1) * sizeof(uint64_t));
+    dump(g.col, (size_t)g.N * g.k * sizeof(uint32_t));
+    dump(g.K, (size_t)g.N * g.k * sizeof(float));
+    f.flush();
+    if (!f) {
+        std::cerr << "[ckpt] write failed " << tmp << std::endl;
+        return false;
+    }
+    f.close();
+    if (!f) {
+        std::cerr << "[ckpt] close failed " << tmp << std::endl;
+        return false;
+    }
+    uint64_t sz = 0;
+    {
+        std::ifstream chk(tmp, std::ios::binary | std::ios::ate);
+        sz = chk ? (uint64_t)chk.tellg() : 0;
+    }
+    uint64_t need = ckpt_bytes(g.N, g.k);
+    if (sz != need) {
+        std::cerr << "[ckpt] abort rename: size " << sz << " != " << need << "\n";
+        std::remove(tmp.c_str());
+        return false;
+    }
+    if (std::rename(tmp.c_str(), path.c_str()) != 0) {
+        std::cerr << "[ckpt] rename failed " << tmp << " -> " << path << std::endl;
+        return false;
+    }
+    std::printf("[ckpt] saved %s (%llu B)\n", path.c_str(), (unsigned long long)sz);
+    std::fflush(stdout);
+    return true;
+}
+
+static std::string utc_stamp() {
+    std::time_t t = std::time(nullptr);
+    std::tm tm{};
+    gmtime_r(&t, &tm);
+    char buf[32];
+    std::strftime(buf, sizeof(buf), "%Y%m%d_%H%M%S", &tm);
+    return buf;
+}
+
+static void ensure_dir(const std::string& dir) {
+    if (dir.empty() || dir == ".") return;
+    if (mkdir(dir.c_str(), 0755) != 0 && errno != EEXIST) {
+        std::cerr << "[ckpt] mkdir " << dir << " failed\n";
+    }
+}
+
+static void save_snapshot(const GpuState& g, const Args& a, int steps) {
+    std::string dir = a.save_dir.empty() ? "." : a.save_dir;
+    ensure_dir(dir);
+    if (a.require_full_curriculum && std::filesystem::space(dir).available < 30'640'000'016ULL)
+        throw std::runtime_error("Insufficient disk headroom for complete checkpoint; stopping before write");
+    std::string name = "gpu_eqprop_" + std::to_string(steps) + "_" + utc_stamp() + ".bin";
+    std::string path = dir;
+    if (!path.empty() && path.back() != '/') path.push_back('/');
+    path += name;
+    if (!save_ckpt(g, path)) std::exit(1);
+    if (!a.save.empty() && a.save != path) {
+        // An absolute target works even when latest and snapshots have different parents.
+        const std::string target = std::filesystem::absolute(path).string();
+        const std::string link_tmp = a.save + ".link." + std::to_string(getpid());
+        if (symlink(target.c_str(), link_tmp.c_str()) != 0) {
+            std::perror("[ckpt] create temporary latest link");
+            std::exit(1);
+        }
+        if (std::rename(link_tmp.c_str(), a.save.c_str()) != 0) {
+            std::perror("[ckpt] replace latest link");
+            std::remove(link_tmp.c_str());
+            std::exit(1);
+        }
+        std::printf("[ckpt] latest -> %s\n", target.c_str());
+    }
+}
+
+struct StepPack {
+    std::vector<uint32_t> S;
+    int n_prompt = 0;
+    std::vector<uint32_t> nudge_id;
+    std::vector<double> nudge_beta;
+};
+
+static int kFillNeighbors = 32;
+
+static StepPack pack_step(const std::vector<uint32_t>& prompt,
+                          const std::vector<std::pair<uint32_t, double>>& nudges,
+                          uint32_t N) {
+    StepPack p;
+    std::unordered_set<uint32_t> seen;
+    for (uint32_t t : prompt) {
+        if (t >= N) continue;
+        if (seen.insert(t).second) p.S.push_back(t);
+    }
+    p.n_prompt = (int)p.S.size();
+    for (auto& nb : nudges) {
+        if (nb.first >= N) continue;
+        p.nudge_id.push_back(nb.first);
+        p.nudge_beta.push_back(nb.second);
+        if (seen.insert(nb.first).second) p.S.push_back(nb.first);
+    }
+    if ((int)p.S.size() > kMaxS) {
+        p.S.resize(kMaxS);
+        if (p.n_prompt > kMaxS) p.n_prompt = kMaxS;
+    }
+    return p;
+}
+
+static void fill_prompt_neighbors(GpuState& g, StepPack& p, int n_fill) {
+    if (n_fill <= 0 || p.n_prompt <= 0 || (int)p.S.size() >= kMaxS) return;
+    uint32_t last = p.S[(size_t)p.n_prompt - 1];
+    if (last >= g.N) return;
+    uint64_t start = 0, end = 0;
+    CUDA_CHECK(cudaMemcpy(&start, g.off + last, sizeof(uint64_t), cudaMemcpyDeviceToHost));
+    CUDA_CHECK(cudaMemcpy(&end, g.off + last + 1, sizeof(uint64_t), cudaMemcpyDeviceToHost));
+    uint64_t n = end > start ? end - start : 0;
+    if (n > (uint64_t)g.k) n = g.k;
+    if (n == 0) return;
+    std::vector<uint32_t> cols((size_t)n);
+    CUDA_CHECK(cudaMemcpy(cols.data(), g.col + start, (size_t)n * sizeof(uint32_t), cudaMemcpyDeviceToHost));
+    std::unordered_set<uint32_t> seen(p.S.begin(), p.S.end());
+    std::vector<uint32_t> extras;
+    extras.reserve((size_t)n_fill);
+    for (uint32_t j : cols) {
+        if ((int)p.S.size() + (int)extras.size() >= kMaxS) break;
+        if ((int)extras.size() >= n_fill) break;
+        if (j >= g.N || seen.count(j)) continue;
+        seen.insert(j);
+        extras.push_back(j);
+    }
+    if (extras.empty()) return;
+    p.S.insert(p.S.begin() + p.n_prompt, extras.begin(), extras.end());
+    p.n_prompt += (int)extras.size();
+    if ((int)p.S.size() > kMaxS) {
+        p.S.resize(kMaxS);
+        if (p.n_prompt > kMaxS) p.n_prompt = kMaxS;
+    }
+}
+
+static double launch_step(GpuState& g, const StepPack& p0, double lr) {
+    StepPack p = p0;
+    const int n_mean = p0.n_prompt;  // real prompt, before the fill neighbours
+    fill_prompt_neighbors(g, p, kFillNeighbors);
+    if (p.S.empty() || p.nudge_id.empty()) return 0.0;
+    CUDA_CHECK(cudaMemcpy(g.S, p.S.data(), p.S.size() * sizeof(uint32_t), cudaMemcpyHostToDevice));
+    CUDA_CHECK(cudaMemcpy(g.nudge_id, p.nudge_id.data(), p.nudge_id.size() * sizeof(uint32_t),
+                        cudaMemcpyHostToDevice));
+    CUDA_CHECK(cudaMemcpy(g.nudge_beta, p.nudge_beta.data(), p.nudge_beta.size() * sizeof(double),
+                        cudaMemcpyHostToDevice));
+    eqprop_fused<<<1, kMaxS>>>(g.N, g.k, g.theta, g.omega, g.amp,
+                       g.off, g.col, g.K, g.S, (int)p.S.size(), p.n_prompt, g.nudge_id,
+                       g.nudge_beta, (int)p.nudge_id.size(), lr, kDt, g.contrast, 0, kRk4Free, 0,
+                       nullptr, n_mean, g_omega_scale);
+    CUDA_CHECK(cudaGetLastError());
+    double contrast = 0.0;
+    CUDA_CHECK(cudaMemcpy(&contrast, g.contrast, sizeof(double), cudaMemcpyDeviceToHost));
+    return contrast;
+}
+
+// ---------------------------------------------------------------------------
+// Settle: read-only inference. Same integrator as the training free phase,
+// same clamp (prompt amp 1, everything else 0), no nudge, no K update, no
+// writeback. This is the operator every readout was missing: the sidecar
+// scores stored theta, which is the *nudged* phase left behind by whichever
+// record touched a node last. Here the prompt drives the read nodes and we
+// report where they land.
+// ---------------------------------------------------------------------------
+
+// Host wrap into [-pi, pi]. The device wrap_pi is __device__ only and
+// nudges by a single period, which is not enough here: omega*T reaches
+// ~100 rad for the fastest oscillators.
+static double wrap_pi_host(double x) { return std::remainder(x, 2.0 * M_PI); }
+
+struct SettleRow {
+    uint32_t id;
+    double theta;
+    double theta0;
+    double omega;
+};
+
+// One launch. S = prompt (+ clamped neighbours) followed by `read`.
+// Returns the prompt mean phase; fills `rows` for the read nodes.
+static double launch_settle(GpuState& g,
+                            const std::vector<uint32_t>& prompt,
+                            int n_fill,
+                            const std::vector<uint32_t>& read,
+                            int n_rk4,
+                            int neutral,
+                            std::vector<SettleRow>& rows) {
+    rows.clear();
+    StepPack p;
+    std::unordered_set<uint32_t> seen;
+    for (uint32_t t : prompt) {
+        if (t >= g.N) continue;
+        if (seen.insert(t).second) p.S.push_back(t);
+    }
+    p.n_prompt = (int)p.S.size();
+    if (p.n_prompt <= 0) return 0.0;
+    if (p.n_prompt > kMaxS) {
+        p.S.resize(kMaxS);
+        p.n_prompt = kMaxS;
+    }
+    if (n_fill > 0) fill_prompt_neighbors(g, p, n_fill);
+    seen.clear();
+    seen.insert(p.S.begin(), p.S.end());
+
+    // Read nodes ride along at amp 0: they receive coupling from the clamped
+    // prompt but do not drive it, so the prompt trajectory (and the mean) is
+    // identical no matter which read chunk we are on.
+    int first_read = (int)p.S.size();
+    for (uint32_t r : read) {
+        if ((int)p.S.size() >= kMaxS) break;
+        if (r >= g.N || seen.count(r)) continue;
+        seen.insert(r);
+        p.S.push_back(r);
+    }
+    int m = (int)p.S.size();
+
+    CUDA_CHECK(cudaMemcpy(g.S, p.S.data(), (size_t)m * sizeof(uint32_t), cudaMemcpyHostToDevice));
+    eqprop_fused<<<1, kMaxS>>>(g.N, g.k, g.theta, g.omega, g.amp,
+                       g.off, g.col, g.K, g.S, m, p.n_prompt, g.nudge_id, g.nudge_beta, 0, 0.0,
+                       kDt, nullptr, 1, n_rk4, neutral, g.settle_out, p.n_prompt, g_omega_scale);
+    CUDA_CHECK(cudaGetLastError());
+    CUDA_CHECK(cudaDeviceSynchronize());
+
+    std::vector<double> out((size_t)(3 * kMaxS + 1), 0.0);
+    CUDA_CHECK(cudaMemcpy(out.data(), g.settle_out, out.size() * sizeof(double),
+                        cudaMemcpyDeviceToHost));
+
+    for (int li = first_read; li < m; ++li) {
+        SettleRow r;
+        r.id = p.S[li];
+        r.theta = out[(size_t)li];
+        r.theta0 = out[(size_t)kMaxS + li];
+        r.omega = out[(size_t)2 * kMaxS + li];
+        rows.push_back(r);
+    }
+    return out[(size_t)3 * kMaxS];
+}
+
+static std::vector<uint32_t> parse_id_list(const std::string& v) {
+    std::vector<uint32_t> ids;
+    size_t i = 0;
+    while (i < v.size()) {
+        size_t j = v.find(',', i);
+        if (j == std::string::npos) j = v.size();
+        if (j > i) {
+            const std::string tok = v.substr(i, j - i);
+            char* endp = nullptr;
+            unsigned long long x = std::strtoull(tok.c_str(), &endp, 10);
+            if (endp && endp != tok.c_str()) ids.push_back((uint32_t)x);
+        }
+        i = j + 1;
+    }
+    return ids;
+}
+
+// Line protocol on stdin, one request per line:
+//   settle prompt=<ids> [read=<ids>] [steps=N] [fill=N]
+//   ping | quit
+// Response:
+//   mean <theta_bar>
+//   n <rows>
+//   <id> <theta> <theta0> <omega> <disp> <align>
+//   ...
+//   end
+// disp is the coupling-only phase shift (omega*T removed); align is
+// cos(theta - mean), the quantity the nudge drives targets toward in training.
+static int run_settle(GpuState& g, const Args& a) {
+    std::printf("[settle] ready N=%u k=%u rk4=%d fill=%d kMaxS=%d\n", g.N, g.k, a.settle_rk4,
+                a.settle_fill, kMaxS);
+    std::puts("[settle] read-only: no theta writeback, no amp write, no K update");
+    std::fflush(stdout);
+
+    std::string line;
+    while (std::getline(std::cin, line)) {
+        while (!line.empty() && (line.back() == 13 || line.back() == 10)) line.pop_back();
+        if (line.empty()) continue;
+        if (line == "quit" || line == "exit") break;
+        if (line == "ping") {
+            std::puts("pong");
+            std::puts("end");
+            std::fflush(stdout);
+            continue;
+        }
+
+        std::vector<uint32_t> prompt, read;
+        int steps = a.settle_rk4;
+        int fill = a.settle_fill;
+        int neutral = 0;
+        bool bad = false;
+        size_t i = 0;
+        while (i < line.size()) {
+            while (i < line.size() && std::isspace((unsigned char)line[i])) ++i;
+            size_t j = i;
+            while (j < line.size() && !std::isspace((unsigned char)line[j])) ++j;
+            if (j <= i) break;
+            const std::string tok = line.substr(i, j - i);
+            i = j;
+            if (tok == "settle") continue;
+            size_t eq = tok.find('=');
+            if (eq == std::string::npos) {
+                bad = true;
+                break;
+            }
+            const std::string key = tok.substr(0, eq);
+            const std::string val = tok.substr(eq + 1);
+            if (key == "prompt") prompt = parse_id_list(val);
+            else if (key == "read") read = parse_id_list(val);
+            else if (key == "steps") steps = std::atoi(val.c_str());
+            else if (key == "fill") fill = std::atoi(val.c_str());
+            else if (key == "neutral") neutral = std::atoi(val.c_str()) ? 1 : 0;
+            else {
+                bad = true;
+                break;
+            }
+        }
+        if (bad || prompt.empty()) {
+            std::puts(bad ? "err bad request" : "err empty prompt");
+            std::puts("end");
+            std::fflush(stdout);
+            continue;
+        }
+        if (steps < 1) steps = 1;
+        if (steps > 200) steps = 200;
+        if (fill < 0) fill = 0;
+
+        // Chunk the read set so every launch stays inside kMaxS.
+        int n_prompt_est = 0;
+        {
+            std::unordered_set<uint32_t> u;
+            for (uint32_t t : prompt) {
+                if (t < g.N && u.insert(t).second) ++n_prompt_est;
+            }
+        }
+        if (n_prompt_est > kMaxS) n_prompt_est = kMaxS;
+        int used = n_prompt_est + fill;
+        if (used > kMaxS - 1) used = kMaxS - 1;
+        int budget = kMaxS - used;
+        if (budget < 1) budget = 1;
+
+        std::vector<SettleRow> all;
+        double mean = 0.0;
+        if (read.empty()) {
+            std::vector<SettleRow> rows;
+            mean = launch_settle(g, prompt, fill, read, steps, neutral, rows);
+        } else {
+            for (size_t off = 0; off < read.size(); off += (size_t)budget) {
+                size_t n = std::min((size_t)budget, read.size() - off);
+                std::vector<uint32_t> chunk(read.begin() + off, read.begin() + off + n);
+                std::vector<SettleRow> rows;
+                mean = launch_settle(g, prompt, fill, chunk, steps, neutral, rows);
+                all.insert(all.end(), rows.begin(), rows.end());
+            }
+        }
+
+        const double T = (double)steps * kDt;
+        std::printf("mean %.17g\n", mean);
+        std::printf("n %zu\n", all.size());
+        for (const SettleRow& r : all) {
+            double disp = wrap_pi_host(r.theta - r.theta0 - r.omega * T);
+            double align = std::cos(r.theta - mean);
+            std::printf("%u %.17g %.17g %.17g %.17g %.17g\n", r.id, r.theta, r.theta0, r.omega,
+                        disp, align);
+        }
+        std::puts("end");
+        std::fflush(stdout);
+    }
+    std::puts("[settle] bye");
+    return 0;
+}
+
+static int train_hard(GpuState& g, const Args& a, const std::string& path) {
+    std::ifstream file(path, std::ios::binary);
+    if (!file) {
+        std::cerr << "corpus not found: " << path << "\n";
+        return 1;
+    }
+    uint32_t nrec = 0;
+    file.read((char*)&nrec, 4);
+    std::printf("[train] hard %s records=%u\n", path.c_str(), nrec);
+    int steps = 0;
+    for (uint32_t r = 0; r < nrec; ++r) {
+        if (a.max_steps > 0 && steps >= a.max_steps) break;
+        uint16_t len = 0;
+        file.read((char*)&len, 2);
+        if (len < 2) {
+            file.seekg(len * 4, std::ios::cur);
+            continue;
+        }
+        std::vector<uint32_t> toks(len);
+        file.read((char*)toks.data(), len * 4);
+        uint32_t target = toks.back();
+        std::vector<uint32_t> prompt(toks.begin(), toks.end() - 1);
+        std::vector<std::pair<uint32_t, double>> nudges{{target, a.beta}};
+        auto pack = pack_step(prompt, nudges, g.N);
+        auto t0 = std::chrono::high_resolution_clock::now();
+        launch_step(g, pack, a.lr);
+        CUDA_CHECK(cudaDeviceSynchronize());
+        auto t1 = std::chrono::high_resolution_clock::now();
+        double us = std::chrono::duration<double, std::micro>(t1 - t0).count();
+        steps++;
+        if (a.log_every > 0 && steps % a.log_every == 0) {
+            std::printf("  [step %d] target=%u |S|=%zu n_prompt=%d  %.1f us\n", steps, target,
+                        pack.S.size(), pack.n_prompt, us);
+        }
+        if (a.save_every > 0 && steps % a.save_every == 0) save_snapshot(g, a, steps);
+    }
+    save_snapshot(g, a, steps);
+    std::printf("[train] done steps=%d\n", steps);
+    return 0;
+}
+
+static int train_sds1(GpuState& g, const Args& a, std::ifstream& file, const std::string& path) {
+    uint32_t nrec = 0;
+    file.read((char*)&nrec, 4);
+    std::printf("[train] SDS1 %s records=%u\n", path.c_str(), nrec);
+    int steps = 0;
+    for (uint32_t r = 0; r < nrec; ++r) {
+        if (a.max_steps > 0 && steps >= a.max_steps) break;
+        uint16_t plen = 0, nsoft = 0;
+        file.read((char*)&plen, 2);
+        std::vector<uint32_t> prompt(plen);
+        if (plen) file.read((char*)prompt.data(), plen * 4);
+        file.read((char*)&nsoft, 2);
+        std::vector<uint32_t> ids(nsoft);
+        std::vector<float> pr(nsoft);
+        if (nsoft) {
+            file.read((char*)ids.data(), nsoft * 4);
+            file.read((char*)pr.data(), nsoft * 4);
+        }
+        if (plen < 1 || nsoft < 1) continue;
+        std::vector<std::pair<uint32_t, double>> nudges;
+        for (uint16_t i = 0; i < nsoft; ++i) {
+            if (pr[i] > 0.0f) nudges.emplace_back(ids[i], a.beta * (double)pr[i]);
+        }
+        if (nudges.empty()) continue;
+        auto pack = pack_step(prompt, nudges, g.N);
+        auto t0 = std::chrono::high_resolution_clock::now();
+        launch_step(g, pack, a.lr);
+        CUDA_CHECK(cudaDeviceSynchronize());
+        auto t1 = std::chrono::high_resolution_clock::now();
+        double us = std::chrono::duration<double, std::micro>(t1 - t0).count();
+        steps++;
+        if (a.log_every > 0 && steps % a.log_every == 0) {
+            std::printf("  [distill %d] |S|=%zu soft=%zu  %.1f us\n", steps, pack.S.size(),
+                        nudges.size(), us);
+        }
+        if (a.save_every > 0 && steps % a.save_every == 0) save_snapshot(g, a, steps);
+    }
+    save_snapshot(g, a, steps);
+    std::printf("[train] distill done steps=%d\n", steps);
+    return 0;
+}
+
+struct HardTail {
+    std::string path;
+    FILE* f = nullptr;
+    bool live = false;
+    bool wrap = false;
+    uint64_t emitted = 0;
+
+    bool ensure() {
+        if (f) return true;
+        f = std::fopen(path.c_str(), "rb");
+        if (!f) return false;
+        uint32_t nrec = 0;
+        if (std::fread(&nrec, 4, 1, f) != 1) {
+            std::fclose(f);
+            f = nullptr;
+            return false;
+        }
+        std::printf("[data] open hard %s header_nrec=%u live=%d wrap=%d\n", path.c_str(), nrec,
+                    (int)live, (int)wrap);
+        return true;
+    }
+
+    bool try_read(std::vector<uint32_t>& toks) {
+        if (!ensure()) return false;
+        long start = std::ftell(f);
+        uint16_t len = 0;
+        if (std::fread(&len, 2, 1, f) != 1) {
+            std::clearerr(f);
+            if (wrap) {
+                std::fseek(f, 4, SEEK_SET);
+                start = std::ftell(f);
+                if (std::fread(&len, 2, 1, f) != 1) return false;
+            } else {
+                std::fseek(f, start, SEEK_SET);
+                return false;
+            }
+        }
+        if (len < 2 || len > 2048) {
+            std::clearerr(f);
+            std::fseek(f, start, SEEK_SET);
+            return false;
+        }
+        toks.resize(len);
+        if (std::fread(toks.data(), 4, (size_t)len, f) != (size_t)len) {
+            std::clearerr(f);
+            std::fseek(f, start, SEEK_SET);
+            toks.clear();
+            return false;
+        }
+        emitted++;
+        return true;
+    }
+};
+
+struct Sds1Tail {
+    std::string path;
+    FILE* f = nullptr;
+    bool wrap = true;
+    uint64_t emitted = 0;
+    static constexpr long kHdr = 8;
+
+    bool ensure() {
+        if (f) return true;
+        f = std::fopen(path.c_str(), "rb");
+        if (!f) return false;
+        char mag[4] = {};
+        uint32_t nrec = 0;
+        if (std::fread(mag, 1, 4, f) != 4 || std::memcmp(mag, "SDS1", 4) != 0 ||
+            std::fread(&nrec, 4, 1, f) != 1) {
+            std::fclose(f);
+            f = nullptr;
+            return false;
+        }
+        std::printf("[data] open SDS1 %s header_nrec=%u\n", path.c_str(), nrec);
+        return true;
+    }
+
+    bool try_read(std::vector<uint32_t>& prompt, std::vector<uint32_t>& ids, std::vector<float>& pr) {
+        if (!ensure()) return false;
+        long start = std::ftell(f);
+        uint16_t plen = 0, nsoft = 0;
+        auto rewind_incomplete = [&]() {
+            std::clearerr(f);
+            std::fseek(f, start, SEEK_SET);
+        };
+        if (std::fread(&plen, 2, 1, f) != 1) {
+            std::clearerr(f);
+            if (wrap) {
+                std::fseek(f, kHdr, SEEK_SET);
+                start = std::ftell(f);
+                if (std::fread(&plen, 2, 1, f) != 1) return false;
+            } else {
+                std::fseek(f, start, SEEK_SET);
+                return false;
+            }
+        }
+        prompt.assign(plen, 0);
+        if (plen && std::fread(prompt.data(), 4, plen, f) != (size_t)plen) {
+            rewind_incomplete();
+            return false;
+        }
+        if (std::fread(&nsoft, 2, 1, f) != 1) {
+            rewind_incomplete();
+            return false;
+        }
+        ids.assign(nsoft, 0);
+        pr.assign(nsoft, 0.0f);
+        if (nsoft) {
+            if (std::fread(ids.data(), 4, nsoft, f) != (size_t)nsoft ||
+                std::fread(pr.data(), 4, nsoft, f) != (size_t)nsoft) {
+                rewind_incomplete();
+                return false;
+            }
+        }
+        if (plen < 1 || nsoft < 1) return false;
+        emitted++;
+        return true;
+    }
+};
+
+struct NysaRec {
+    std::vector<uint32_t> spec;
+    std::vector<uint8_t> bits;
+};
+
+static bool read_nysa_rec(FILE* f, NysaRec& r) {
+    uint16_t kind = 0, slen = 0, nbytes = 0, nbits = 0, ntrace = 0;
+    int64_t x = 0, y = 0;
+    uint8_t flags = 0;
+    if (std::fread(&kind, 2, 1, f) != 1) return false;
+    if (std::fread(&slen, 2, 1, f) != 1) return false;
+    r.spec.assign(slen, 0);
+    if (slen && std::fread(r.spec.data(), 4, slen, f) != (size_t)slen) return false;
+    if (std::fread(&x, 8, 1, f) != 1 || std::fread(&y, 8, 1, f) != 1) return false;
+    if (std::fread(&nbytes, 2, 1, f) != 1) return false;
+    if (nbytes) std::fseek(f, nbytes, SEEK_CUR);
+    if (std::fread(&nbits, 2, 1, f) != 1) return false;
+    r.bits.assign(nbits, 0);
+    if (nbits && std::fread(r.bits.data(), 1, nbits, f) != (size_t)nbits) return false;
+    if (std::fread(&flags, 1, 1, f) != 1) return false;
+    if (std::fread(&ntrace, 2, 1, f) != 1) return false;
+    if (ntrace) std::fseek(f, ntrace, SEEK_CUR);
+    (void)kind;
+    (void)x;
+    (void)y;
+    (void)flags;
+    return true;
+}
+
+struct NysaTail {
+    std::string path;
+    FILE* f = nullptr;
+    bool wrap = true;
+    uint64_t emitted = 0;
+    static constexpr uint32_t kCompilerBase = 3800000u;
+    static constexpr int kActiveBits = 64;
+    static constexpr long kHdr = 12;
+
+    bool ensure() {
+        if (f) return true;
+        f = std::fopen(path.c_str(), "rb");
+        if (!f) return false;
+        char mag[4] = {};
+        uint32_t ver = 0, nrec = 0;
+        if (std::fread(mag, 1, 4, f) != 4 || std::memcmp(mag, "NYSA", 4) != 0 ||
+            std::fread(&ver, 4, 1, f) != 1 || std::fread(&nrec, 4, 1, f) != 1) {
+            std::fclose(f);
+            f = nullptr;
+            return false;
+        }
+        std::printf("[data] open NYSA %s header_nrec=%u\n", path.c_str(), nrec);
+        return true;
+    }
+
+    bool try_read(NysaRec& r) {
+        if (!ensure()) return false;
+        long start = std::ftell(f);
+        if (!read_nysa_rec(f, r)) {
+            std::clearerr(f);
+            if (wrap) {
+                std::fseek(f, kHdr, SEEK_SET);
+                if (!read_nysa_rec(f, r)) return false;
+            } else {
+                std::fseek(f, start, SEEK_SET);
+                return false;
+            }
+        }
+        if (r.spec.empty() && r.bits.empty()) return false;
+        emitted++;
+        return true;
+    }
+};
+
+struct NysvRec {
+    std::vector<uint32_t> text;
+    std::vector<uint32_t> frames;
+};
+
+static bool read_nysv_rec(FILE* f, NysvRec& r) {
+    uint16_t tlen = 0, nfl = 0;
+    uint32_t rate = 0, plen = 0;
+    if (std::fread(&tlen, 2, 1, f) != 1) return false;
+    r.text.assign(tlen, 0);
+    if (tlen && std::fread(r.text.data(), 4, tlen, f) != (size_t)tlen) return false;
+    if (std::fread(&rate, 4, 1, f) != 1) return false;
+    if (std::fread(&nfl, 2, 1, f) != 1) return false;
+    r.frames.assign(nfl, 0);
+    if (nfl && std::fread(r.frames.data(), 4, nfl, f) != (size_t)nfl) return false;
+    if (std::fread(&plen, 4, 1, f) != 1) return false;
+    if (plen) std::fseek(f, plen, SEEK_CUR);
+    (void)rate;
+    return true;
+}
+
+struct NysvTail {
+    std::string path;
+    FILE* f = nullptr;
+    bool wrap = true;
+    uint64_t emitted = 0;
+    uint32_t record_count = 0;
+    static constexpr long kHdr = 12;
+
+    bool ensure() {
+        if (f) return true;
+        f = std::fopen(path.c_str(), "rb");
+        if (!f) return false;
+        char mag[4] = {};
+        uint32_t ver = 0, nrec = 0;
+        if (std::fread(mag, 1, 4, f) != 4 || std::memcmp(mag, "NYSV", 4) != 0 ||
+            std::fread(&ver, 4, 1, f) != 1 || std::fread(&nrec, 4, 1, f) != 1) {
+            std::fclose(f);
+            f = nullptr;
+            return false;
+        }
+        std::printf("[data] open NYSV %s header_nrec=%u\n", path.c_str(), nrec);
+        record_count = nrec;
+        return true;
+    }
+
+    bool try_read(NysvRec& r) {
+        if (!ensure()) return false;
+        long start = std::ftell(f);
+        if (!read_nysv_rec(f, r)) {
+            std::clearerr(f);
+            if (wrap) {
+                std::fseek(f, kHdr, SEEK_SET);
+                if (!read_nysv_rec(f, r)) return false;
+            } else {
+                std::fseek(f, start, SEEK_SET);
+                return false;
+            }
+        }
+        if (r.text.empty() || r.frames.empty()) return false;
+        emitted++;
+        return true;
+    }
+};
+
+static uint32_t compiler_base_for_n(uint32_t N) {
+    const uint32_t base = 3800000u;
+    const uint32_t bits = 64u;
+    if (N > base + bits) return base;
+    return N > bits + 256u ? N - bits - 1u : 256u;
+}
+
+static uint32_t speech_base_for_n(uint32_t N) {
+    const uint32_t base = 4300000u;
+    const uint32_t need = 400u * 256u;
+    if (N > base + need) return base;
+    return N > need + 256u ? N - need - 1u : 256u;
+}
+
+// Vocoder codes whose atom is flat (digital silence). Frames on these codes
+// stay in the records -- t indexing is untouched -- but are never nudged and
+// never used as negatives. About two-thirds of the speech corpus is literal
+// silence (frame stdev 0), and the silence node (t, code) is gold for most
+// records at every t, so each text pulled that one node toward its own phase:
+// +w against +w, the shared-register conflict the compiler band also has.
+//
+// Derived from the installed codebook at startup, so it follows whatever
+// vocoder is in the slots dir. An untrained codebook is mostly flat atoms
+// (the old one had 235/256), which would make "skip silence" mean "skip
+// nearly everything" -- so above kMaxSilenceCodes the skip is disabled and
+// training behaves exactly as it did before.
+static bool g_silence_code[256] = {false};
+static int g_n_silence = 0;
+static constexpr int kMaxSilenceCodes = 64;
+
+static void load_silence_codes(const std::string& slots_dir) {
+    std::string p = slots_dir;
+    if (!p.empty() && p.back() != '/') p.push_back('/');
+    p += "speech_vocoder.nyvc";
+    std::ifstream f(p, std::ios::binary);
+    if (!f) {
+        std::printf("[speech] no vocoder at %s -- silence frames will be nudged\n", p.c_str());
+        return;
+    }
+    char mag[4] = {};
+    uint32_t hdr[4] = {};
+    f.read(mag, 4);
+    f.read((char*)hdr, sizeof(hdr));
+    const uint32_t n_codes = hdr[1], fs = hdr[2];
+    if (!f || std::memcmp(mag, "NYVC", 4) != 0 || n_codes != 256u || fs == 0 || fs > 4096) {
+        std::printf("[speech] unreadable vocoder %s -- silence frames will be nudged\n", p.c_str());
+        return;
+    }
+    bool flat[256] = {false};
+    int count = 0;
+    std::vector<unsigned char> atom(fs);
+    for (uint32_t c = 0; c < n_codes; ++c) {
+        f.read((char*)atom.data(), (std::streamsize)fs);
+        if (!f) {
+            std::printf("[speech] short vocoder %s -- silence frames will be nudged\n", p.c_str());
+            return;
+        }
+        double m = 0.0;
+        for (uint32_t b = 0; b < fs; ++b) m += atom[b];
+        m /= (double)fs;
+        double v = 0.0;
+        for (uint32_t b = 0; b < fs; ++b) v += (atom[b] - m) * (atom[b] - m);
+        if (std::sqrt(v / (double)fs) < 1.0) {
+            flat[c] = true;
+            ++count;
+        }
+    }
+    if (count > kMaxSilenceCodes) {
+        std::printf("[speech] vocoder has %d flat atoms (untrained codebook) -- silence skip "
+                    "DISABLED\n", count);
+        return;
+    }
+    std::memcpy(g_silence_code, flat, sizeof(flat));
+    g_n_silence = count;
+    std::printf("[speech] silence codes (not nudged):");
+    for (int c = 0; c < 256; ++c) {
+        if (g_silence_code[c]) std::printf(" %d", c);
+    }
+    std::printf("  [%d]\n", count);
+}
+
+static bool speech_is_silence(uint32_t id, uint32_t N) {
+    if (g_n_silence == 0) return false;
+    uint32_t base = speech_base_for_n(N);
+    uint32_t c = id >= base ? (id - base) % 256u : (id & 255u);
+    return g_silence_code[c];
+}
+
+static bool next_voiced_speech(NysvTail& tail, NysvRec& rec,
+                              std::vector<uint32_t>& voiced, uint32_t N,
+                              uint64_t& skipped) {
+    if (!tail.ensure()) return false;
+    // Advance past valid but silent alignment rows within this slot. A bounded
+    // pass rejects wholly silent/unusable sources without reducing the diet.
+    for (uint32_t attempt=0; attempt<tail.record_count; ++attempt) {
+        if (!tail.try_read(rec)) { ++skipped; continue; }
+        voiced.clear();
+        for (uint32_t id : rec.frames)
+            if (id<N && !speech_is_silence(id,N)) voiced.push_back(id);
+        if (!voiced.empty() && !rec.text.empty()) return true;
+        ++skipped;
+    }
+    return false;
+}
+
+// Every frame ID that is gold for ANY record, loaded once at startup.
+//
+// A physical (t, code) node is reused by every record whose gold happens
+// to land on it, so a negative built from ONE record's frames can be a
+// different record's gold. Measured on the live corpus: 39.9% of the
+// positive pushes were fought by a negative push on the identical node,
+// which is why K on text->gold sat flat (mean 0.195, essentially k0) while
+// K on text->negative drifted up (mean 0.230) after 50k steps post-reset.
+// Checking against the corpus-wide gold set instead of just the current
+// record's frames removes that conflict at the data level. Loaded once
+// because NYSV is not live-tailed -- regenerating it always requires a
+// stop, unlike the mix corpus.
+static std::unordered_set<uint32_t> g_global_gold;
+
+static void load_global_gold_frames(const std::string& slots_dir) {
+    g_global_gold.clear();
+    const char* names[] = {"speech_align.nysv", "speech_slot.nysv"};
+    for (const char* name : names) {
+        std::string p = slots_dir;
+        if (!p.empty() && p.back() != '/') p.push_back('/');
+        p += name;
+        FILE* f = std::fopen(p.c_str(), "rb");
+        if (!f) continue;
+        char mag[4] = {};
+        uint32_t ver = 0, nrec = 0;
+        if (std::fread(mag, 1, 4, f) != 4 || std::memcmp(mag, "NYSV", 4) != 0 ||
+            std::fread(&ver, 4, 1, f) != 1 || std::fread(&nrec, 4, 1, f) != 1) {
+            std::fclose(f);
+            continue;
+        }
+        NysvRec r;
+        while (read_nysv_rec(f, r)) {
+            for (uint32_t fid : r.frames) g_global_gold.insert(fid);
+        }
+        std::fclose(f);
+    }
+    std::printf("[speech] global gold frames: %zu (negatives will avoid these)\n",
+                g_global_gold.size());
+}
+
+static bool speech_is_global_gold(uint32_t id) {
+    return g_global_gold.count(id) != 0;
+}
+
+// Neighbours of each gold code, used as NEGATIVE nudge targets.
+//
+// These used to be appended to the prompt, where they were ~97.5% of the
+// clamped set (mean 91.2 negatives against 2.3 text ids). The kernel builds
+// the nudge target as the circular mean over every prompt node, so sh_mean
+// was effectively the negatives' own phase: each step pulled the gold codes
+// toward their own neighbours and the text contributed 2.5% of the target.
+// The contrastive dc on text->gold was then zero-mean, which is why K on
+// those edges sat at the k0 the wiring pass wrote (median 0.2006, 50.2%
+// above k0) after 25k steps. As signed targets they push away from the
+// text's phase instead -- the same shape NYSA already uses for 0-bits.
+static std::vector<uint32_t> speech_negatives(const std::vector<uint32_t>& frames,
+                                              uint32_t N) {
+    std::vector<uint32_t> negs;
+    uint32_t base = speech_base_for_n(N);
+    std::unordered_set<uint32_t> gold(frames.begin(), frames.end());
+    auto is_gold = [&](uint32_t x) { return gold.count(x) != 0; };
+    int extra = 0;
+    for (uint32_t id : frames) {
+        if (extra >= 96) break;
+        uint32_t t = 0, c = id & 255u;
+        if (id >= base) {
+            t = (id - base) / 256u;
+            c = (id - base) % 256u;
+        }
+        // One negative per gold frame, not two: the dropped +127 offset
+        // doubled the total nudge mass on the negative side relative to
+        // gold for no benefit -- the 256 vocoder codes are unordered
+        // k-means cluster ids, not similarity-ranked, so +1 is no less a
+        // 'confusable' example than +127 was.
+        uint32_t n1 = base + t * 256u + ((c + 1u) & 255u);
+        if (n1 < N && !is_gold(n1) && !speech_is_silence(n1, N) &&
+            !speech_is_global_gold(n1)) {
+            negs.push_back(n1);
+            extra++;
+        }
+    }
+    return negs;
+}
+
+static int train_nysa_file(GpuState& g, const Args& a, const std::string& path) {
+    NysaTail t;
+    t.path = path;
+    t.wrap = false;
+    int steps = 0;
+    NysaRec rec;
+    while (t.try_read(rec)) {
+        if (a.max_steps > 0 && steps >= a.max_steps) break;
+        uint32_t cbase = compiler_base_for_n(g.N);
+        std::vector<std::pair<uint32_t, double>> nudges;
+        int nbits = (int)std::min(rec.bits.size(), (size_t)NysaTail::kActiveBits);
+        for (int b = 0; b < nbits; ++b) {
+            uint32_t id = cbase + (uint32_t)b;
+            if (id >= g.N) break;
+            nudges.emplace_back(id, rec.bits[b] ? a.beta : -a.beta);
+        }
+        if (nudges.empty()) continue;
+        auto pack = pack_step(rec.spec, nudges, g.N);
+        launch_step(g, pack, a.lr);
+        CUDA_CHECK(cudaDeviceSynchronize());
+        steps++;
+        if (a.save_every > 0 && steps % a.save_every == 0) save_snapshot(g, a, steps);
+    }
+    save_snapshot(g, a, steps);
+    std::printf("[train] NYSA done steps=%d\n", steps);
+    return 0;
+}
+
+static int train_nysv_file(GpuState& g, const Args& a, const std::string& path) {
+    NysvTail t;
+    t.path = path;
+    t.wrap = false;
+    int steps = 0;
+    NysvRec rec;
+    while (t.try_read(rec)) {
+        if (a.max_steps > 0 && steps >= a.max_steps) break;
+        std::vector<std::pair<uint32_t, double>> nudges;
+        // Silence frames stay in the record (t is unchanged) but are not
+        // targets; beta is spread over the voiced frames only.
+        std::vector<uint32_t> voiced;
+        for (uint32_t id : rec.frames) {
+            if (id < g.N && !speech_is_silence(id, g.N)) voiced.push_back(id);
+        }
+        double w = voiced.empty() ? 0.0 : a.beta / (double)voiced.size();
+        if (w > 0.0 && w < 0.25) w = 0.25;
+        for (uint32_t id : voiced) nudges.emplace_back(id, w);
+        if (nudges.empty() || rec.text.empty()) continue;
+        for (uint32_t nid : speech_negatives(voiced, g.N)) {
+            nudges.emplace_back(nid, -w);
+        }
+        // Prompt is the text alone, so sh_mean is the text's phase and the
+        // contrastive update on text->gold finally has a consistent sign.
+        auto pack = pack_step(rec.text, nudges, g.N);
+        launch_step(g, pack, a.lr);
+        CUDA_CHECK(cudaDeviceSynchronize());
+        steps++;
+        if (a.save_every > 0 && steps % a.save_every == 0) save_snapshot(g, a, steps);
+    }
+    save_snapshot(g, a, steps);
+    std::printf("[train] NYSV done steps=%d\n", steps);
+    return 0;
+}
+
+#include "distill_stdin.h"
+
+static int train_live(GpuState& g, const Args& a) {
+    std::unique_ptr<DistillStdin> teacher;
+    if (a.distill_stdin) {
+        teacher = std::make_unique<DistillStdin>(g.N);
+        std::puts("[stream] ready for Qwen SDS1 probabilities");
+    }
+    std::vector<HardTail> hards;
+    std::vector<Sds1Tail> sds1s;
+    std::vector<NysaTail> nysas;
+    std::vector<NysvTail> nysvs;
+    HardTail mix;
+    mix.live = true;
+    mix.wrap = false;
+    mix.path = a.live_mix;
+
+    for (const auto& path : a.corpora) {
+        if (!a.live_mix.empty() && path == a.live_mix) continue;
+        std::ifstream probe(path, std::ios::binary);
+        char magic[4] = {};
+        probe.read(magic, 4);
+        bool sds1 = probe.gcount() == 4 && std::memcmp(magic, "SDS1", 4) == 0;
+        bool nysa = probe.gcount() == 4 && std::memcmp(magic, "NYSA", 4) == 0;
+        bool nysv = probe.gcount() == 4 && std::memcmp(magic, "NYSV", 4) == 0;
+        bool nysd = probe.gcount() == 4 && std::memcmp(magic, "NYSD", 4) == 0;
+        probe.close();
+        if (nysd) {
+            std::printf("[data] skip NYSD dump envelope %s\n", path.c_str());
+        } else if (nysa) {
+            NysaTail t;
+            t.path = path;
+            nysas.push_back(std::move(t));
+        } else if (nysv) {
+            NysvTail t;
+            t.path = path;
+            nysvs.push_back(std::move(t));
+        } else if (sds1) {
+            Sds1Tail t;
+            t.path = path;
+            t.wrap = true;
+            sds1s.push_back(std::move(t));
+        } else {
+            HardTail t;
+            t.path = path;
+            t.wrap = true;
+            hards.push_back(std::move(t));
+        }
+    }
+
+    if (teacher && !sds1s.empty())
+        throw std::runtime_error("--distill-stdin replaces the SDS1 slot; do not also supply an SDS1 corpus");
+    if (a.require_full_curriculum && (!teacher || mix.path.empty() || hards.size()!=2 || nysas.size()!=1 || nysvs.size()!=2))
+        throw std::runtime_error("Complete curriculum requires mix, two hard corpora, Qwen, compiler, and both speech inputs");
+
+    int steps = a.resume_steps;
+    size_t hi = 0, di = 0, ci = 0, vi = 0;
+    int idle = 0;
+    std::printf("[train] live loop static_hard=%zu sds1=%zu nysa=%zu nysv=%zu mix=%s resume_steps=%d\n",
+                hards.size(), sds1s.size(), nysas.size(), nysvs.size(),
+                mix.path.empty() ? "(none)" : mix.path.c_str(), a.resume_steps);
+
+    double c_mix = 0, c_hard = 0, c_dist = 0, c_comp = 0, c_speech = 0;
+    auto log_rot = [&]() {
+        if (a.log_every <= 0 || steps % a.log_every != 0) return;
+        std::printf("  [step %d] mix=%.5f hard=%.5f distill=%.5f compiler=%.5f speech=%.5f mix_recs=%llu\n",
+                    steps, c_mix, c_hard, c_dist, c_comp, c_speech,
+                    (unsigned long long)mix.emitted);
+        std::fflush(stdout);
+    };
+
+    auto hard_step = [&](const std::vector<uint32_t>& toks, const char* src) {
+        if (toks.size() < 2) return;
+        uint32_t target = toks.back();
+        std::vector<uint32_t> prompt(toks.begin(), toks.end() - 1);
+        std::vector<std::pair<uint32_t, double>> nudges{{target, a.beta}};
+        auto pack = pack_step(prompt, nudges, g.N);
+        double contrast = launch_step(g, pack, a.lr);
+        CUDA_CHECK(cudaDeviceSynchronize());
+        steps++;
+        if (std::strcmp(src, "mix") == 0) c_mix = contrast;
+        else c_hard = contrast;
+        log_rot();
+        if (a.save_every > 0 && steps % a.save_every == 0) save_snapshot(g, a, steps);
+    };
+
+    while (a.max_steps < 0 || steps < a.max_steps) {
+        int rotation_start = steps;
+        bool did = false;
+        std::vector<uint32_t> toks;
+        std::vector<uint32_t> teacher_prompt, teacher_ids;
+        std::vector<float> teacher_probs;
+        // One teacher record paces one complete rotation. In particular, do not
+        // train other slots while Qwen loads, stalls, or has already finished.
+        if (teacher) {
+            int status;
+            do {
+                status = teacher->next(teacher_prompt, teacher_ids, teacher_probs);
+                if (!status) std::this_thread::sleep_for(std::chrono::milliseconds(5));
+            } while (!status);
+            if (status < 0) {
+                if (!teacher->emitted) throw std::runtime_error("teacher closed without records");
+                std::puts("[stream] teacher EOF; saving and stopping");
+                break;
+            }
+        }
+
+        if (!mix.path.empty() && mix.try_read(toks)) {
+            hard_step(toks, "mix");
+            did = true;
+            idle = 0;
+            if (a.max_steps > 0 && steps >= a.max_steps) break;
+        } else if (a.require_full_curriculum) {
+            throw std::runtime_error("Required mixed-language slot has no complete record");
+        }
+
+        if (!hards.empty()) {
+            for (size_t n = 0; n < hards.size(); ++n) {
+                size_t i = (hi + n) % hards.size();
+                if (hards[i].try_read(toks)) {
+                    hard_step(toks, "hard");
+                    hi = (i + 1) % hards.size();
+                    did = true;
+                    idle = 0;
+                    break;
+                }
+            }
+            if (a.max_steps > 0 && steps >= a.max_steps) break;
+        }
+
+        if (teacher) {
+            std::vector<std::pair<uint32_t, double>> nudges;
+            for (size_t i = 0; i < teacher_ids.size(); ++i)
+                nudges.emplace_back(teacher_ids[i], a.beta * teacher_probs[i]);
+            auto pack = pack_step(teacher_prompt, nudges, g.N);
+            c_dist = launch_step(g, pack, a.lr);
+            CUDA_CHECK(cudaDeviceSynchronize());
+            ++steps; did = true; idle = 0;
+            log_rot();
+            if (a.save_every > 0 && steps % a.save_every == 0) save_snapshot(g, a, steps);
+            if (a.max_steps > 0 && steps >= a.max_steps) break;
+        }
+
+        if (!sds1s.empty()) {
+            std::vector<uint32_t> prompt, ids;
+            std::vector<float> pr;
+            for (size_t n = 0; n < sds1s.size(); ++n) {
+                size_t i = (di + n) % sds1s.size();
+                if (!sds1s[i].try_read(prompt, ids, pr)) continue;
+                std::vector<std::pair<uint32_t, double>> nudges;
+                for (size_t k = 0; k < ids.size(); ++k) {
+                    if (pr[k] > 0.0f) nudges.emplace_back(ids[k], a.beta * (double)pr[k]);
+                }
+                if (!nudges.empty()) {
+                    auto pack = pack_step(prompt, nudges, g.N);
+                    double contrast = launch_step(g, pack, a.lr);
+                    CUDA_CHECK(cudaDeviceSynchronize());
+                    steps++;
+                    did = true;
+                    idle = 0;
+                    c_dist = contrast;
+                    log_rot();
+                    if (a.save_every > 0 && steps % a.save_every == 0) save_snapshot(g, a, steps);
+                }
+                di = (i + 1) % sds1s.size();
+                break;
+            }
+            if (a.max_steps > 0 && steps >= a.max_steps) break;
+        }
+
+        if (!nysas.empty()) {
+            NysaRec rec;
+            for (size_t n = 0; n < nysas.size(); ++n) {
+                size_t i = (ci + n) % nysas.size();
+                if (!nysas[i].try_read(rec)) continue;
+                uint32_t cbase = compiler_base_for_n(g.N);
+                std::vector<std::pair<uint32_t, double>> nudges;
+                int nbits = (int)std::min(rec.bits.size(), (size_t)NysaTail::kActiveBits);
+                for (int b = 0; b < nbits; ++b) {
+                    uint32_t id = cbase + (uint32_t)b;
+                    if (id >= g.N) break;
+                    nudges.emplace_back(id, rec.bits[b] ? a.beta : -a.beta);
+                }
+                if (!nudges.empty()) {
+                    auto pack = pack_step(rec.spec, nudges, g.N);
+                    double contrast = launch_step(g, pack, a.lr);
+                    CUDA_CHECK(cudaDeviceSynchronize());
+                    steps++;
+                    did = true;
+                    idle = 0;
+                    c_comp = contrast;
+                    log_rot();
+                    if (a.save_every > 0 && steps % a.save_every == 0) save_snapshot(g, a, steps);
+                }
+                ci = (i + 1) % nysas.size();
+                break;
+            }
+            if (a.max_steps > 0 && steps >= a.max_steps) break;
+        }
+
+        if (!nysvs.empty()) {
+            NysvRec rec;
+            for (size_t n = 0; n < nysvs.size(); ++n) {
+                size_t i = (vi + n) % nysvs.size();
+                std::vector<std::pair<uint32_t, double>> nudges;
+                std::vector<uint32_t> voiced;
+                if (a.require_full_curriculum) {
+                    uint64_t skipped=0;
+                    if (!next_voiced_speech(nysvs[i],rec,voiced,g.N,skipped))
+                        throw std::runtime_error("Required speech source has no voiced training records: "+nysvs[i].path);
+                    if (skipped) std::printf("[speech] skipped %llu silent/unusable rows within %s; speech slot retained\n",
+                                            (unsigned long long)skipped,nysvs[i].path.c_str());
+                } else {
+                    if (!nysvs[i].try_read(rec)) continue;
+                    for (uint32_t id : rec.frames)
+                        if (id < g.N && !speech_is_silence(id, g.N)) voiced.push_back(id);
+                }
+                double w = voiced.empty() ? 0.0 : a.beta / (double)voiced.size();
+                if (w > 0.0 && w < 0.25) w = 0.25;
+                for (uint32_t id : voiced) nudges.emplace_back(id, w);
+                if (!nudges.empty() && !rec.text.empty()) {
+                    for (uint32_t nid : speech_negatives(voiced, g.N)) {
+                        nudges.emplace_back(nid, -w);
+                    }
+                    // Text-only prompt: sh_mean is the text's phase, not the
+                    // negatives'. This is the live rotation's NYSV step.
+                    auto pack = pack_step(rec.text, nudges, g.N);
+                    double contrast = launch_step(g, pack, a.lr);
+                    CUDA_CHECK(cudaDeviceSynchronize());
+                    steps++;
+                    did = true;
+                    idle = 0;
+                    c_speech = contrast;
+                    log_rot();
+                    if (a.save_every > 0 && steps % a.save_every == 0) save_snapshot(g, a, steps);
+                }
+                vi = (i + 1) % nysvs.size();
+                break;
+            }
+            if (a.max_steps > 0 && steps >= a.max_steps) break;
+        }
+
+        if (a.require_full_curriculum && steps-rotation_start != 5)
+            throw std::runtime_error("Required five-slot rotation was incomplete; refusing reduced curriculum");
+        if (a.save_first_rotation && rotation_start == a.resume_steps)
+            save_snapshot(g, a, steps);
+        if (did) continue;
+        if (teacher) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(5));
+            continue;
+        }
+
+        bool mix_done = mix.path.empty();
+        if (!mix.path.empty()) {
+            std::ifstream df(mix.path + ".done");
+            mix_done = (bool)df;
+        }
+        std::this_thread::sleep_for(std::chrono::milliseconds(50));
+        idle++;
+        if (mix_done && idle > 40) {
+            std::puts("[train] live: mix done and no static records; stopping");
+            break;
+        }
+        if (a.live_idle_sec > 0 && idle * 50 > a.live_idle_sec * 1000 && steps == 0) {
+            std::puts("[train] live: idle with zero steps; stopping");
+            break;
+        }
+    }
+    save_snapshot(g, a, steps);
+    std::printf("[train] live done steps=%d mix_recs=%llu\n", steps,
+                (unsigned long long)mix.emitted);
+    return 0;
+}
+
+#include "cuda_self_test.h"
+
+static int steps_from_ckpt_path(const std::string& path) {
+    std::string src = path;
+    char link[768];
+    ssize_t n = readlink(path.c_str(), link, sizeof(link) - 1);
+    if (n > 0) {
+        link[n] = 0;
+        src = link;
+    }
+    auto slash = src.find_last_of('/');
+    std::string base = (slash == std::string::npos) ? src : src.substr(slash + 1);
+    int st = 0;
+    if (std::sscanf(base.c_str(), "gpu_eqprop_%d_", &st) == 1) return st;
+    return 0;
+}
+
+static bool check_ckpt(const Args& a) {
+    std::ifstream f(a.ckpt, std::ios::binary | std::ios::ate);
+    const uint64_t need = ckpt_bytes(a.N, a.k);
+    if (!f || (uint64_t)f.tellg() != need) {
+        std::cerr << "[ckpt] missing or wrong size: expected " << need << " bytes\n";
+        return false;
+    }
+    f.seekg(0);
+    uint32_t N = 0, k = 0;
+    f.read((char*)&N, 4);
+    f.read((char*)&k, 4);
+    if (!f || N != a.N || k != a.k) {
+        std::cerr << "[ckpt] N/k mismatch\n";
+        return false;
+    }
+    std::printf("[ckpt] header/size OK: %ux%u %llu bytes\n", N, k,
+                (unsigned long long)need);
+    return true;
+}
+
+static int main_impl(int argc, char** argv) {
+    std::setvbuf(stdout, nullptr, _IOLBF, 0);
+    std::setvbuf(stderr, nullptr, _IONBF, 0);
+    std::puts("=== NYS GPU EqProp (CUDA, no PyTorch) ===");
+    Args a = parse_args(argc, argv);
+    if (a.validate_distill_stdin) return validate_distill_stdin(a.N);
+    if (a.check_inputs) {
+        resolve_corpora(a);
+        for (const auto& path : a.corpora) {
+            std::ifstream f(path, std::ios::binary);
+            char magic[4] = {};
+            f.read(magic, 4);
+            if (!f) throw std::runtime_error("missing/empty corpus: " + path);
+            if (a.distill_stdin && !std::memcmp(magic, "SDS1", 4))
+                throw std::runtime_error("Qwen replaces the SDS1 slot; omit the legacy corpus");
+            std::printf("[inputs] %s\n", path.c_str());
+        }
+        std::string sd = a.slots_dir;
+        if (sd.empty() && !a.data_dir.empty()) sd = a.data_dir + "/slots";
+        if (!sd.empty()) {
+            load_silence_codes(sd);
+            load_global_gold_frames(sd);
+            if (a.require_full_curriculum) {
+                for (const char* name : {"speech_slot.nysv","speech_align.nysv"}) {
+                    NysvTail tail; tail.path=sd+"/"+name;
+                    if (!tail.ensure() || !tail.record_count) throw std::runtime_error("Empty speech source");
+                    uint64_t skipped=0;
+                    const uint32_t reads=2*tail.record_count;
+                    for (uint32_t j=0;j<reads;++j) {
+                        NysvRec rec; std::vector<uint32_t> voiced;
+                        if (!next_voiced_speech(tail,rec,voiced,a.N,skipped))
+                            throw std::runtime_error("Speech source cannot supply a voiced rotation");
+                    }
+                    std::printf("[inputs] voiced-reader %s passed %u reads; skipped=%llu\n",name,reads,(unsigned long long)skipped);
+                }
+            }
+        }
+        std::puts("[inputs] CPU inspection complete; no CUDA allocation or training");
+        return 0;
+    }
+    if (a.distill_stdin && (!a.live || a.settle || a.init)) {
+        std::cerr << "--distill-stdin requires --live and a resume checkpoint\n";
+        return 2;
+    }
+    g_omega_scale = a.omega_scale;
+    kFillNeighbors = a.fill_neighbors;
+    std::printf("[dyn] omega_scale=%g (1 = original dynamics)\n", g_omega_scale);
+
+    if (!a.probe && !a.self_test) {
+        if (a.init && !a.ckpt.empty()) {
+            std::cerr << "--init cannot be combined with --ckpt\n";
+            return 2;
+        }
+        if (!a.init && a.ckpt.empty()) {
+            std::cerr << "explicit --ckpt is required; use --init only for a new graph\n";
+            return 2;
+        }
+        if ((!a.init || a.check_ckpt) && !check_ckpt(a)) return 1;
+        if (a.check_ckpt) return 0;
+    }
+    probe_device(a.device, a.vram_limit_gb);
+    if (a.probe) return 0;
+
+    size_t free_b = 0, total_b = 0;
+    CUDA_CHECK(cudaMemGetInfo(&free_b, &total_b));
+    size_t cap = (a.vram_limit_gb > 0.0)
+                     ? (size_t)(a.vram_limit_gb * (double)(1ull << 30))
+                     : (size_t)(kVramFraction * (double)total_b);
+    if (cap > kVramLimitMax) cap = kVramLimitMax;
+
+    uint64_t model = a.self_test ? ckpt_bytes(4096, 32) : ckpt_bytes(a.N, a.k);
+    std::printf("[plan] model_state=%.3f GB  cap=%.3f GiB  leave_free_for_others=%.3f GiB\n",
+                model / 1e9, cap / (double)(1ull << 30), kLeaveFreeBytes / (double)(1ull << 30));
+    if (!a.self_test && model > cap) {
+        std::cerr << "[plan] model larger than VRAM cap\n";
+        return 3;
+    }
+    if (free_b < (size_t)model + kLeaveFreeBytes) {
+        std::cerr << "[plan] not enough free VRAM without crowding other jobs. abort.\n";
+        return 3;
+    }
+
+    if (a.self_test) return run_self_test(cap);
+
+    if (!a.init && !a.ckpt.empty() && a.resume_steps == 0) {
+        a.resume_steps = steps_from_ckpt_path(a.ckpt);
+        std::printf("[ckpt] resume_steps=%d from %s\n", a.resume_steps, a.ckpt.c_str());
+    }
+
+    if (!a.init && !a.settle && !a.live) {
+        std::cerr << "resuming the GPU lineage requires --live to preserve its step counter\n";
+        return 2;
+    }
+
+    if (a.settle) {
+        if (a.ckpt.empty() || a.init) {
+            std::cerr << "--settle needs --ckpt COMPLETE.bin, not a random init" << std::endl;
+            return 2;
+        }
+    } else {
+        resolve_corpora(a);
+        {
+            std::string sd = a.slots_dir;
+            if (sd.empty() && !a.data_dir.empty()) {
+                sd = a.data_dir;
+                if (sd.back() != '/') sd.push_back('/');
+                sd += "slots";
+            }
+            if (!sd.empty()) {
+                load_silence_codes(sd);
+                load_global_gold_frames(sd);
+            }
+        }
+        if (a.live) {
+            if (a.corpora.empty() && a.live_mix.empty() && !a.distill_stdin) {
+                std::cerr << "need --data-dir corpora or --live-mix\n";
+                return 2;
+            }
+        } else if (a.corpora.empty()) {
+            std::cerr << "need --corpus, --data-dir, --self-test, or --probe\n";
+            return 2;
+        }
+
+    }
+
+    GpuState g = alloc_state(a.N, a.k, cap);
+    if (a.init) {
+        std::puts("[init] random ring+stubs on host (not loading a ckpt)");
+        std::vector<double> theta, amp, omega;
+        std::vector<uint64_t> off;
+        std::vector<uint32_t> col;
+        std::vector<float> K;
+        host_init_graph(a.N, a.k, theta, amp, omega, off, col, K);
+        upload(g, theta, amp, omega, off, col, K);
+    } else {
+        load_ckpt(g, a.ckpt);
+    }
+
+    if (a.settle) return run_settle(g, a);
+
+    if (a.live) return train_live(g, a);
+
+    int rc = 0;
+    for (const auto& path : a.corpora) {
+        std::printf("[train] ===== %s =====\n", path.c_str());
+        std::ifstream probe(path, std::ios::binary);
+        char magic[4] = {};
+        probe.read(magic, 4);
+        bool sds1 = probe.gcount() == 4 && std::memcmp(magic, "SDS1", 4) == 0;
+        bool nysa = probe.gcount() == 4 && std::memcmp(magic, "NYSA", 4) == 0;
+        bool nysv = probe.gcount() == 4 && std::memcmp(magic, "NYSV", 4) == 0;
+        bool nysd = probe.gcount() == 4 && std::memcmp(magic, "NYSD", 4) == 0;
+        probe.close();
+        if (nysd) {
+            std::printf("[train] skip NYSD %s\n", path.c_str());
+        } else if (nysa) {
+            rc |= train_nysa_file(g, a, path);
+        } else if (nysv) {
+            rc |= train_nysv_file(g, a, path);
+        } else if (sds1) {
+            std::ifstream sds(path, std::ios::binary);
+            char mag[4] = {};
+            sds.read(mag, 4);
+            rc |= train_sds1(g, a, sds, path);
+        } else {
+            rc |= train_hard(g, a, path);
+        }
+    }
+    return rc;
+}
+
+int main(int argc, char** argv) {
+    try { return main_impl(argc, argv); }
+    catch (const std::exception& e) {
+        std::cerr << "[error] " << e.what() << std::endl;
+        return 1;
+    }
+}

lineages/corrected-20260930-v2/recovery/gpu_eqprop/hf_checkpoint_service.py

@@ -0,0 +1,458 @@
+#!/usr/bin/env python3
+"""L40S checkpoint uploads and separate, SHA-verified LOCAL retention.
+
+No GPU imports, remote deletion, repo creation, or directory-wide uploads.
+Zoey's latest checkpoint commit also includes a consistent warehouse snapshot
+and an explicit allowlist of recovery files. Credentials are never artifacts.
+"""
+import argparse
+from contextlib import contextmanager
+from datetime import datetime, timezone
+import hashlib
+import json
+import os
+from pathlib import Path
+import re
+import struct
+import tempfile
+import time
+
+SIZE = 20_640_000_016
+REPOS = {'nys': 'YNSScarSaiyan/nys-sft-public', 'zoey': 'YNSScarSaiyan/zoey'}
+PATTERNS = {
+    'nys': re.compile(r'gpu_eqprop_(\d+)_\d{8}_\d{6}\.bin\Z'),
+    'zoey': re.compile(r'zoey_vsa_distill_step_(\d+)\.json\Z'),
+}
+
+
+def now():
+    return datetime.now(timezone.utc).isoformat()
+
+
+def log(event, **fields):
+    print(json.dumps(dict(time=now(), event=event, **fields)), flush=True)
+
+
+def atomic_json(path, data):
+    tmp = path.with_suffix('.writing')
+    with tmp.open('w') as f:
+        json.dump(data, f, indent=2)
+        f.write('\n'); f.flush(); os.fsync(f.fileno())
+    tmp.replace(path)
+
+
+def verified_for_lineage(root, verified):
+    prefix = remote_prefix(Path(root))
+    return {key: record for key, record in verified.items()
+            if not prefix or record.get('remote_path', '').startswith(prefix)}
+
+
+def service_status(root):
+    """Read saved service identities and verify each PID's command line."""
+    service = Path(root)/'hf-services'
+    result = {}
+    for mode in ('upload', 'retain'):
+        path = service/f'{mode}.json'
+        entry = json.loads(path.read_text()) if path.exists() else {}
+        cmdline = Path('/proc')/str(entry.get('pid', 0))/'cmdline'
+        try:
+            command = cmdline.read_bytes().split(b'\0')
+        except FileNotFoundError:
+            command = []
+        entry['alive'] = (any(x.endswith(b'/hf_checkpoint_service.py') for x in command)
+                          and mode.encode() in command and entry.get('kind', '').encode() in command)
+        result[mode] = entry
+    path = service/'verified.json'
+    verified = json.loads(path.read_text()).get('verified', {}) if path.exists() else {}
+    verified = verified_for_lineage(root, verified)
+    result['verified_checkpoint_count'] = len(verified)
+    result['latest_verified'] = max(verified.values(), key=lambda x: x['step']) if verified else None
+    return result
+
+
+def signature(path):
+    st = path.stat()
+    return [st.st_size, st.st_mtime_ns, st.st_ino]
+
+
+def digest(path):
+    h = hashlib.sha256()
+    with path.open('rb') as f:
+        while chunk := f.read(16 * 1024 * 1024):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def candidates(root, kind, settle=20):
+    base = root/'checkpoints' if kind == 'nys' else root/'runtime/hf-pending'
+    paths = base.glob('qwen-*/*.bin') if kind == 'nys' else base.glob('*.json')
+    result = []
+    for path in paths:
+        if (path.parent/'DO_NOT_RESUME.json').exists():
+            continue
+        match = PATTERNS[kind].fullmatch(path.name)
+        if not match or path.is_symlink() or not path.resolve().is_relative_to(base.resolve()):
+            continue
+        try:
+            st = path.stat()
+            if st.st_size <= 0 or time.time()-st.st_mtime < settle:
+                continue
+            if kind == 'nys' and st.st_size != SIZE:
+                continue
+            result.append((int(match[1]), path))
+        except FileNotFoundError:
+            continue
+    return sorted(result, key=lambda item: (item[0], item[1].name), reverse=True)
+
+
+def inspect_checkpoint(path, kind, step):
+    before = signature(path)
+    meta = {}
+    if kind == 'nys':
+        with path.open('rb') as f:
+            if before[0] != SIZE or struct.unpack('<II', f.read(8)) != (5_000_000, 512):
+                raise ValueError('invalid NYS checkpoint size/header')
+    else:
+        with path.open() as f:
+            ckpt = json.load(f)
+        if (ckpt.get('step') != step or ckpt.get('map_ver') != 5
+                or not isinstance(ckpt.get('map5'), dict) or not ckpt['map5']
+                or type(ckpt.get('warehouse_consumed')) is not int
+                or ckpt['warehouse_consumed'] < 0):
+            raise ValueError('invalid Zoey checkpoint schema/cursor')
+        meta['warehouse_consumed'] = ckpt['warehouse_consumed']
+    sha = digest(path)
+    if signature(path) != before:
+        raise ValueError('checkpoint changed during inspection')
+    return dict(signature=before, bytes=before[0], sha256=sha, step=step, **meta)
+
+
+def field(obj, name):
+    return obj.get(name) if isinstance(obj, dict) else getattr(obj, name, None)
+
+
+def remote_matches(info, record):
+    lfs = field(info, 'lfs')
+    return (field(info, 'size') == record['bytes']
+            and field(lfs, 'size') == record['bytes']
+            and field(lfs, 'sha256') == record['sha256'])
+
+
+def remote_info(api, repo, name, revision=None):
+    infos = api.get_paths_info(repo, [name], repo_type='model', revision=revision)
+    return infos[0] if infos else None
+
+
+def protected_paths(root, kind, rows, keep):
+    protected = {p.resolve() for _, p in rows[:keep]}
+    if kind == 'nys' and rows:
+        active = json.loads((root/'runs/active_run.json').read_text())
+        if not re.fullmatch(r'qwen-[a-z0-9-]+', active['run_id']):
+            raise ValueError('invalid active NYS run')
+        started = json.loads((root/'runs'/active['run_id']/'started.json').read_text())
+        manifest_path = Path(started['checkpoint_manifest']).resolve()
+        if not manifest_path.is_relative_to(root.resolve()):
+            raise ValueError('resume manifest outside workspace')
+        manifest = json.loads(manifest_path.read_text())
+        protected.add(Path(manifest['local_path']).resolve())
+    return protected
+
+
+def snapshot_jsonl(source, dest):
+    import fcntl
+    rows = 0
+    with source.open('rb') as src, dest.open('wb') as out:
+        fcntl.flock(src, fcntl.LOCK_SH)
+        try:
+            # Bounded prefix, including for the raw stream whose writer does
+            # not lock. An incomplete trailing line is excluded.
+            remaining = os.fstat(src.fileno()).st_size
+            while remaining > 0:
+                line = src.readline(remaining)
+                remaining -= len(line)
+                if not line or not line.endswith(b'\n'):
+                    break
+                out.write(line)
+                rows += bool(line.strip())
+        finally:
+            fcntl.flock(src, fcntl.LOCK_UN)
+    return rows
+
+
+def snapshot_zoey(root, stage, record, name):
+    runtime = root/'runtime'
+    warehouse = stage/'zoey_warehouse.jsonl'
+    count = snapshot_jsonl(runtime/'corpus/zoey_warehouse.jsonl', warehouse)
+    if count < record['warehouse_consumed']:
+        raise ValueError('warehouse snapshot is shorter than checkpoint cursor')
+    stream = stage/'zoey_warehouse_stream.jsonl'
+    snapshot_jsonl(runtime/'corpus/zoey_warehouse_stream.jsonl', stream)
+    files = {'corpus/zoey_warehouse.jsonl': warehouse,
+             'corpus/zoey_warehouse_stream.jsonl': stream}
+    # Explicit paths only; never include tokens, caches or arbitrary runtime files.
+    for relative, src in {
+        'map5_see.json': runtime/'map5_see.json', 'flags.json': runtime/'flags.json',
+        'migration-manifest.json': runtime/'migration-manifest.json',
+        'teacher_manifest.json': root/'teacher_manifest.json',
+        'corpus/hose_seeds.txt': runtime/'corpus/hose_seeds.txt',
+        'merge-manifest.json': root/'merged-corpus/merge-manifest.json',
+    }.items():
+        before = signature(src)
+        target = stage/src.name
+        data = src.read_bytes()
+        if signature(src) != before:
+            raise ValueError(f'recovery file changed during snapshot: {relative}')
+        if src.suffix == '.json':
+            json.loads(data)
+        target.write_bytes(data)
+        files[relative] = target
+    checkpoint = json.loads((runtime/'hf-pending'/name).read_text())
+    if (root/'lineage.json').exists():
+        readout=checkpoint.get('readout_state')
+        if not readout or not readout.get('flags.json',{}).get('gemini_chooser'):
+            raise ValueError('Corrected checkpoint has no saved Gemini reader')
+        for relative,data in readout.items():
+            if relative not in ('flags.json','map5_see.json','chooser.json'):
+                raise ValueError('Unknown reader recovery file')
+            target=stage/relative
+            target.write_text(json.dumps(data))
+            files[relative]=target
+        for relative,src in {
+            'lineage.json':root/'lineage.json',
+            'chooser-acceptance.json':root/'validation/chooser-acceptance.json',
+            'source/zoey_neural_chooser.py':root/'source/zoey_neural_chooser.py',
+            'source/zoey_readout.py':root/'source/zoey_readout.py',
+            'source/zoey_see.py':root/'source/zoey_see.py',
+            'source/train_zoey_distill.py':root/'source/train_zoey_distill.py',
+        }.items():
+            target=stage/src.name
+            target.write_bytes(src.read_bytes())
+            files[relative]=target
+        source=root/'source'
+        code_paths=list(source.glob('zoey_*.py'))+list((source/'src').rglob('*.rs'))
+        code_paths += [p for p in (source/'Cargo.toml',source/'Cargo.lock') if p.is_file()]
+        code_paths += list((source/'l40s').glob('*.py'))+list((source/'l40s').glob('*.sh'))
+        for src in code_paths:
+            relative='source/'+src.relative_to(source).as_posix()
+            target=stage/'code'/src.relative_to(source)
+            target.parent.mkdir(parents=True,exist_ok=True)
+            target.write_bytes(src.read_bytes())
+            files[relative]=target
+    manifest = dict(checkpoint=f'{remote_prefix(root)}checkpoints/{name}', checkpoint_sha256=record['sha256'],
+                    warehouse_consumed=record['warehouse_consumed'], warehouse_rows=count,
+                    captured_utc=now(), files={k: dict(bytes=p.stat().st_size, sha256=digest(p))
+                                              for k, p in files.items()})
+    target = stage/'backup-manifest.json'
+    target.write_text(json.dumps(manifest, indent=2)+'\n')
+    files['backup-manifest.json'] = target
+    return files
+
+
+def needs_runtime_bundle(kind, step, state, previous, has_lineage=False):
+    # Legacy Zoey checkpoints can have larger step counters from a different
+    # schema/lineage. Compare only this deployment's verified checkpoints.
+    highest = max((r['step'] for r in state['verified'].values()), default=-1)
+    return ((kind == 'zoey' or has_lineage) and step >= highest
+            and not (previous and previous.get('runtime_bundle_verified')
+                     and (not has_lineage or previous.get('bundle_version') == 2)))
+
+
+def remote_prefix(root):
+    path=root/'lineage.json'
+    if not path.exists(): return ''
+    lineage=json.loads(path.read_text())['lineage']
+    if not re.fullmatch(r'[a-z0-9-]+',lineage): raise ValueError('Invalid backup lineage')
+    return 'lineages/'+lineage+'/'
+
+
+def snapshot_nys(root, stage, record, name):
+    files={}
+    for subdir,names in {
+        'data/corrected-mix':['mix_sft_sparse.bin','mix_manifest.json'],
+        'data/language_baseline':['vocab_sparse.json','train_corpus_sparse.bin','sft_corpus_sparse.bin','recovery_manifest.json'],
+        'data/slots':['compiler_physics.nysa','speech_align.nysv','speech_slot.nysv','speech_vocoder.nyvc','recovery_manifest.json'],
+    }.items():
+        for item in names:
+            path=root/subdir/item
+            if not path.is_file(): raise ValueError(f'Missing recovery input: {path}')
+            files[subdir+'/'+item]=path
+    code=['build_cuda.sh','run_cuda_l40s.sh','run_qwen_live.py','start_qwen_l40s.sh',
+          'qwen_live.py','validate_curriculum.py','eqprop_gpu.cu','distill_stdin.h','cuda_self_test.h',
+          'hf_checkpoint_service.py','start_backup_services.py','live_status.py','build_corrected_mix.py']
+    for relative in ['gpu_eqprop/'+n for n in code]+['hierarchical_tokenizer.py','source_checkpoint.json','lineage.json','recovery_policy.json']:
+        src=root/relative
+        target=stage/'code'/relative
+        target.parent.mkdir(parents=True,exist_ok=True)
+        target.write_bytes(src.read_bytes())
+        files[relative]=target
+    manifest=dict(checkpoint=remote_prefix(root)+name,checkpoint_sha256=record['sha256'],captured_utc=now(),
+                  files={n:dict(bytes=p.stat().st_size,sha256=digest(p)) for n,p in files.items()})
+    target=stage/'backup-manifest.json'
+    target.write_text(json.dumps(manifest,indent=2))
+    files['backup-manifest.json']=target
+    return files
+
+
+def upload_one(api, root, kind, path, record, service, publish_runtime=False):
+    from huggingface_hub import CommitOperationAdd
+    repo = REPOS[kind]
+    prefix=remote_prefix(root)
+    dest = prefix+(path.name if kind == 'nys' else 'checkpoints/'+path.name)
+    existing = remote_info(api, repo, dest)
+    if existing is not None:
+        if not remote_matches(existing, record):
+            raise ValueError(f'remote filename collision: {dest}; refusing to overwrite')
+        if not publish_runtime:
+            return dict(record, remote_path=dest, verified_utc=now())
+    with tempfile.TemporaryDirectory(prefix='snapshot-', dir=service) as folder:
+        stage = Path(folder)
+        operations = [CommitOperationAdd(path_in_repo=dest, path_or_fileobj=str(path))]
+        head = api.model_info(repo, files_metadata=False)
+        files = {}
+        bundle_prefix=prefix+('runtime/l40s/' if kind=='zoey' else 'recovery/')
+        if publish_runtime and kind=='zoey':
+            files = snapshot_zoey(root, stage, record, path.name)
+            operations.append(CommitOperationAdd(path_in_repo=prefix+'checkpoints/LATEST.txt',
+                                                 path_or_fileobj=(path.name+'\n').encode()))
+        elif publish_runtime and kind=='nys':
+            files=snapshot_nys(root,stage,record,path.name)
+        operations.extend(CommitOperationAdd(path_in_repo=bundle_prefix+name,
+                          path_or_fileobj=str(src)) for name,src in files.items())
+        if prefix and publish_runtime:
+            lineage=(root/'lineage.json').read_bytes()
+            operations.append(CommitOperationAdd(path_in_repo=prefix+'lineage.json',path_or_fileobj=lineage))
+            policy=root/'recovery_policy.json'
+            if policy.exists():
+                operations.append(CommitOperationAdd(path_in_repo=prefix+'recovery_policy.json',path_or_fileobj=str(policy)))
+            operations.append(CommitOperationAdd(path_in_repo=prefix+'LATEST.json',path_or_fileobj=json.dumps(
+                dict(path=dest,step=record['step'],bytes=record['bytes'],sha256=record['sha256'])).encode()))
+            if kind=='nys':
+                for name,src in {
+                    'mix_manifest.json':root/'data/corrected-mix/mix_manifest.json',
+                    'curriculum.json':path.parent/'curriculum.json',
+                }.items():
+                    operations.append(CommitOperationAdd(path_in_repo=prefix+name,path_or_fileobj=str(src)))
+        if signature(path) != record['signature']:
+            raise ValueError('checkpoint changed before upload')
+        log('upload_start', checkpoint=path.name, bytes=record['bytes'], repo=repo)
+        commit = api.create_commit(repo_id=repo, repo_type='model', operations=operations,
+                                   parent_commit=head.sha,
+                                   commit_message=f'L40S {kind} checkpoint {record["step"]}')
+        info = remote_info(api, repo, dest, revision=commit.oid)
+        if not remote_matches(info, record):
+            raise ValueError('HF size/SHA verification failed after commit')
+        if signature(path) != record['signature']:
+            raise ValueError('local checkpoint changed during upload')
+        if files:
+            infos = api.get_paths_info(repo, [bundle_prefix+name for name in files],
+                                       revision=commit.oid, repo_type='model')
+            if len(infos) != len(files):
+                raise ValueError('HF recovery bundle is incomplete')
+            for info in infos:
+                source = files[info.path.removeprefix(bundle_prefix)]
+                if info.size != source.stat().st_size:
+                    raise ValueError(f'HF recovery size mismatch: {info.path}')
+                if info.lfs:
+                    if field(info.lfs, 'sha256') != digest(source):
+                        raise ValueError(f'HF recovery SHA mismatch: {info.path}')
+                else:
+                    blob = source.read_bytes()
+                    expected = hashlib.sha1(b'blob '+str(len(blob)).encode()+b'\0'+blob).hexdigest()
+                    if info.blob_id != expected:
+                        raise ValueError(f'HF recovery Git blob mismatch: {info.path}')
+        return dict(record, remote_path=dest, commit=commit.oid, verified_utc=now(),
+                    runtime_bundle_verified=bool(files),bundle_version=2 if files else None)
+
+
+def retention_pass(api, root, kind, state, keep, dry_run=False):
+    rows = candidates(root, kind)
+    protected = protected_paths(root, kind, rows, keep)
+    for step, path in rows:
+        if path.resolve() in protected:
+            continue
+        key = path.relative_to(root).as_posix()
+        record = state.get('verified', {}).get(key)
+        if not record or signature(path) != record['signature']:
+            continue
+        info = remote_info(api, REPOS[kind], record['remote_path'])
+        if not remote_matches(info, record):
+            log('retain_unverified', checkpoint=path.name)
+            continue
+        # The uploader verified this exact inode/mtime/size against SHA. Verify
+        # identity again after the remote check; remove only this single file.
+        if signature(path) != record['signature'] or path.is_symlink():
+            continue
+        log('retain_would_delete' if dry_run else 'retain_delete', checkpoint=path.name,
+            bytes=record['bytes'], remote_sha256=record['sha256'])
+        if not dry_run:
+            path.unlink()
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument('--kind', choices=REPOS, required=True)
+    ap.add_argument('--mode', choices=['upload', 'retain'], required=True)
+    ap.add_argument('--root', type=Path, required=True)
+    ap.add_argument('--token-file', type=Path, required=True)
+    ap.add_argument('--keep', type=int, default=2)
+    ap.add_argument('--interval', type=int, default=30)
+    ap.add_argument('--once', action='store_true')
+    ap.add_argument('--dry-run', action='store_true')
+    args = ap.parse_args()
+    if args.keep < 2 or args.interval < 5:
+        raise ValueError('keep >= 2 and interval >= 5 required')
+    root = args.root.resolve()
+    if (root/'DO_NOT_RESUME_CURRENT_CHECKPOINTS.json').exists():
+        raise ValueError('User quarantined this deployment; upload and retention are disabled')
+    if (root/'lineage.json').exists() and json.loads((root/'lineage.json').read_text()).get('status') != 'VALIDATED':
+        raise ValueError('Corrected lineage has not passed validation')
+    service = root/'hf-services'
+    service.mkdir(exist_ok=True)
+    import fcntl
+    from huggingface_hub import HfApi
+    with (service/f'{args.mode}.lock').open('a') as lock:
+        fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        api = HfApi(token=args.token_file.read_text().strip())
+        api.model_info(REPOS[args.kind])  # Require the known repo to exist.
+        state_path = service/'verified.json'
+        atomic_json(service/f'{args.mode}.json', dict(pid=os.getpid(), started_utc=now(),
+                    kind=args.kind, mode=args.mode, repo=REPOS[args.kind], keep=args.keep))
+        log('service_started', mode=args.mode, kind=args.kind, keep=args.keep,
+            repo=REPOS[args.kind], dry_run=args.dry_run)
+        while True:
+            try:
+                state = json.loads(state_path.read_text()) if state_path.exists() else {'verified': {}}
+                if args.mode == 'retain':
+                    retention_pass(api, root, args.kind, state, args.keep, args.dry_run)
+                else:
+                    for step, path in candidates(root, args.kind):
+                        key = path.relative_to(root).as_posix()
+                        current_verified = verified_for_lineage(root, state['verified'])
+                        previous = current_verified.get(key)
+                        publish_runtime = needs_runtime_bundle(args.kind, step, {'verified': current_verified}, previous,
+                                                               has_lineage=bool(remote_prefix(root)))
+                        if previous and signature(path) == previous['signature'] and not publish_runtime:
+                            continue
+                        if args.dry_run:
+                            log('upload_candidate', checkpoint=path.name, step=step, bytes=path.stat().st_size)
+                            continue
+                        record = inspect_checkpoint(path, args.kind, step)
+                        state['verified'][key] = upload_one(api, root, args.kind, path, record, service,
+                                                           publish_runtime=publish_runtime)
+                        atomic_json(state_path, state)
+                        log('upload_verified', checkpoint=path.name, bytes=record['bytes'], sha256=record['sha256'])
+                        # Re-scan after each upload so newly saved checkpoints
+                        # take priority over the historical backlog.
+                        break
+            except Exception as exc:
+                message = re.sub(r'hf_[A-Za-z0-9]+', '[REDACTED]', str(exc))
+                log('error', mode=args.mode, error=type(exc).__name__, message=message[:600])
+                if args.once:
+                    raise SystemExit(1)
+            if args.once:
+                return
+            time.sleep(args.interval)
+
+
+if __name__ == '__main__':
+    main()

lineages/corrected-20260930-v2/recovery/gpu_eqprop/live_status.py

@@ -0,0 +1,93 @@
+#!/usr/bin/env python3
+"""Read the authorized L40S run's logs and checkpoints; never controls processes."""
+import argparse
+from collections import deque
+from datetime import datetime, timezone
+import hashlib
+import json
+from pathlib import Path
+import re
+import struct
+import subprocess
+from hf_checkpoint_service import service_status
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--verify-latest", action="store_true")
+    args = ap.parse_args()
+    root = Path(__file__).resolve().parents[1]
+    run_id = json.loads((root/"runs/active_run.json").read_text())["run_id"]
+    if not re.fullmatch(r"qwen-[a-z0-9-]+", run_id):
+        raise ValueError("invalid active run ID")
+    run = root/"runs"/run_id
+    started = json.loads((run/"started.json").read_text())
+    result = dict(checked_utc=datetime.now(timezone.utc).isoformat(), run_id=run_id, started=started)
+    if (run/"finished.json").exists():
+        result["finished"] = json.loads((run/"finished.json").read_text())
+    teacher, recent, skips, issues = None, deque(maxlen=500), 0, []
+    step = started["resume_step"]
+    save_step = step
+    contrast = None
+    if (run/"train.log").exists():
+        with (run/"train.log").open(errors="replace") as log:
+            for line in log:
+                m = re.search(r"\[step (\d+)\] (.+)", line)
+                if m:
+                    step, contrast = int(m[1]), m[2].strip()
+                saving = re.search(r'\[ckpt\] saving .*gpu_eqprop_(\d+)_\d{8}_\d{6}\.bin',line)
+                if saving:
+                    save_step=max(save_step,int(saving[1]))
+                if line.startswith('{"event":'):
+                    try:
+                        event = json.loads(line)
+                    except json.JSONDecodeError:
+                        continue  # Writer can be between writes during a status read.
+                    if event.get("event") == "record":
+                        teacher = event["record"]
+                        recent.append(event["retained_mass"])
+                    elif event.get("event") == "skipped":
+                        skips += 1
+                if any(s in line for s in ("[error]", "Traceback", "[qwen-live]", "CUDA error", "Fatal Python", "nan", "inf ")):
+                    issues.append(line.strip()[:400])
+    result.update(last_logged_step=step, updates=step-started["resume_step"],
+                  last_completed_update_step=max(step,save_step),
+                  contrast=contrast, teacher_records_emitted=teacher, teacher_skipped=skips,
+                  recent_teacher_records=len(recent),
+                  recent_retained_mass_min=min(recent) if recent else None,
+                  recent_retained_mass_mean=sum(recent)/len(recent) if recent else None,
+                  issues=issues[-10:])
+    result['checkpoint_writes']=[dict(path=str(p),bytes=p.stat().st_size,
+        modified_unix=p.stat().st_mtime) for p in (root/'checkpoints'/run_id).glob('*.bin.writing')]
+    files = []
+    for path in (root/"checkpoints"/run_id).glob("gpu_eqprop_*.bin"):
+        match = re.fullmatch(r"gpu_eqprop_(\d+)_\d{8}_\d{6}\.bin", path.name)
+        if match and path.stat().st_size == 20_640_000_016:
+            files.append((int(match[1]), path))
+    result["complete_checkpoint_count"] = len(files)
+    if files:
+        step, path = max(files, key=lambda item: (item[0], item[1].name))
+        with path.open("rb") as f:
+            dims = struct.unpack("<II", f.read(8))
+            digest = None
+            if args.verify_latest:
+                h = hashlib.sha256()
+                f.seek(0)
+                while chunk := f.read(16*1024*1024):
+                    h.update(chunk)
+                digest = h.hexdigest()
+        result["latest_checkpoint"] = dict(path=str(path), step=step, bytes=path.stat().st_size,
+                                           dimensions=dims, header_ok=dims==(5_000_000,512),
+                                           sha256=digest)
+    result["gpu1"] = subprocess.check_output([
+        "nvidia-smi", "-i", "1", "--query-gpu=uuid,memory.used,memory.free,utilization.gpu",
+        "--format=csv,noheader"], text=True).strip()
+    result["gpu_processes"] = subprocess.check_output([
+        "nvidia-smi", "--query-compute-apps=gpu_uuid,pid,process_name,used_memory",
+        "--format=csv,noheader"], text=True).strip().splitlines()
+    result["hf_backup"] = service_status(root)
+    print(json.dumps(result, indent=2))
+
+
+if __name__ == "__main__":
+    main()

lineages/corrected-20260930-v2/recovery/gpu_eqprop/qwen_live.py

@@ -0,0 +1,283 @@
+#!/usr/bin/env python3
+"""Qwen next-token probabilities -> frozen NYS IDs -> live SDS1 on stdout.
+
+No response generation and no corpus output. Multi-ID mappings are rejected:
+one teacher-token probability is not the probability of its first NYS piece.
+Duplicate single-ID mappings are summed; retained mass is never inflated.
+"""
+from __future__ import annotations
+
+import argparse
+from collections import defaultdict, deque
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import re
+import struct
+import sys
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from hierarchical_tokenizer import HierarchicalTokenizer
+
+GPU1 = "GPU-15278276-8f59-9540-a03f-7188fec578f9"
+HEADER = b"SDS1" + struct.pack("<I", 0xffffffff)
+FOOTER = b"\x00\x00DONE"
+N = 5_000_000
+
+
+def file_sha(path):
+    h = hashlib.sha256()
+    with open(path, "rb") as f:
+        while chunk := f.read(1024*1024):
+            h.update(chunk)
+    return h.hexdigest()
+
+
+def load_vocab(path, expected):
+    if file_sha(path) != expected.lower():
+        raise ValueError("frozen NYS vocabulary SHA-256 mismatch")
+    tok = HierarchicalTokenizer()
+    tok.load(str(path))
+    if not tok.vocab or any(type(v) is not int or v < 0 or v >= N for v in tok.vocab.values()):
+        raise ValueError("invalid NYS vocabulary IDs")
+    return tok
+
+
+def project_probabilities(tok, candidates):
+    """Conservative partial projection, not a full cross-tokenizer distribution."""
+    mass = defaultdict(float)
+    rejected = defaultdict(float)
+    total = 0.0
+    for text, probability in candidates:
+        if not math.isfinite(probability) or not 0 <= probability <= 1:
+            raise ValueError("invalid teacher probability")
+        total += probability
+        if probability == 0:
+            continue
+        if not text or "\ufffd" in text or "<|" in text:
+            rejected["special_or_undecodable"] += probability
+            continue
+        ids = tok.encode(text)
+        if len(ids) != 1:
+            rejected["multiple_or_empty_nys_ids"] += probability
+            continue
+        if not 0 <= ids[0] < N:
+            raise ValueError("teacher mapped outside NYS graph")
+        mass[ids[0]] += probability
+    if total > 1.00001:
+        raise ValueError("teacher top-k probability mass exceeds one")
+    # Float32 softmax plus duplicate-ID summation can exceed 1 by rounding
+    # (observed: 1.0000000000005385). Clamp only downward after checking total
+    # mass; this neither renormalizes nor inflates any target probability.
+    targets = [(token_id, min(1.0, probability)) for token_id, probability in mass.items()]
+    return sorted(targets, key=lambda x: (-x[1], x[0])), dict(rejected)
+
+
+def pack_record(prompt, targets):
+    if not 1 <= len(prompt) <= 127 or not 1 <= len(targets) <= 64:
+        raise ValueError("record exceeds active-set bounds")
+    if any(type(x) is not int or not 0 <= x < N for x in prompt):
+        raise ValueError("invalid prompt ID")
+    if len({x for x, _ in targets}) != len(targets):
+        raise ValueError("duplicate target ID")
+    for x, p in targets:
+        if type(x) is not int or not 0 <= x < N or not math.isfinite(p) or not 0 < p <= 1:
+            raise ValueError(f"invalid target ID/probability: id={x}, probability={p!r}")
+    if sum(p for _, p in targets) > 1.00001:
+        raise ValueError("target probability mass exceeds one")
+    return (struct.pack("<H", len(prompt)) + struct.pack(f"<{len(prompt)}I", *prompt)
+            + struct.pack("<H", len(targets))
+            + struct.pack(f"<{len(targets)}I", *(x for x, _ in targets))
+            + struct.pack(f"<{len(targets)}f", *(p for _, p in targets)))
+
+
+def prompt_text(row):
+    if isinstance(row.get("prompt"), str):
+        return row["prompt"]
+    for message in row.get("messages", []):
+        if message.get("role") == "user" and isinstance(message.get("content"), str):
+            return message["content"]
+    raise ValueError("input row has no user prompt")
+
+
+def iter_prompts(args):
+    if args.prompts:
+        with args.prompts.open(encoding="utf-8") as f:
+            for line in f:
+                if line.strip():
+                    yield prompt_text(json.loads(line))
+    else:
+        from datasets import load_dataset
+        if not args.dataset_revision or not re.fullmatch(r"[0-9a-f]{40}", args.dataset_revision):
+            raise ValueError("dataset source needs a pinned 40-character revision")
+        rows = iter(load_dataset(args.dataset, split=args.split, revision=args.dataset_revision,
+                                 streaming=True, token=False))
+        try:
+            for row in rows:
+                yield prompt_text(row)
+        finally:
+            close = getattr(rows, "close", None)
+            if close:
+                close()
+
+
+def unique_prompts(tok, prompts, skip=0):
+    """Rebuild the same deduplication prefix without running teacher inference.
+
+    prompt_index counts distinct, nonempty represented prompts; source_row
+    counts input rows. A pinned source and vocabulary are required for resume.
+    """
+    seen = set()
+    prompt_index = 0
+    for source_row, raw in enumerate(prompts, 1):
+        core = tok.encode(raw)[:96]
+        if not core:
+            continue
+        represented = tok.decode(core)
+        if represented in seen:
+            continue
+        seen.add(represented)
+        prompt_index += 1
+        if prompt_index > skip:
+            yield prompt_index, source_row, core, represented
+
+
+class MappingGuard:
+    """Stop a degraded bridge, without a lifetime limit on isolated rejections."""
+    def __init__(self, window=1000, max_skipped=100):
+        if window < 1 or not 0 <= max_skipped < window:
+            raise ValueError("require 0 <= max-skipped < skip-window")
+        self.recent = deque(maxlen=window)
+        self.skipped = 0
+        self.max_skipped = max_skipped
+
+    def observe(self, accepted):
+        if len(self.recent) == self.recent.maxlen:
+            self.skipped -= self.recent[0]
+        self.recent.append(not accepted)
+        self.skipped += not accepted
+        if self.skipped > self.max_skipped:
+            raise ValueError(f"too many low-coverage teacher mappings: {self.skipped} "
+                             f"of last {len(self.recent)}; inspect the bridge")
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--vocab", type=Path, required=True)
+    ap.add_argument("--vocab-sha256", required=True)
+    ap.add_argument("--model", required=True)
+    ap.add_argument("--revision", required=True)
+    source = ap.add_mutually_exclusive_group(required=True)
+    source.add_argument("--prompts", type=Path, help="JSONL user prompts, streamed once")
+    source.add_argument("--dataset", help="HF source of user prompts, not teacher targets")
+    ap.add_argument("--dataset-revision")
+    ap.add_argument("--split", default="train_sft")
+    ap.add_argument("--limit", type=int, default=1000, help="maximum accepted streamed records")
+    ap.add_argument("--top-k", type=int, default=64)
+    ap.add_argument("--min-mass", type=float, default=.05)
+    ap.add_argument("--max-skipped", type=int, default=100,
+                    help="maximum low-coverage rejections within --skip-window")
+    ap.add_argument("--skip-window", type=int, default=1000)
+    ap.add_argument("--skip-prompts", type=int, default=0,
+                    help="resume after this many unique represented source prompts")
+    args = ap.parse_args()
+    if os.environ.get("CUDA_VISIBLE_DEVICES") != GPU1:
+        raise ValueError("Qwen requires the pinned GPU 1 UUID in CUDA_VISIBLE_DEVICES")
+    if not re.fullmatch(r"[0-9a-f]{40}", args.revision) or "qwen" not in args.model.lower():
+        raise ValueError("specify a Qwen model and immutable 40-character HF revision")
+    if not 1 <= args.top_k <= 64 or args.limit < 1 or not 0 < args.min_mass <= 1:
+        raise ValueError("invalid stream limits")
+    guard = MappingGuard(args.skip_window, args.max_skipped)
+    if args.skip_prompts < 0:
+        raise ValueError("skip-prompts must be nonnegative")
+    tok = load_vocab(args.vocab, args.vocab_sha256)
+    # Validate the input source before allocating the teacher.
+    prompts = iter_prompts(args)
+    unique = unique_prompts(tok, prompts, args.skip_prompts)
+    first = next(unique, None)
+    if first is None:
+        raise ValueError("no remaining unique prompts after resume prefix")
+    import itertools
+    import torch
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+    if torch.cuda.device_count() != 1:
+        raise ValueError("teacher must see exactly one GPU")
+    # A bounded teacher allocation on GPU 1; the NYS trainer has its own 28 GiB cap.
+    torch.cuda.set_per_process_memory_fraction(.45, 0)
+    teacher_tok = AutoTokenizer.from_pretrained(args.model, revision=args.revision, token=False)
+    model = AutoModelForCausalLM.from_pretrained(
+        args.model, revision=args.revision, token=False, torch_dtype=torch.bfloat16,
+        trust_remote_code=False).to("cuda:0").eval()
+    if model.config.model_type not in ("qwen2", "qwen3"):
+        raise ValueError("this bridge validates Qwen2/Qwen3 text model tokenizers only")
+    metadata = dict(event="teacher", model=args.model, revision=args.revision,
+                    vocab_sha256=args.vocab_sha256, top_k=args.top_k,
+                    projection="single-NYS-ID, duplicate mass summed, no renormalization",
+                    dataset=args.dataset, dataset_revision=args.dataset_revision,
+                    skip_prompts=args.skip_prompts, first_prompt_index=first[0],
+                    skip_window=args.skip_window, max_skipped=args.max_skipped,
+                    prompts_sha256=file_sha(args.prompts) if args.prompts else None)
+    print(json.dumps(metadata), file=sys.stderr, flush=True)
+    out = sys.stdout.buffer
+    out.write(HEADER); out.flush()
+    emitted = skipped = 0
+    for prompt_index, source_row, core, represented in itertools.chain([first], unique):
+        # Both models see the same represented user content. Role markers are context only.
+        prompt = tok.encode(" user ") + core + tok.encode(" assistant ")
+        if len(prompt) > 127:
+            raise ValueError("role framing exceeds active-set budget")
+        text = teacher_tok.apply_chat_template(
+            [{"role": "user", "content": represented}], tokenize=False,
+            add_generation_prompt=True, enable_thinking=False)
+        inputs = teacher_tok(text, return_tensors="pt").to("cuda:0")
+        with torch.inference_mode():
+            logits = model(**inputs).logits[0, -1].float()
+            probabilities = torch.softmax(logits, dim=-1)
+            values, indices = probabilities.topk(args.top_k)
+        candidates = [(teacher_tok.decode([i], skip_special_tokens=False,
+                                          clean_up_tokenization_spaces=False), p)
+                      for i, p in zip(indices.tolist(), values.tolist())
+                      if i not in teacher_tok.all_special_ids]
+        targets, rejected = project_probabilities(tok, candidates)
+        retained = sum(p for _, p in targets)
+        if not targets or retained < args.min_mass:
+            skipped += 1
+            print(json.dumps(dict(event="skipped", prompt_index=prompt_index,
+                                  source_row=source_row, retained_mass=retained, rejected=rejected)),
+                  file=sys.stderr, flush=True)
+            guard.observe(False)
+            continue
+        guard.observe(True)
+        out.write(pack_record(prompt, targets)); out.flush()
+        emitted += 1
+        print(json.dumps(dict(event="record", record=emitted, targets=len(targets),
+                             prompt_index=prompt_index, source_row=source_row,
+                             retained_mass=retained, rejected=rejected,
+                             top_target_ids=targets[:3])), file=sys.stderr, flush=True)
+        if emitted >= args.limit:
+            break
+    if not emitted:
+        raise ValueError("no teacher records passed the mapping checks")
+    # Tear down a partially consumed Arrow stream while Python still owns the
+    # GIL, before emitting DONE or entering interpreter finalization.
+    unique.close()
+    prompts.close()
+    import gc
+    gc.collect()
+    out.write(FOOTER); out.flush()
+    free_bytes, total_bytes = torch.cuda.mem_get_info(0)
+    print(json.dumps(dict(event="complete", records=emitted, skipped=skipped,
+                         peak_teacher_allocated_bytes=torch.cuda.max_memory_allocated(0),
+                         gpu_free_bytes=free_bytes, gpu_total_bytes=total_bytes)), file=sys.stderr)
+
+
+if __name__ == "__main__":
+    try:
+        main()
+    except BrokenPipeError:
+        raise SystemExit(1)
+    except Exception as exc:
+        print(f"[qwen-live] {type(exc).__name__}: {exc}", file=sys.stderr)
+        raise SystemExit(1)

lineages/corrected-20260930-v2/recovery/gpu_eqprop/run_cuda_l40s.sh

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+# Physical GPU 1 is pinned by UUID; CUDA then exposes it as logical device 0.
+set -euo pipefail
+cd -- "$(dirname -- "${BASH_SOURCE[0]}")"
+expected=GPU-15278276-8f59-9540-a03f-7188fec578f9
+actual="$(nvidia-smi -i 1 --query-gpu=uuid --format=csv,noheader)"
+[[ "$actual" == "$expected" ]] || { echo 'GPU 1 UUID changed; aborting' >&2; exit 1; }
+export CUDA_VISIBLE_DEVICES="$expected"
+for arg in "$@"; do
+  [[ "$arg" != --init ]] || { echo 'This resume wrapper does not allow --init' >&2; exit 2; }
+done
+if (( $# == 0 )); then set -- --probe; fi
+exec ./eqprop_gpu_cuda "$@" --device 0 --vram-limit-gb 28 --omega-scale 0.01

lineages/corrected-20260930-v2/recovery/gpu_eqprop/run_qwen_live.py

@@ -0,0 +1,127 @@
+#!/usr/bin/env python3
+"""Supervise Qwen -> SDS1 pipe -> NYS. Prints the plan unless --run is supplied.
+
+Starts Qwen only after NYS has loaded its checkpoint, so the trainer's memory
+reserve check is deterministic. Never starts upload or retention services.
+"""
+import argparse
+import json
+import os
+from pathlib import Path
+import re
+import subprocess
+import sys
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__)
+    ap.add_argument("--checkpoint-manifest", type=Path, required=True)
+    ap.add_argument("--save-dir", type=Path, required=True)
+    ap.add_argument("--corpus", type=Path, action="append", default=[])
+    ap.add_argument("--live-mix", type=Path, required=True)
+    ap.add_argument("--mix-manifest", type=Path, required=True)
+    ap.add_argument("--slots-dir", type=Path,
+                    help="native speech inputs and matching vocoder for silence/negative filtering")
+    ap.add_argument("--max-steps", type=int, required=True, help="absolute final step, including resume")
+    ap.add_argument("--run", action="store_true")
+    ap.add_argument("teacher_args", nargs=argparse.REMAINDER, help="after --, arguments to qwen_live.py")
+    args = ap.parse_args()
+    here = Path(__file__).resolve().parent
+    root = here.parent
+    if args.run and (root/"DO_NOT_RESUME_CURRENT_CHECKPOINTS.json").exists():
+        raise ValueError("User stopped this deployment; current run checkpoints must not be resumed")
+    manifest = json.loads(args.checkpoint_manifest.read_text())
+    ckpt = Path(manifest["local_path"]).resolve()
+    if not manifest.get("verified") or ckpt.stat().st_size != 20_640_000_016:
+        raise ValueError("requires a verified complete checkpoint manifest")
+    match = re.fullmatch(r"gpu_eqprop_(\d+)_\d{8}_\d{6}\.bin", ckpt.name)
+    if not match or int(match[1]) != manifest["step"] or not manifest["step"] < args.max_steps <= 2_147_483_647:
+        raise ValueError("invalid checkpoint step or absolute stop step")
+    save_dir = args.save_dir.resolve()
+    if save_dir == ckpt.parent or ckpt.parent in save_dir.parents:
+        raise ValueError("write new snapshots outside the source checkpoint directory")
+    teacher_args = args.teacher_args
+    if teacher_args[:1] == ["--"]:
+        teacher_args = teacher_args[1:]
+    if not teacher_args:
+        raise ValueError("teacher arguments are required after --")
+    from validate_curriculum import validate
+    curriculum = validate(args.live_mix,args.mix_manifest,args.corpus,args.slots_dir,
+                          (args.max_steps-manifest['step']+4)//5)
+    trainer = ["bash", str(here/"run_cuda_l40s.sh"), "--live", "--distill-stdin",
+               "--require-full-curriculum", "--save-first-rotation", "--live-mix", str(args.live_mix.resolve()),
+               "--ckpt", str(ckpt), "--resume-steps", str(manifest["step"]),
+               "--save-dir", str(save_dir), "--save", str(save_dir/"nys_gpu_checkpoint.bin"),
+               "--save-every", "5000", "--log-every", "20", "--max-steps", str(args.max_steps)]
+    speech = False
+    for corpus in args.corpus:
+        if not corpus.is_file():
+            raise ValueError(f"missing corpus: {corpus}")
+        with corpus.open("rb") as f:
+            magic = f.read(4)
+        if magic == b"SDS1":
+            raise ValueError("Qwen replaces the SDS1 slot; omit the legacy distill corpus")
+        speech = speech or magic == b"NYSV"
+        trainer += ["--corpus", str(corpus.resolve())]
+    if speech and args.slots_dir is None:
+        raise ValueError("NYSV training requires --slots-dir with its recovered vocoder")
+    if args.slots_dir:
+        slots = args.slots_dir.resolve()
+        for name in ("compiler_physics.nysa", "speech_vocoder.nyvc", "speech_align.nysv", "speech_slot.nysv"):
+            if not (slots/name).is_file():
+                raise ValueError(f"missing native speech input: {slots/name}")
+        # Global gold filtering must read the same speech records being trained.
+        for corpus in args.corpus:
+            with corpus.open("rb") as f:
+                if f.read(4) == b"NYSV" and corpus.resolve() not in (
+                        slots/"speech_align.nysv", slots/"speech_slot.nysv"):
+                    raise ValueError("NYSV corpora must be the speech inputs in --slots-dir")
+        trainer += ["--slots-dir", str(slots)]
+    teacher = [str(root/"teacher-venv/bin/python"), str(here/"qwen_live.py"), *teacher_args]
+    print(json.dumps(dict(trainer=trainer, teacher=teacher, curriculum=curriculum, executes=args.run), indent=2), flush=True)
+    if not args.run:
+        return 0
+    # Rehash immediately before a real run; a stale manifest alone is insufficient.
+    from qwen_live import file_sha, GPU1
+    if file_sha(ckpt) != manifest["sha256"]:
+        raise ValueError("checkpoint no longer matches the verified SHA-256")
+    save_dir.mkdir(parents=True, exist_ok=True)
+    (save_dir/'curriculum.json').write_text(json.dumps(curriculum,indent=2))
+    env = os.environ.copy()
+    env.update(CUDA_VISIBLE_DEVICES=GPU1, HF_HOME=str(root/"hf-cache"),
+               TOKENIZERS_PARALLELISM="false", PYTHONUNBUFFERED="1")
+    prod = None
+    with subprocess.Popen(trainer, stdin=subprocess.PIPE, stdout=subprocess.PIPE,
+                          stderr=subprocess.STDOUT, env=env) as consumer:
+        try:
+            # Echo trainer diagnostics while waiting for its full checkpoint load.
+            for line in iter(consumer.stdout.readline, b""):
+                sys.stdout.buffer.write(line); sys.stdout.buffer.flush()
+                if b"[stream] ready" in line:
+                    prod = subprocess.Popen(teacher, stdout=consumer.stdin, env=env)
+                    consumer.stdin.close(); consumer.stdin = None
+                    break
+            if prod is None:
+                return consumer.wait() or 1
+            for line in iter(consumer.stdout.readline, b""):
+                sys.stdout.buffer.write(line); sys.stdout.buffer.flush()
+            code = consumer.wait()
+            # A bounded consumer can finish before the next teacher record.
+            # Terminate only the exact child we created, never a process-name match.
+            if prod.poll() is None:
+                prod.terminate()
+                prod.wait(timeout=30)
+                return code
+            return code or prod.returncode
+        finally:
+            for proc in (prod, consumer):
+                if proc is not None and proc.poll() is None:
+                    proc.terminate()
+                    try:
+                        proc.wait(timeout=30)
+                    except subprocess.TimeoutExpired:
+                        proc.kill(); proc.wait()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

lineages/corrected-20260930-v2/recovery/gpu_eqprop/start_backup_services.py

@@ -0,0 +1,38 @@
+"""Start one uploader and one verified retention worker for a validated root."""
+import argparse
+import json
+from pathlib import Path
+import subprocess
+import sys
+import time
+
+def main():
+    p=argparse.ArgumentParser()
+    p.add_argument('--root',type=Path,required=True)
+    p.add_argument('--kind',choices=['nys','zoey'],required=True)
+    p.add_argument('--token-file',type=Path,required=True)
+    args=p.parse_args()
+    root=args.root.resolve()
+    if (root/'DO_NOT_RESUME_CURRENT_CHECKPOINTS.json').exists() or json.loads((root/'lineage.json').read_text())['status']!='VALIDATED':
+        raise RuntimeError('Deployment is quarantined or not validated')
+    script=root/('gpu_eqprop/hf_checkpoint_service.py' if args.kind=='nys' else 'source/l40s/hf_checkpoint_service.py')
+    sys.path.insert(0,str(script.parent))
+    from hf_checkpoint_service import service_status
+    services=service_status(root)
+    base=root/'hf-services'; base.mkdir(exist_ok=True)
+    for mode in ('upload','retain'):
+        if services[mode]['alive']: continue
+        with (base/(mode+'.log')).open('ab',buffering=0) as log:
+            subprocess.Popen([str(root/'.venv/bin/python'),'-u',str(script),'--kind',args.kind,
+                              '--mode',mode,'--root',str(root),'--token-file',str(args.token_file),'--keep','2'],
+                             stdout=log,stderr=subprocess.STDOUT,stdin=subprocess.DEVNULL,
+                             start_new_session=True,close_fds=True)
+    deadline=time.monotonic()+15
+    while time.monotonic()<deadline:
+        services=service_status(root)
+        if all(services[m]['alive'] for m in ('upload','retain')):
+            print(json.dumps(services,indent=2)); return
+        time.sleep(.2)
+    raise RuntimeError('Backup services did not start; inspect their logs')
+
+if __name__=='__main__': main()

lineages/corrected-20260930-v2/recovery/gpu_eqprop/start_qwen_l40s.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+# Authorized 2026-09-30: one bounded live run, GPU 1 only, no HF publishing.
+set -euo pipefail
+ROOT="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")/.." && pwd)"
+cd "$ROOT"
+[[ ! -e "$ROOT/DO_NOT_RESUME_CURRENT_CHECKPOINTS.json" ]] || { echo 'User stopped this deployment. Its run checkpoints are quarantined; use the validated corrected deployment.' >&2; exit 1; }
+RUN_ID="${1:-qwen-20260930}"
+MANIFEST="${2:-$ROOT/source_checkpoint.json}"
+SKIP_PROMPTS="${3:-0}"
+TEACHER_LIMIT="${4:-40000}"
+MAX_STEP="${5:-2075000}"
+[[ "$RUN_ID" =~ ^qwen-[a-z0-9-]+$ ]] || { echo 'Invalid run ID' >&2; exit 1; }
+RUN="$ROOT/runs/$RUN_ID"
+mkdir -p "$RUN"
+exec 9>"$ROOT/runs/trainer.lock"
+flock -n 9 || { echo 'An NYS launch already holds the run lock' >&2; exit 1; }
+[[ ! -e "$RUN/started.json" ]] || { echo 'This run already started; inspect it before resuming' >&2; exit 1; }
+# Reserve space for the remaining periodic saves, two final-save equivalents,
+# and 10 GB headroom. Earlier run snapshots remain intact.
+"$ROOT/.venv/bin/python" - "$RUN" "$MANIFEST" "$SKIP_PROMPTS" "$TEACHER_LIMIT" "$MAX_STEP" <<'PY'
+from datetime import datetime, timezone
+import json, os, shutil, sys
+from pathlib import Path
+run, manifest_path = map(Path, sys.argv[1:3])
+skip, limit, maximum = map(int, sys.argv[3:])
+manifest = json.loads(manifest_path.read_text())
+resume = manifest['step']
+if not manifest.get('verified') or not 0 <= resume < maximum <= 2_147_483_647 or skip < 0 or limit < 1:
+    raise ValueError('invalid resume plan')
+needed = (maximum // 5000 - resume // 5000 + 2) * 20_640_000_016 + 10_000_000_000
+reservation = 'all remaining checkpoints'
+if shutil.disk_usage(run).free < needed:
+    sys.path.insert(0, str(run.parents[1]/'gpu_eqprop'))
+    from hf_checkpoint_service import service_status
+    services=service_status(run.parents[1])
+    if all(services[mode].get('alive') for mode in ('upload','retain')):
+        needed = 4 * 20_640_000_016 + 10_000_000_000
+        reservation = 'four checkpoints with verified local retention; trainer stops before low-space writes'
+if shutil.disk_usage(run).free < needed:
+    raise ValueError(f'insufficient space: need {needed} bytes for remaining saves')
+started = dict(pid=os.getppid(), started_utc=datetime.now(timezone.utc).isoformat(),
+               resume_step=resume, max_step=maximum, teacher_limit=limit,
+               teacher_skip_prompts=skip, checkpoint_manifest=str(manifest_path.resolve()),
+               reserved_disk_bytes=needed, reservation_policy=reservation)
+(run/'started.json').write_text(json.dumps(started) + '\n')
+active = run.parent/'active_run.json'
+temp = active.with_suffix('.json.writing')
+temp.write_text(json.dumps(dict(run_id=run.name)) + '\n')
+temp.replace(active)
+PY
+export HF_HUB_DISABLE_PROGRESS_BARS=1
+export PYTHONUNBUFFERED=1
+set +e
+"$ROOT/.venv/bin/python" -u gpu_eqprop/run_qwen_live.py \
+  --checkpoint-manifest "$MANIFEST" \
+  --save-dir "checkpoints/$RUN_ID" --max-steps "$MAX_STEP" \
+  --live-mix data/corrected-mix/mix_sft_sparse.bin \
+  --mix-manifest data/corrected-mix/mix_manifest.json \
+  --corpus data/language_baseline/train_corpus_sparse.bin \
+  --corpus data/language_baseline/sft_corpus_sparse.bin \
+  --slots-dir data/slots --run \
+  -- \
+  --model Qwen/Qwen3-8B \
+  --revision b968826d9c46dd6066d109eabc6255188de91218 \
+  --vocab "$ROOT/data/language_baseline/vocab_sparse.json" \
+  --vocab-sha256 23d96f815a5904045899fa304988fb011e21a6b25b612d729b8d833ae5e7388e \
+  --dataset HuggingFaceH4/ultrachat_200k \
+  --dataset-revision 8049631c405ae6576f93f445c6b8166f76f5505a \
+  --split train_sft --limit "$TEACHER_LIMIT" --skip-prompts "$SKIP_PROMPTS" \
+  --skip-window 1000 --max-skipped 100 >> "$RUN/train.log" 2>&1
+code=$?
+printf '{"exit_code":%d,"finished_utc":"%s"}\n' "$code" "$(date -u +%FT%TZ)" > "$RUN/finished.json"
+exit "$code"

lineages/corrected-20260930-v2/recovery/gpu_eqprop/validate_curriculum.py

@@ -0,0 +1,63 @@
+"""Fail-closed validation of the complete corrected NYS curriculum."""
+import hashlib
+import json
+from pathlib import Path
+import struct
+
+VOCAB_SHA='23d96f815a5904045899fa304988fb011e21a6b25b612d729b8d833ae5e7388e'
+SOURCE_SHA='406a691b1ac42112705c5193814f76ff064f922161d48ab0e3f67452403bbeec'
+SOURCES={'tulu3','openhermes','ultrachat','xlam','toolace','glaive','hermes_fc','orca','agent_flan'}
+
+def sha(path):
+    with Path(path).open('rb') as f: return hashlib.file_digest(f,'sha256').hexdigest()
+
+def check_file(path,info):
+    if path.stat().st_size!=info['bytes'] or sha(path)!=info['sha256']:
+        raise ValueError(f'Curriculum size/hash mismatch: {path}')
+
+def hard_records(path):
+    with path.open('rb') as f:
+        count,=struct.unpack('<I',f.read(4))
+        if not count: raise ValueError('Empty hard corpus')
+        for _ in range(count):
+            n,=struct.unpack('<H',f.read(2))
+            if not 2<=n<=2048: raise ValueError('Invalid record length')
+            ids=struct.unpack('<'+'I'*n,f.read(4*n))
+            if max(ids)>=5_000_000: raise ValueError('Out-of-range token')
+        if f.read(1): raise ValueError('Trailing hard corpus bytes')
+    return count
+
+def validate(mix_path,mix_manifest,corpora,slots,max_rotations):
+    if mix_path is None or mix_manifest is None or slots is None:
+        raise ValueError('Corrected training requires the mixed corpus, its manifest, and native slots')
+    m=json.loads(mix_manifest.read_text())
+    if not m.get('verified') or m.get('vocab_sha256')!=VOCAB_SHA:
+        raise ValueError('Unverified mix or wrong vocabulary')
+    if {r['name'] for r in m['sources']}!=SOURCES or any(r['records']<=0 for r in m['sources']):
+        raise ValueError('All nine original SFT sources must contribute')
+    if any(m.get('first_32000_source_counts',{}).get(name,0)<=0 for name in SOURCES):
+        raise ValueError('The bounded run prefix must include every source')
+    if m.get('converter_sha256')!='0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649':
+        raise ValueError('Mix was not built with the verified frozen-tokenizer converter')
+    if sum(r['records'] for r in m['sources'])!=m['records']:
+        raise ValueError('Mix source accounting mismatch')
+    check_file(mix_path,m)
+    if hard_records(mix_path)!=m['records']: raise ValueError('Mix record count mismatch')
+    # No wrapping is needed during this bounded recovery run.
+    if m['records']<max_rotations: raise ValueError('Insufficient mixed records for the whole run')
+    if {p.name for p in corpora}!={'train_corpus_sparse.bin','sft_corpus_sparse.bin'} or len(corpora)!=2:
+        raise ValueError('Both original hard-language corpora are required exactly once')
+    counts={'mix':m['records']}
+    for path in corpora:
+        baseline=json.loads((path.parent/'recovery_manifest.json').read_text())
+        check_file(path,baseline['files'][path.name])
+        check_file(path.parent/'vocab_sparse.json',baseline['files']['vocab_sparse.json'])
+        if baseline['files']['vocab_sparse.json']['sha256']!=VOCAB_SHA: raise ValueError('Wrong baseline vocabulary')
+        counts[path.name]=hard_records(path)
+    slot_manifest=json.loads((slots/'recovery_manifest.json').read_text())
+    if not slot_manifest.get('verified'): raise ValueError('Unverified native slots')
+    for name in ('compiler_physics.nysa','speech_align.nysv','speech_slot.nysv','speech_vocoder.nyvc'):
+        check_file(slots/name,slot_manifest['staged_files'][name])
+    counts.update(slot_manifest['record_counts'])
+    return dict(verified=True,rotation=['mix','hard','qwen_direct','compiler','speech'],records=counts,
+                mix_sha256=m['sha256'],mix_sources=sorted(SOURCES),vocab_sha256=VOCAB_SHA)

lineages/corrected-20260930-v2/recovery/hierarchical_tokenizer.py

@@ -0,0 +1,126 @@
+import os
+import re
+import json
+import logging
+import struct
+from collections import Counter
+
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+log = logging.getLogger("HierarchicalTokenizer")
+
+class HierarchicalTokenizer:
+    def __init__(self):
+        self.vocab = {}      # word/phrase -> token_id
+        self.inverse_vocab = {} # token_id -> word/phrase
+        
+        # 1. Initialize base vocabulary with raw bytes (0-255)
+        for i in range(256):
+            b_str = bytes([i]).decode('latin-1') # safe round-trip representation
+            self.vocab[b_str] = i
+            self.inverse_vocab[i] = b_str
+
+    def train(self, texts, target_vocab_size=5000000, max_phrase_length=4):
+        log.info(f"Training Hierarchical Phrase Tokenizer to target size: {target_vocab_size}...")
+        
+        # 1. Clean and normalize texts, then extract word n-grams (preserving whitespace)
+        word_token_pattern = re.compile(r"\w+|[^\w\s]|\s+")
+        
+        all_words = []
+        n_gram_counters = [Counter() for _ in range(max_phrase_length)]
+
+        log.info("Analyzing text corpora and counting phrase frequencies...")
+        for text in texts:
+            words = word_token_pattern.findall(text.lower())
+            all_words.extend(words)
+
+            # Record n-grams
+            for n in range(1, max_phrase_length + 1):
+                for i in range(len(words) - n + 1):
+                    phrase = " ".join(words[i:i+n])
+                    n_gram_counters[n-1][phrase] += 1
+
+        # 2. Extract best words and phrases based on frequencies
+        candidates = []
+        
+        # Keep words that appear at least twice
+        for word, freq in n_gram_counters[0].items():
+            if freq >= 2:
+                candidates.append((word, freq, len(word.split())))
+
+        # Keep multi-word phrases that appear at least 3 times
+        for n in range(2, max_phrase_length + 1):
+            for phrase, freq in n_gram_counters[n-1].items():
+                if freq >= 3:
+                    candidates.append((phrase, freq, len(phrase.split())))
+
+        # Sort candidates by frequency (descending)
+        candidates.sort(key=lambda x: x[1], reverse=True)
+
+        # 3. Add to vocabulary up to the target_vocab_size limit
+        current_id = 256
+        for item, freq, phrase_len in candidates:
+            if current_id >= target_vocab_size:
+                break
+            
+            # Avoid overwriting the raw byte slots
+            if item not in self.vocab:
+                self.vocab[item] = current_id
+                self.inverse_vocab[current_id] = item
+                current_id += 1
+
+        log.info(f"Vocabulary successfully built. Final size: {len(self.vocab)} tokens (IDs: 0 to {current_id - 1})")
+
+    def encode(self, text):
+        """Greedy longest-match phrase encoding."""
+        word_token_pattern = re.compile(r"\w+|[^\w\s]|\s+")
+        words = word_token_pattern.findall(text.lower())
+        
+        encoded_tokens = []
+        i = 0
+        n_words = len(words)
+        
+        while i < n_words:
+            matched = False
+            # Try to match the longest phrase starting at index i (up to 4 words/spaces)
+            for length in range(4, 0, -1):
+                if i + length <= n_words:
+                    phrase = " ".join(words[i:i+length])
+                    if phrase in self.vocab:
+                        encoded_tokens.append(self.vocab[phrase])
+                        i += length
+                        matched = True
+                        break
+            
+            if not matched:
+                # Character-level fallback for out-of-vocabulary single words/spaces
+                oov_word = words[i]
+                for char in oov_word:
+                    # Encode character as its byte equivalent
+                    char_byte = ord(char) if ord(char) < 256 else 63 # '?' fallback
+                    encoded_tokens.append(char_byte)
+                i += 1
+                
+        return encoded_tokens
+
+    def decode(self, token_ids):
+        """Decode token stream back to text."""
+        parts = []
+        for tid in token_ids:
+            if tid in self.inverse_vocab:
+                item = self.inverse_vocab[tid]
+                parts.append(item)
+            else:
+                parts.append(f"<{tid}>")
+                
+        return "".join(parts)
+
+    def save(self, vocab_path):
+        log.info(f"Saving vocabulary to {vocab_path}...")
+        with open(vocab_path, "w") as f:
+            json.dump(self.vocab, f, indent=2)
+
+    def load(self, vocab_path):
+        log.info(f"Loading vocabulary from {vocab_path}...")
+        with open(vocab_path, "r") as f:
+            self.vocab = json.load(f)
+        self.inverse_vocab = {int(v): k for k, v in self.vocab.items()}

lineages/corrected-20260930-v2/recovery/lineage.json

@@ -0,0 +1,11 @@
+{
+  "lineage": "corrected-20260930-v2",
+  "parent_root": "/data/nys-l40s",
+  "quarantined_parent_runs": true,
+  "source_step": 1915000,
+  "source_revision": "6f1f1e314e6d680f0e1541ddc6b1f6590b46cf40",
+  "status": "VALIDATED",
+  "full_curriculum_sha256": "e1e79d842ec60f3f646a563850a683e49519c6892807ee3a70a3a60047c3de81",
+  "mix_sha256": "425f2adaa8ab2a380b273d7abba3401855fcd792475c742627c0befa419273a9",
+  "superseded_lineage": "corrected-20260930"
+}

lineages/corrected-20260930-v2/recovery/recovery_policy.json

@@ -0,0 +1,95 @@
+{
+  "created_utc": "2026-09-30T16:51:26.166606+00:00",
+  "reason": "User rejected the prior deployments: NYS lacked the required mix; Zoey lacked Gemini chooser",
+  "quarantined_root": "/data/nys-l40s",
+  "exclude_all_run_outputs": true,
+  "original_source_revision": "6f1f1e314e6d680f0e1541ddc6b1f6590b46cf40",
+  "corrected_namespace": "lineages/corrected-20260930-v2/",
+  "selection_rule": "Use the corrected lineage manifest or the pinned original source, never repository-wide highest step",
+  "known_verified_remote_outputs": [
+    {
+      "bytes": 20640000016,
+      "sha256": "0c4763caf56bf393581dac9e032e3ad37cd1b6064f82162381830c289354584e",
+      "step": 2000000,
+      "remote_path": "gpu_eqprop_2000000_20260930_132916.bin",
+      "commit": "e33f42fcb859dc8fd43ce6921923d4552c7b9a93"
+    },
+    {
+      "bytes": 20640000016,
+      "sha256": "b5bae8a2a984f0ed01b8f0b16721095719857bb0f38c17c99f9922879b82c941",
+      "step": 1995000,
+      "remote_path": "gpu_eqprop_1995000_20260930_132014.bin",
+      "commit": "592300a451225e4c01825db06b2fd6ccc8d63ee9"
+    },
+    {
+      "bytes": 20640000016,
+      "sha256": "09184c4c4e74ec42fe8b5ebd5396573aedcc8ca6e497075b4dcbe8b8be0eba8f",
+      "step": 1990000,
+      "remote_path": "gpu_eqprop_1990000_20260930_131104.bin",
+      "commit": "4482e473d2d0040eece15e8644e6ce2ea4a0c09f"
+    },
+    {
+      "bytes": 20640000016,
+      "sha256": "4df3a5a9f724b60239d4c9a4462330425e21641238b3552f13e8b48074df7bc2",
+      "step": 1985000,
+      "remote_path": "gpu_eqprop_1985000_20260930_130154.bin",
+      "commit": "3a374292cb2e5f4d0c3dd43de8e28c237fa5d4eb"
+    },
+    {
+      "bytes": 20640000016,
+      "sha256": "f728c272680e0399268acc90f5e51b6345f50d506009f98fe9300f475134232c",
+      "step": 2005000,
+      "remote_path": "gpu_eqprop_2005000_20260930_150916.bin",
+      "commit": "b4b72f23d4997ec0f5d537f089be9b07b398e4b8"
+    },
+    {
+      "bytes": 20640000016,
+      "sha256": "363fe72d53955eed71d60a556e66cb6fa2c4322b41a132e67c77900390f2bc20",
+      "step": 1980000,
+      "remote_path": "gpu_eqprop_1980000_20260930_125247.bin",
+      "commit": "5c5bf1bcd676e4dc1d13beafc2d6000d71a5f0dc"
+    },
+    {
+      "bytes": 20640000016,
+      "sha256": "652f9acd94c4a977bb1df5466cfe27c911c3e5b2c396d31d81d53f414bca5c0e",
+      "step": 1975000,
+      "remote_path": "gpu_eqprop_1975000_20260930_124338.bin",
+      "commit": "3c98c79f9f4115d0191620874886cedddfc1e4c9"
+    },
+    {
+      "bytes": 20640000016,
+      "sha256": "6ce3d17580637beee6e223c33d6197dc4e2fdbfa8172cf8392acdc13eec87a99",
+      "step": 1970000,
+      "remote_path": "gpu_eqprop_1970000_20260930_123429.bin",
+      "commit": "6c91ae6376060ddd4db51f1d6766776c06673d81"
+    },
+    {
+      "bytes": 20640000016,
+      "sha256": "89b1f9d3bc939d695e5bfbc580c2b746d2626ca943c58d6e8f744026e12851c8",
+      "step": 2010000,
+      "remote_path": "gpu_eqprop_2010000_20260930_151818.bin",
+      "commit": "842dc9b0ef08798827b489a62e98ecdf40e48e4e"
+    },
+    {
+      "bytes": 20640000016,
+      "sha256": "547b726c248de15fe0ff94d7f87a50ee1a9c03cf89312664c5c1f3564110226b",
+      "step": 1965000,
+      "remote_path": "gpu_eqprop_1965000_20260930_122522.bin",
+      "commit": "5015b2ca767d822fbff6f3f286bcf72ca5a7ebcf"
+    },
+    {
+      "bytes": 20640000016,
+      "sha256": "7dd3b898d5b2cb7487a58ebdb628077d5e60b721cce664701a65aa0d59373545",
+      "step": 2015000,
+      "remote_path": "gpu_eqprop_2015000_20260930_152729.bin",
+      "commit": "19f0c19d07081b9f974d1cbc8d9da4a0bd6f06d1"
+    }
+  ],
+  "additional_excluded_namespaces": [
+    "lineages/corrected-20260930/"
+  ],
+  "additional_excluded_runs": [
+    "qwen-corrected-20260930"
+  ],
+  "additional_exclusion_reason": "Incomplete rotation guard stopped the first correction before silent speech rows were handled within their slot"
+}

lineages/corrected-20260930-v2/recovery/source_checkpoint.json

@@ -0,0 +1,12 @@
+{
+  "repo": "YNSScarSaiyan/nys-sft-public",
+  "revision": "6f1f1e314e6d680f0e1541ddc6b1f6590b46cf40",
+  "filename": "gpu_eqprop_1915000_20260913_095122.bin",
+  "step": 1915000,
+  "bytes": 20640000016,
+  "sha256": "406a691b1ac42112705c5193814f76ff064f922161d48ab0e3f67452403bbeec",
+  "N": 5000000,
+  "k": 512,
+  "local_path": "/data/nys-l40s/checkpoints/source/gpu_eqprop_1915000_20260913_095122.bin",
+  "verified": true
+}

lineages/corrected-20260930-v2/recovery_policy.json

@@ -0,0 +1,95 @@
+{
+  "created_utc": "2026-09-30T16:51:26.166606+00:00",
+  "reason": "User rejected the prior deployments: NYS lacked the required mix; Zoey lacked Gemini chooser",
+  "quarantined_root": "/data/nys-l40s",
+  "exclude_all_run_outputs": true,
+  "original_source_revision": "6f1f1e314e6d680f0e1541ddc6b1f6590b46cf40",
+  "corrected_namespace": "lineages/corrected-20260930-v2/",
+  "selection_rule": "Use the corrected lineage manifest or the pinned original source, never repository-wide highest step",
+  "known_verified_remote_outputs": [
+    {
+      "bytes": 20640000016,
+      "sha256": "0c4763caf56bf393581dac9e032e3ad37cd1b6064f82162381830c289354584e",
+      "step": 2000000,
+      "remote_path": "gpu_eqprop_2000000_20260930_132916.bin",
+      "commit": "e33f42fcb859dc8fd43ce6921923d4552c7b9a93"
+    },
+    {
+      "bytes": 20640000016,
+      "sha256": "b5bae8a2a984f0ed01b8f0b16721095719857bb0f38c17c99f9922879b82c941",
+      "step": 1995000,
+      "remote_path": "gpu_eqprop_1995000_20260930_132014.bin",
+      "commit": "592300a451225e4c01825db06b2fd6ccc8d63ee9"
+    },
+    {
+      "bytes": 20640000016,
+      "sha256": "09184c4c4e74ec42fe8b5ebd5396573aedcc8ca6e497075b4dcbe8b8be0eba8f",
+      "step": 1990000,
+      "remote_path": "gpu_eqprop_1990000_20260930_131104.bin",
+      "commit": "4482e473d2d0040eece15e8644e6ce2ea4a0c09f"
+    },
+    {
+      "bytes": 20640000016,
+      "sha256": "4df3a5a9f724b60239d4c9a4462330425e21641238b3552f13e8b48074df7bc2",
+      "step": 1985000,
+      "remote_path": "gpu_eqprop_1985000_20260930_130154.bin",
+      "commit": "3a374292cb2e5f4d0c3dd43de8e28c237fa5d4eb"
+    },
+    {
+      "bytes": 20640000016,
+      "sha256": "f728c272680e0399268acc90f5e51b6345f50d506009f98fe9300f475134232c",
+      "step": 2005000,
+      "remote_path": "gpu_eqprop_2005000_20260930_150916.bin",
+      "commit": "b4b72f23d4997ec0f5d537f089be9b07b398e4b8"
+    },
+    {
+      "bytes": 20640000016,
+      "sha256": "363fe72d53955eed71d60a556e66cb6fa2c4322b41a132e67c77900390f2bc20",
+      "step": 1980000,
+      "remote_path": "gpu_eqprop_1980000_20260930_125247.bin",
+      "commit": "5c5bf1bcd676e4dc1d13beafc2d6000d71a5f0dc"
+    },
+    {
+      "bytes": 20640000016,
+      "sha256": "652f9acd94c4a977bb1df5466cfe27c911c3e5b2c396d31d81d53f414bca5c0e",
+      "step": 1975000,
+      "remote_path": "gpu_eqprop_1975000_20260930_124338.bin",
+      "commit": "3c98c79f9f4115d0191620874886cedddfc1e4c9"
+    },
+    {
+      "bytes": 20640000016,
+      "sha256": "6ce3d17580637beee6e223c33d6197dc4e2fdbfa8172cf8392acdc13eec87a99",
+      "step": 1970000,
+      "remote_path": "gpu_eqprop_1970000_20260930_123429.bin",
+      "commit": "6c91ae6376060ddd4db51f1d6766776c06673d81"
+    },
+    {
+      "bytes": 20640000016,
+      "sha256": "89b1f9d3bc939d695e5bfbc580c2b746d2626ca943c58d6e8f744026e12851c8",
+      "step": 2010000,
+      "remote_path": "gpu_eqprop_2010000_20260930_151818.bin",
+      "commit": "842dc9b0ef08798827b489a62e98ecdf40e48e4e"
+    },
+    {
+      "bytes": 20640000016,
+      "sha256": "547b726c248de15fe0ff94d7f87a50ee1a9c03cf89312664c5c1f3564110226b",
+      "step": 1965000,
+      "remote_path": "gpu_eqprop_1965000_20260930_122522.bin",
+      "commit": "5015b2ca767d822fbff6f3f286bcf72ca5a7ebcf"
+    },
+    {
+      "bytes": 20640000016,
+      "sha256": "7dd3b898d5b2cb7487a58ebdb628077d5e60b721cce664701a65aa0d59373545",
+      "step": 2015000,
+      "remote_path": "gpu_eqprop_2015000_20260930_152729.bin",
+      "commit": "19f0c19d07081b9f974d1cbc8d9da4a0bd6f06d1"
+    }
+  ],
+  "additional_excluded_namespaces": [
+    "lineages/corrected-20260930/"
+  ],
+  "additional_excluded_runs": [
+    "qwen-corrected-20260930"
+  ],
+  "additional_exclusion_reason": "Incomplete rotation guard stopped the first correction before silent speech rows were handled within their slot"
+}

lineages/corrected-20260930/LATEST.json

@@ -0,0 +1 @@
+{"path": "lineages/corrected-20260930/gpu_eqprop_1915005_20260930_163300.bin", "step": 1915005, "bytes": 20640000016, "sha256": "c94c93db11ad89876d0b18b9ae1e1542e0e6a20df3366a8ecc0dad568b82a334"}

lineages/corrected-20260930/curriculum.json

@@ -0,0 +1,31 @@
+{
+  "verified": true,
+  "rotation": [
+    "mix",
+    "hard",
+    "qwen_direct",
+    "compiler",
+    "speech"
+  ],
+  "records": {
+    "mix": 2050000,
+    "train_corpus_sparse.bin": 255435,
+    "sft_corpus_sparse.bin": 50000,
+    "speech_align.nysv": 305,
+    "speech_slot.nysv": 6,
+    "compiler_physics.nysa": 412
+  },
+  "mix_sha256": "425f2adaa8ab2a380b273d7abba3401855fcd792475c742627c0befa419273a9",
+  "mix_sources": [
+    "agent_flan",
+    "glaive",
+    "hermes_fc",
+    "openhermes",
+    "orca",
+    "toolace",
+    "tulu3",
+    "ultrachat",
+    "xlam"
+  ],
+  "vocab_sha256": "23d96f815a5904045899fa304988fb011e21a6b25b612d729b8d833ae5e7388e"
+}

lineages/corrected-20260930/lineage.json

@@ -0,0 +1,10 @@
+{
+  "lineage": "corrected-20260930",
+  "parent_root": "/data/nys-l40s",
+  "quarantined_parent_runs": true,
+  "source_step": 1915000,
+  "source_revision": "6f1f1e314e6d680f0e1541ddc6b1f6590b46cf40",
+  "status": "VALIDATED",
+  "full_curriculum_sha256": "ee1184e158efb81e40a9aa6cede9884b774ce71acc766cbc2a1aea3d733b0b4a",
+  "mix_sha256": "425f2adaa8ab2a380b273d7abba3401855fcd792475c742627c0befa419273a9"
+}

lineages/corrected-20260930/mix_manifest.json

@@ -0,0 +1,187 @@
+{
+  "verified": true,
+  "records": 2050000,
+  "bytes": 810830240,
+  "sha256": "425f2adaa8ab2a380b273d7abba3401855fcd792475c742627c0befa419273a9",
+  "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649",
+  "vocab_sha256": "23d96f815a5904045899fa304988fb011e21a6b25b612d729b8d833ae5e7388e",
+  "sources": [
+    {
+      "name": "tulu3",
+      "repo": "allenai/tulu-3-sft-mixture",
+      "revision": "b14afda60f1bbebe55d5d2fa1e4df5042f97f8be",
+      "config": null,
+      "records": 273333,
+      "target_records": 273333,
+      "bytes": 74691934,
+      "sha256": "a6791c7f5ebfbf73982f16200c57da1f986ec82835e26d310337723811488efe",
+      "fed_conversations": {
+        "train": 14280
+      },
+      "normalized_input_sha256": "43a1ceebba233ccc1295c0e6e4c38df03ca107aeca88ba76aa8ebdff3db05739",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "openhermes",
+      "repo": "teknium/OpenHermes-2.5",
+      "revision": "b82037821055c377bed0d495e72e46de3bc72e84",
+      "config": null,
+      "records": 205000,
+      "target_records": 205000,
+      "bytes": 37265984,
+      "sha256": "a14995d3982265093dade0e5456bf4e807adc1606502a008e010bf1cae91a86e",
+      "fed_conversations": {
+        "train": 9472
+      },
+      "normalized_input_sha256": "0c8290012cd577e5fa0e719b3e1a109d0be0e7352a180fcc87d558123f96b55d",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "ultrachat",
+      "repo": "HuggingFaceH4/ultrachat_200k",
+      "revision": "8049631c405ae6576f93f445c6b8166f76f5505a",
+      "config": null,
+      "records": 205000,
+      "target_records": 205000,
+      "bytes": 54089028,
+      "sha256": "ca6fe7a2c74cf1612a51d6c8b425c4869a5147f56647581a318b148a1660fca0",
+      "fed_conversations": {
+        "train_sft": 8211
+      },
+      "normalized_input_sha256": "c5e3c60cfe787c0ee6dc15a934e2d9f0de46a866faafb8d871464f69972301de",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "xlam",
+      "repo": "Salesforce/xlam-function-calling-60k",
+      "revision": "26d14ebfe18b1f7b524bd39b404b50af5dc97866",
+      "config": "dataset",
+      "records": 273333,
+      "target_records": 273333,
+      "bytes": 133978174,
+      "sha256": "35fa9266bf1f5080dd52798145a68fcfaae141e5ae7060e9049d8b5518dc9f83",
+      "fed_conversations": {
+        "train": 11216
+      },
+      "normalized_input_sha256": "4d384db283209ff38aecbd1fc07498e9d2e9158aa5c151e488a6e3bcfa7dba73",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "toolace",
+      "repo": "Team-ACE/ToolACE",
+      "revision": "6bda777c88d21e5a204703c1ee45597a8fa4f734",
+      "config": null,
+      "records": 205000,
+      "target_records": 205000,
+      "bytes": 105319644,
+      "sha256": "4e2351be623bf5d2cb4e6c72fe5454289dbb467055d8ab5c4ef9f9a50cca8b36",
+      "fed_conversations": {
+        "train": 9014
+      },
+      "normalized_input_sha256": "129d36d3541f946be6d6199eaed8ab7a796cdd54ffc45abe735f9837c79e7e3d",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "glaive",
+      "repo": "glaiveai/glaive-function-calling-v2",
+      "revision": "e7f4b6456019f5d8bcb991ef0dd67d8ff23221ac",
+      "config": null,
+      "records": 205000,
+      "target_records": 205000,
+      "bytes": 80593548,
+      "sha256": "c1e0f9b1b3e57bea3d726ee282748959aaeefdce5a01dea4d10e980a152ee1fa",
+      "fed_conversations": {
+        "train": 8320
+      },
+      "normalized_input_sha256": "9a8a47aca6a49e0054690a267bdc610e9f9ffc2b67ae3782f00aae34921d33b7",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "hermes_fc",
+      "repo": "NousResearch/hermes-function-calling-v1",
+      "revision": "dae3e1d28cfbcf4b915c04ea1e072030529b4bda",
+      "config": "func_calling_singleturn",
+      "records": 47325,
+      "target_records": 136666,
+      "bytes": 24325054,
+      "sha256": "b83105e2de0c9317cbdf064b8a022c0e2e6994b20ee95a9e2aee28fa7a4ea2b3",
+      "fed_conversations": {
+        "train": 1893
+      },
+      "normalized_input_sha256": "f9faf972ab53f865c517574dd83540982ec94b3d19024acf941bd627117e09d5",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "orca",
+      "repo": "microsoft/orca-agentinstruct-1M-v1",
+      "revision": "86d609183249ff8037eae33d76ebca3af9390ea8",
+      "config": null,
+      "records": 273333,
+      "target_records": 273333,
+      "bytes": 115045826,
+      "sha256": "b9194dd3c45ac353809a19c851ef5935ef06d568c46943ab021963a4a8adf677",
+      "fed_conversations": {
+        "analytical_reasoning": 1873,
+        "code_": 1873,
+        "rag": 1872,
+        "follow_up": 1872,
+        "fs_cot_flow": 1872,
+        "open_domain_qa": 1872
+      },
+      "normalized_input_sha256": "c4b165c28a5e4ba92304e38d23f2da93cf691eb9eb137b847aa9f6f5592b7180",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "agent_flan",
+      "repo": "internlm/Agent-FLAN",
+      "revision": "8b25999e795a58b264fcb51e8746edb2faee9161",
+      "config": null,
+      "records": 362676,
+      "target_records": 362676,
+      "bytes": 185521080,
+      "sha256": "b760628a29e8f7e50237379d2ba4f4aaf4400b771706347032a80bc032524856",
+      "fed_conversations": {
+        "agent_instruct_tflan": 1730,
+        "agent_instruct_react": 1730,
+        "toolbench_tflan_60p_r10r5u7": 5530,
+        "toolbench_instruct_j1s1_3k": 5530
+      },
+      "normalized_input_sha256": "e67470488beec5b7dbc132d818185f9dc2c3fa5d39859dc59e27573e90582fca",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {
+        "agent_instruct_react": 1,
+        "agent_instruct_tflan": 1
+      },
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    }
+  ],
+  "shuffle_seed": 7,
+  "first_32000_source_counts": {
+    "tulu3": 4287,
+    "orca": 4204,
+    "agent_flan": 5622,
+    "xlam": 4393,
+    "ultrachat": 3193,
+    "openhermes": 3171,
+    "toolace": 3164,
+    "glaive": 3219,
+    "hermes_fc": 747
+  },
+  "note": "Rebuilt original nine-source recipe; not the unavailable historical byte-for-byte mix"
+}

lineages/corrected-20260930/recovery/backup-manifest.json

@@ -0,0 +1,119 @@
+{
+  "checkpoint": "lineages/corrected-20260930/gpu_eqprop_1915005_20260930_163300.bin",
+  "checkpoint_sha256": "c94c93db11ad89876d0b18b9ae1e1542e0e6a20df3366a8ecc0dad568b82a334",
+  "captured_utc": "2026-09-30T16:36:56.115009+00:00",
+  "files": {
+    "data/corrected-mix/mix_sft_sparse.bin": {
+      "bytes": 810830240,
+      "sha256": "425f2adaa8ab2a380b273d7abba3401855fcd792475c742627c0befa419273a9"
+    },
+    "data/corrected-mix/mix_manifest.json": {
+      "bytes": 7067,
+      "sha256": "bf22f42a0fd2fdcbdc23e60821e0614cd1bc5ab69b7c1589efc762c5adc4c624"
+    },
+    "data/language_baseline/vocab_sparse.json": {
+      "bytes": 106816698,
+      "sha256": "23d96f815a5904045899fa304988fb011e21a6b25b612d729b8d833ae5e7388e"
+    },
+    "data/language_baseline/train_corpus_sparse.bin": {
+      "bytes": 66816546,
+      "sha256": "a9b901c8c02b35eebe638abc0bc8ae551e359f51370890733ac917f0c8a97916"
+    },
+    "data/language_baseline/sft_corpus_sparse.bin": {
+      "bytes": 13200476,
+      "sha256": "91cc73e689d8e8e457221d3a20bb4d552cd9d2e5df1c1ed2f7ad2ce5c796cd60"
+    },
+    "data/language_baseline/recovery_manifest.json": {
+      "bytes": 703,
+      "sha256": "aac6d1a44e1037fcac4de6b3a9cc8de1e714c357f7495e9aff4fe6309dd561cb"
+    },
+    "data/slots/compiler_physics.nysa": {
+      "bytes": 48815,
+      "sha256": "052fc7dee4b1081392051b9fde2fac6533aa77e82dbea56ac32c27a67ced6cf8"
+    },
+    "data/slots/speech_align.nysv": {
+      "bytes": 1490468,
+      "sha256": "fea716002f75cde8a4567d64e28c14e353c3cdb349cd9ec8ecf3c991f52fbf8c"
+    },
+    "data/slots/speech_slot.nysv": {
+      "bytes": 15284,
+      "sha256": "2988cc801e2b95d6ebba35d335ec656486bc0fe0b5938d071a536c63879aca0c"
+    },
+    "data/slots/speech_vocoder.nyvc": {
+      "bytes": 20500,
+      "sha256": "028d0e759f9721b2110d8527028e7de3d80d5b611401d33db895d48e2f2df4d1"
+    },
+    "data/slots/recovery_manifest.json": {
+      "bytes": 3007,
+      "sha256": "b74dc14a623e7a4e1b9b1726d1c162a2e23cc19d373e9f53e1fd9064eb46dc35"
+    },
+    "gpu_eqprop/build_cuda.sh": {
+      "bytes": 287,
+      "sha256": "8c2148c696f5f4520b9cfa13bc6e80accc3de5630e449de0197391877db13173"
+    },
+    "gpu_eqprop/run_cuda_l40s.sh": {
+      "bytes": 640,
+      "sha256": "7f0360130f5d5f28c22e40310b9f6cec532ee0d8afd2cd1cf3afdd319375f96c"
+    },
+    "gpu_eqprop/run_qwen_live.py": {
+      "bytes": 6718,
+      "sha256": "deac34a492afb95687a97200955debb38d8a1f4e2c4bf39e8e6a64315e815ffb"
+    },
+    "gpu_eqprop/start_qwen_l40s.sh": {
+      "bytes": 3840,
+      "sha256": "b018e78b46355d022614352b362ee8bdc3bf8e701758cf97b60a7419ef33b0f8"
+    },
+    "gpu_eqprop/qwen_live.py": {
+      "bytes": 12912,
+      "sha256": "40ee3d2f4ba916f3d93db3f515a21af1feec3a1572b9d782798711ae7d787cf7"
+    },
+    "gpu_eqprop/validate_curriculum.py": {
+      "bytes": 3744,
+      "sha256": "d433f10fc417e2a87154c2c0e9721271d084ccb12f6bcda335c2a995cf79af02"
+    },
+    "gpu_eqprop/eqprop_gpu.cu": {
+      "bytes": 83588,
+      "sha256": "352fe64f735221128fe883c9d2baac13b2f66c4278bd24b471f351a2467c5fd9"
+    },
+    "gpu_eqprop/distill_stdin.h": {
+      "bytes": 4590,
+      "sha256": "6ad021d70316d74f29a43359f3436669d57827c84bdd47919e9c907f75c42eb3"
+    },
+    "gpu_eqprop/cuda_self_test.h": {
+      "bytes": 8128,
+      "sha256": "96e95af580d1d133cf72c7636f2da52ef0358f4d7e7978c5050029f8f61e0ff2"
+    },
+    "gpu_eqprop/hf_checkpoint_service.py": {
+      "bytes": 21698,
+      "sha256": "31e700a0471ad1e2c8fbe5fda61ed536f33bb57d72be8c0c73a728a145eb4172"
+    },
+    "gpu_eqprop/start_backup_services.py": {
+      "bytes": 1845,
+      "sha256": "de96145ac8e0ac90b48a72f9e199b5c7879e29967f9a52d5b5bc28493cd4c56f"
+    },
+    "gpu_eqprop/live_status.py": {
+      "bytes": 4503,
+      "sha256": "6de382c1565f95ca0ce4b6c94846c5c128b32c6af8e65bf7c980a0c48800c3a4"
+    },
+    "gpu_eqprop/build_corrected_mix.py": {
+      "bytes": 10711,
+      "sha256": "a2bcd06abe180432c009d84b6a298b9c6d893747a60f6a16f4eea5977136b27f"
+    },
+    "hierarchical_tokenizer.py": {
+      "bytes": 4963,
+      "sha256": "e7bacce12c795901359a57dbe2fc53915aa79f9a9c446ec5725c3e6e3f4a809f"
+    },
+    "source_checkpoint.json": {
+      "bytes": 422,
+      "sha256": "bda715ec4a981fd23d2164206b37956f639102fa20cd7c621f93bf81c018a8cc"
+    },
+    "lineage.json": {
+      "bytes": 403,
+      "sha256": "b0be0d97349ac609f0370311cc1a19795c68cc4deee088de246201e13a13d760"
+    },
+    "recovery_policy.json": {
+      "bytes": 3504,
+      "sha256": "6d5db68cb9911118b0f2df3c5b3262d00c616cb3801a27d3087c28bc099e1608"
+    }
+  }
+}

lineages/corrected-20260930/recovery/data/corrected-mix/mix_manifest.json

@@ -0,0 +1,187 @@
+{
+  "verified": true,
+  "records": 2050000,
+  "bytes": 810830240,
+  "sha256": "425f2adaa8ab2a380b273d7abba3401855fcd792475c742627c0befa419273a9",
+  "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649",
+  "vocab_sha256": "23d96f815a5904045899fa304988fb011e21a6b25b612d729b8d833ae5e7388e",
+  "sources": [
+    {
+      "name": "tulu3",
+      "repo": "allenai/tulu-3-sft-mixture",
+      "revision": "b14afda60f1bbebe55d5d2fa1e4df5042f97f8be",
+      "config": null,
+      "records": 273333,
+      "target_records": 273333,
+      "bytes": 74691934,
+      "sha256": "a6791c7f5ebfbf73982f16200c57da1f986ec82835e26d310337723811488efe",
+      "fed_conversations": {
+        "train": 14280
+      },
+      "normalized_input_sha256": "43a1ceebba233ccc1295c0e6e4c38df03ca107aeca88ba76aa8ebdff3db05739",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "openhermes",
+      "repo": "teknium/OpenHermes-2.5",
+      "revision": "b82037821055c377bed0d495e72e46de3bc72e84",
+      "config": null,
+      "records": 205000,
+      "target_records": 205000,
+      "bytes": 37265984,
+      "sha256": "a14995d3982265093dade0e5456bf4e807adc1606502a008e010bf1cae91a86e",
+      "fed_conversations": {
+        "train": 9472
+      },
+      "normalized_input_sha256": "0c8290012cd577e5fa0e719b3e1a109d0be0e7352a180fcc87d558123f96b55d",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "ultrachat",
+      "repo": "HuggingFaceH4/ultrachat_200k",
+      "revision": "8049631c405ae6576f93f445c6b8166f76f5505a",
+      "config": null,
+      "records": 205000,
+      "target_records": 205000,
+      "bytes": 54089028,
+      "sha256": "ca6fe7a2c74cf1612a51d6c8b425c4869a5147f56647581a318b148a1660fca0",
+      "fed_conversations": {
+        "train_sft": 8211
+      },
+      "normalized_input_sha256": "c5e3c60cfe787c0ee6dc15a934e2d9f0de46a866faafb8d871464f69972301de",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "xlam",
+      "repo": "Salesforce/xlam-function-calling-60k",
+      "revision": "26d14ebfe18b1f7b524bd39b404b50af5dc97866",
+      "config": "dataset",
+      "records": 273333,
+      "target_records": 273333,
+      "bytes": 133978174,
+      "sha256": "35fa9266bf1f5080dd52798145a68fcfaae141e5ae7060e9049d8b5518dc9f83",
+      "fed_conversations": {
+        "train": 11216
+      },
+      "normalized_input_sha256": "4d384db283209ff38aecbd1fc07498e9d2e9158aa5c151e488a6e3bcfa7dba73",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "toolace",
+      "repo": "Team-ACE/ToolACE",
+      "revision": "6bda777c88d21e5a204703c1ee45597a8fa4f734",
+      "config": null,
+      "records": 205000,
+      "target_records": 205000,
+      "bytes": 105319644,
+      "sha256": "4e2351be623bf5d2cb4e6c72fe5454289dbb467055d8ab5c4ef9f9a50cca8b36",
+      "fed_conversations": {
+        "train": 9014
+      },
+      "normalized_input_sha256": "129d36d3541f946be6d6199eaed8ab7a796cdd54ffc45abe735f9837c79e7e3d",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "glaive",
+      "repo": "glaiveai/glaive-function-calling-v2",
+      "revision": "e7f4b6456019f5d8bcb991ef0dd67d8ff23221ac",
+      "config": null,
+      "records": 205000,
+      "target_records": 205000,
+      "bytes": 80593548,
+      "sha256": "c1e0f9b1b3e57bea3d726ee282748959aaeefdce5a01dea4d10e980a152ee1fa",
+      "fed_conversations": {
+        "train": 8320
+      },
+      "normalized_input_sha256": "9a8a47aca6a49e0054690a267bdc610e9f9ffc2b67ae3782f00aae34921d33b7",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "hermes_fc",
+      "repo": "NousResearch/hermes-function-calling-v1",
+      "revision": "dae3e1d28cfbcf4b915c04ea1e072030529b4bda",
+      "config": "func_calling_singleturn",
+      "records": 47325,
+      "target_records": 136666,
+      "bytes": 24325054,
+      "sha256": "b83105e2de0c9317cbdf064b8a022c0e2e6994b20ee95a9e2aee28fa7a4ea2b3",
+      "fed_conversations": {
+        "train": 1893
+      },
+      "normalized_input_sha256": "f9faf972ab53f865c517574dd83540982ec94b3d19024acf941bd627117e09d5",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "orca",
+      "repo": "microsoft/orca-agentinstruct-1M-v1",
+      "revision": "86d609183249ff8037eae33d76ebca3af9390ea8",
+      "config": null,
+      "records": 273333,
+      "target_records": 273333,
+      "bytes": 115045826,
+      "sha256": "b9194dd3c45ac353809a19c851ef5935ef06d568c46943ab021963a4a8adf677",
+      "fed_conversations": {
+        "analytical_reasoning": 1873,
+        "code_": 1873,
+        "rag": 1872,
+        "follow_up": 1872,
+        "fs_cot_flow": 1872,
+        "open_domain_qa": 1872
+      },
+      "normalized_input_sha256": "c4b165c28a5e4ba92304e38d23f2da93cf691eb9eb137b847aa9f6f5592b7180",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {},
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    },
+    {
+      "name": "agent_flan",
+      "repo": "internlm/Agent-FLAN",
+      "revision": "8b25999e795a58b264fcb51e8746edb2faee9161",
+      "config": null,
+      "records": 362676,
+      "target_records": 362676,
+      "bytes": 185521080,
+      "sha256": "b760628a29e8f7e50237379d2ba4f4aaf4400b771706347032a80bc032524856",
+      "fed_conversations": {
+        "agent_instruct_tflan": 1730,
+        "agent_instruct_react": 1730,
+        "toolbench_tflan_60p_r10r5u7": 5530,
+        "toolbench_instruct_j1s1_3k": 5530
+      },
+      "normalized_input_sha256": "e67470488beec5b7dbc132d818185f9dc2c3fa5d39859dc59e27573e90582fca",
+      "max_per_conversation": 25,
+      "skipped_no_assistant_targets": {
+        "agent_instruct_react": 1,
+        "agent_instruct_tflan": 1
+      },
+      "converter_sha256": "0e478ad6b522e193fc052888a269aa2aa076633183e29f6e5cf2b7263d413649"
+    }
+  ],
+  "shuffle_seed": 7,
+  "first_32000_source_counts": {
+    "tulu3": 4287,
+    "orca": 4204,
+    "agent_flan": 5622,
+    "xlam": 4393,
+    "ultrachat": 3193,
+    "openhermes": 3171,
+    "toolace": 3164,
+    "glaive": 3219,
+    "hermes_fc": 747
+  },
+  "note": "Rebuilt original nine-source recipe; not the unavailable historical byte-for-byte mix"
+}

lineages/corrected-20260930/recovery/data/language_baseline/recovery_manifest.json

@@ -0,0 +1,22 @@
+{
+  "repo": "YNSScarSaiyan/nys-corpus",
+  "revision": "7eb0b0dd1f3122a4189d33ae6cc13c21d0a25774",
+  "files": {
+    "vocab_sparse.json": {
+      "bytes": 106816698,
+      "sha256": "23d96f815a5904045899fa304988fb011e21a6b25b612d729b8d833ae5e7388e"
+    },
+    "train_corpus_sparse.bin": {
+      "bytes": 66816546,
+      "sha256": "a9b901c8c02b35eebe638abc0bc8ae551e359f51370890733ac917f0c8a97916"
+    },
+    "sft_corpus_sparse.bin": {
+      "bytes": 13200476,
+      "sha256": "91cc73e689d8e8e457221d3a20bb4d552cd9d2e5df1c1ed2f7ad2ce5c796cd60"
+    },
+    "distill_corpus_sparse.bin": {
+      "bytes": 15363524,
+      "sha256": "e1e27ee163ef7288fa6d68230fe167ef368e553ac8f19922019d80f87eb7e4e4"
+    }
+  }
+}

lineages/corrected-20260930/recovery/data/language_baseline/vocab_sparse.json

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

lineages/corrected-20260930/recovery/data/slots/recovery_manifest.json

@@ -0,0 +1,108 @@
+{
+  "verified": true,
+  "checks": {
+    "2_compiler": true,
+    "4_speech": true,
+    "hard": true,
+    "sft": true,
+    "distill": true,
+    "source_checkpoint_sha256_unchanged": true
+  },
+  "record_counts": {
+    "speech_align.nysv": 305,
+    "speech_slot.nysv": 6,
+    "compiler_physics.nysa": 412
+  },
+  "checkpoint": "gpu_eqprop_1915000_20260913_095122.bin",
+  "checkpoint_sha256": "406a691b1ac42112705c5193814f76ff064f922161d48ab0e3f67452403bbeec",
+  "published_revision": "6f1f1e314e6d680f0e1541ddc6b1f6590b46cf40",
+  "vocoder_sha256": "028d0e759f9721b2110d8527028e7de3d80d5b611401d33db895d48e2f2df4d1",
+  "original_slot_sha256": {
+    "compiler_physics.nysa": "052fc7dee4b1081392051b9fde2fac6533aa77e82dbea56ac32c27a67ced6cf8",
+    "speech_slot.nysv": "2fd8be22d9408bb5d88a11b1c27c6c0ac80f42d7808f93a8d1ed31734a5f5cee",
+    "speech_align.nysv": "274f4d2e283a6b1de14eb73d4ea4f6c2e10fc18aff8bd7f1d1aca29b5e1430c5"
+  },
+  "actual": {
+    "slots": {
+      "1_language": {
+        "mix": {
+          "acc": null,
+          "hits": 0,
+          "n": 0,
+          "in_pool": 0,
+          "in_pool_frac": null
+        },
+        "hard": {
+          "acc": 0.0,
+          "hits": 0,
+          "n": 32,
+          "in_pool": 4,
+          "in_pool_frac": 0.125
+        },
+        "sft": {
+          "acc": 0.0,
+          "hits": 0,
+          "n": 32,
+          "in_pool": 30,
+          "in_pool_frac": 0.9375
+        },
+        "distill": {
+          "acc": 0.0,
+          "hits": 0,
+          "n": 32,
+          "in_pool": 18,
+          "in_pool_frac": 0.5625
+        }
+      },
+      "2_compiler": {
+        "clamped_free": {
+          "acc": 0.6385690789473685,
+          "hits": 1553,
+          "n": 2432,
+          "in_pool": 2432,
+          "in_pool_frac": 1.0
+        },
+        "spin_free": {
+          "acc": 0.4004934210526316,
+          "hits": 974,
+          "n": 2432,
+          "in_pool": 2432,
+          "in_pool_frac": 1.0
+        },
+        "n_recs": 64,
+        "n_free": 38
+      },
+      "4_speech": {
+        "acc": 0.10825043885313049,
+        "hits": 185,
+        "n": 1709,
+        "in_pool": 700,
+        "in_pool_frac": 0.4095962551199532
+      }
+    },
+    "headline": {
+      "language": 0.0,
+      "compiler": 0.6385690789473685,
+      "speech": 0.10825043885313049
+    }
+  },
+  "limitation": "Original live mix is unavailable; its score and aggregate language headline cannot be reproduced.",
+  "staged_files": {
+    "compiler_physics.nysa": {
+      "bytes": 48815,
+      "sha256": "052fc7dee4b1081392051b9fde2fac6533aa77e82dbea56ac32c27a67ced6cf8"
+    },
+    "speech_vocoder.nyvc": {
+      "bytes": 20500,
+      "sha256": "028d0e759f9721b2110d8527028e7de3d80d5b611401d33db895d48e2f2df4d1"
+    },
+    "speech_align.nysv": {
+      "bytes": 1490468,
+      "sha256": "fea716002f75cde8a4567d64e28c14e353c3cdb349cd9ec8ecf3c991f52fbf8c"
+    },
+    "speech_slot.nysv": {
+      "bytes": 15284,
+      "sha256": "2988cc801e2b95d6ebba35d335ec656486bc0fe0b5938d071a536c63879aca0c"
+    }
+  }
+}

lineages/corrected-20260930/recovery/data/slots/speech_align.nysv

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

lineages/corrected-20260930/recovery/gpu_eqprop/build_corrected_mix.py

@@ -0,0 +1,217 @@
+"""Rebuild all nine original SFT sources using frozen NYS IDs. No training/upload.
+
+Pinned schemas are normalized explicitly. Every source and every requested split
+must contribute; failed or empty sources fail the build, never shrink the diet.
+"""
+import argparse
+from array import array
+from collections import Counter
+import hashlib
+import json
+import mmap
+import os
+from pathlib import Path
+import random
+import re
+import struct
+import subprocess
+
+VOCAB_SHA = '23d96f815a5904045899fa304988fb011e21a6b25b612d729b8d833ae5e7388e'
+SPECS = [
+ ('tulu3',4,['train'],None), ('openhermes',3,['train'],None),
+ ('ultrachat',3,['train_sft'],None), ('xlam',4,['train'],'dataset'),
+ ('toolace',3,['train'],None), ('glaive',3,['train'],None),
+ ('hermes_fc',2,['train'],'func_calling_singleturn'),
+ ('orca',4,['analytical_reasoning','code_','rag','follow_up','fs_cot_flow','open_domain_qa'],None),
+ ('agent_flan',4,['agent_instruct_tflan','agent_instruct_react','toolbench_tflan_60p_r10r5u7','toolbench_instruct_j1s1_3k'],None),
+]
+
+def sha(path):
+    with Path(path).open('rb') as f:
+        return hashlib.file_digest(f, 'sha256').hexdigest()
+
+def text(v):
+    if v is None: return ''
+    return v if isinstance(v,str) else json.dumps(v,ensure_ascii=False,separators=(',',':'))
+
+def decode(v):
+    return json.loads(v) if isinstance(v,str) else v
+
+class NoTargets(ValueError):
+    pass
+
+def messages(row):
+    out=[]
+    conv=row.get('messages') or row.get('conversations') or row.get('conversation')
+    if conv:
+        conv=decode(conv)
+        for m in conv:
+            m=decode(m)
+            role=(m.get('role') or m.get('from') or '').lower()
+            role={'human':'user','gpt':'assistant','function':'tool','tool_response':'tool'}.get(role,role)
+            if role not in ('user','assistant','system','tool'):
+                raise ValueError(f'Unknown conversation role {role!r}')
+            content=text(m.get('content',m.get('value')))
+            if m.get('tool_calls'):
+                content += '\n'+text(m['tool_calls'])
+            if m.get('loss') is False:
+                role='tool' # context only; not an assistant target
+            if content.strip(): out.append(dict(role=role,content=content))
+        system=row.get('system') or row.get('system_prompt')
+        if system and not any(m['role']=='system' for m in out):
+            out.insert(0,dict(role='system',content=text(system)))
+    elif row.get('query') is not None and row.get('answers') is not None:
+        out=[dict(role='user',content=text(row['query'])+'\n tools '+text(row.get('tools'))),
+             dict(role='assistant',content=text(row['answers']))]
+    elif isinstance(row.get('chat'),str):
+        if row.get('system'): out.append(dict(role='system',content=text(row['system'])))
+        parts=re.split(r'(?:^|\n)(USER|ASSISTANT|FUNCTION RESPONSE):\s*', row['chat'])
+        if len(parts)<3 or parts[0].strip(): raise ValueError('Unsupported Glaive chat framing')
+        for role,body in zip(parts[1::2],parts[2::2]):
+            out.append(dict(role={'USER':'user','ASSISTANT':'assistant','FUNCTION RESPONSE':'tool'}[role],
+                            content=body.replace('<|endoftext|>','').strip()))
+    else:
+        raise ValueError(f'Unsupported source schema: {sorted(row)}')
+    if not any(m['role']=='assistant' and m['content'].strip() for m in out):
+        raise NoTargets('No assistant targets in conversation')
+    return out
+
+def offsets(path, expected):
+    off=array('Q')
+    with open(path,'rb') as f:
+        with mmap.mmap(f.fileno(),0,access=mmap.ACCESS_READ) as mm:
+            count,=struct.unpack_from('<I',mm,0)
+            if count!=expected: raise ValueError(f'Incomplete source {path}: {count} != {expected}')
+            pos=4
+            for _ in range(count):
+                off.append(pos)
+                n,=struct.unpack_from('<H',mm,pos)
+                if not 2<=n<=128: raise ValueError('Invalid sparse record length')
+                end=pos+2+4*n
+                if end>len(mm): raise ValueError('Truncated sparse record')
+                ids=struct.unpack_from('<'+'I'*n,mm,pos+2)
+                if max(ids)>=5_000_000: raise ValueError('Invalid sparse token ID')
+                pos=end
+            if pos!=len(mm): raise ValueError('Trailing corpus bytes')
+    return off
+
+def build(args):
+    if args.token_file:
+        os.environ['HF_TOKEN']=args.token_file.read_text().strip()
+    from datasets import load_dataset
+    from huggingface_hub import hf_hub_download
+    def open_stream(name, info, config, sp):
+        if name=='agent_flan':
+            # Its published Arrow feature declaration omits the optional `type`
+            # field in some splits. Read the pinned JSONL rows without that cast.
+            p=hf_hub_download(info['repo'],'data/'+sp+'.jsonl',repo_type='dataset',revision=info['revision'])
+            def rows():
+                with open(p,encoding='utf-8') as f:
+                    for line in f:
+                        if line.strip(): yield json.loads(line)
+            return iter(rows())
+        return iter(load_dataset(info['repo'],name=config,split=sp,revision=info['revision'],streaming=True))
+    out=args.output
+    out.mkdir(parents=True,exist_ok=True)
+    if sha(args.vocab)!=VOCAB_SHA: raise ValueError('Wrong frozen vocabulary')
+    discovered=json.loads(args.discovery.read_text())
+    converter_sha=sha(args.converter)
+    reports=[]
+    used=0
+    for idx,(spec,info) in enumerate(zip(SPECS,discovered)):
+        name,weight,splits,config=spec
+        quota=args.records-used if idx==len(SPECS)-1 else args.records*weight//30
+        path=out/(name+'.bin')
+        report_path=out/(name+'.json')
+        if report_path.exists():
+            report=json.loads(report_path.read_text())
+            if report.get('converter_sha256')!=converter_sha or report['sha256']!=sha(path) or report.get('target_records',report['records'])!=quota or report['revision']!=info['revision']:
+                raise ValueError('Prior build identity differs')
+            offsets(path,report['records'])
+            reports.append(report)
+            used+=report['records']
+            continue
+        streams={sp:open_stream(name,info,config,sp) for sp in splits}
+        empty=Counter()
+        def next_messages(sp,it):
+            while True:
+                row=next(it)
+                try: return messages(row)
+                except NoTargets: empty[sp]+=1
+        # Check each schema before starting the converter; preserve the first row.
+        first={sp:next_messages(sp,it) for sp,it in streams.items()}
+        counts=Counter()
+        source_hash=hashlib.sha256()
+        with (out/(name+'.convert.log')).open('w') as log:
+            proc=subprocess.Popen([str(args.converter),'--vocab',str(args.vocab),'--output',str(path),
+                                   '--limit',str(quota),'--max-per-convo','25','--flush-every','1000'],
+                                  stdin=subprocess.PIPE,stderr=log,text=True)
+            try:
+                while proc.poll() is None and streams:
+                    for sp,it in list(streams.items()):
+                        try:
+                            ms=first.pop(sp) if sp in first else next_messages(sp,it)
+                        except StopIteration:
+                            del streams[sp]
+                            continue
+                        line=json.dumps({'messages':ms},ensure_ascii=False)+'\n'
+                        proc.stdin.write(line)
+                        counts[sp]+=1
+                        source_hash.update(line.encode())
+            except BrokenPipeError:
+                pass
+            except BaseException:
+                proc.kill(); proc.wait(); raise
+            finally:
+                try: proc.stdin.close()
+                except BrokenPipeError: pass
+            if proc.wait()!=0: raise RuntimeError(f'Converter failed: {name}')
+        actual=struct.unpack('<I',path.read_bytes()[:4])[0]
+        if actual<=0 or actual>quota: raise ValueError('Empty source or quota overrun')
+        offsets(path,actual)
+        if not all(counts[sp]>0 for sp in splits): raise ValueError('Missing split')
+        report=dict(name=name,repo=info['repo'],revision=info['revision'],config=config,
+                    records=actual,target_records=quota,bytes=path.stat().st_size,sha256=sha(path),fed_conversations=dict(counts),
+                    normalized_input_sha256=source_hash.hexdigest(),max_per_conversation=25,
+                    skipped_no_assistant_targets=dict(empty),converter_sha256=converter_sha)
+        report_path.write_text(json.dumps(report,indent=2))
+        reports.append(report)
+        used+=actual
+        print(json.dumps(report),flush=True)
+    # Shuffle record order globally so the first live rotations include all sources.
+    handles=[open(out/(r['name']+'.bin'),'rb') for r in reports]
+    maps=[mmap.mmap(f.fileno(),0,access=mmap.ACCESS_READ) for f in handles]
+    record_offsets=[offsets(out/(r['name']+'.bin'),r['records']) for r in reports]
+    order=array('Q', ((i<<32)|j for i,r in enumerate(reports) for j in range(r['records'])))
+    random.Random(7).shuffle(order)
+    temp=out/'mix_sft_sparse.bin.writing'
+    first_counts=Counter()
+    with temp.open('wb') as f:
+        f.write(struct.pack('<I',len(order)))
+        for at,key in enumerate(order):
+            i,j=key>>32,key&0xffffffff
+            pos=record_offsets[i][j]
+            n,=struct.unpack_from('<H',maps[i],pos)
+            f.write(maps[i][pos:pos+2+4*n])
+            if at<32000: first_counts[reports[i]['name']]+=1
+        f.flush(); os.fsync(f.fileno())
+    offsets(temp,args.records)
+    final=out/'mix_sft_sparse.bin'
+    temp.replace(final)
+    for m,f in zip(maps,handles): m.close(); f.close()
+    manifest=dict(verified=True,records=args.records,bytes=final.stat().st_size,sha256=sha(final),
+                  converter_sha256=converter_sha,
+                  vocab_sha256=VOCAB_SHA,sources=reports,shuffle_seed=7,first_32000_source_counts=dict(first_counts),
+                  note='Rebuilt original nine-source recipe; not the unavailable historical byte-for-byte mix')
+    (out/'mix_manifest.json').write_text(json.dumps(manifest,indent=2))
+    print(json.dumps(manifest),flush=True)
+
+if __name__=='__main__':
+    ap=argparse.ArgumentParser(description=__doc__)
+    ap.add_argument('--discovery',type=Path,required=True)
+    ap.add_argument('--vocab',type=Path,required=True)
+    ap.add_argument('--converter',type=Path,required=True)
+    ap.add_argument('--output',type=Path,required=True)
+    ap.add_argument('--records',type=int,default=2_050_000)
+    ap.add_argument('--token-file',type=Path)
+    build(ap.parse_args())

lineages/corrected-20260930/recovery/gpu_eqprop/build_cuda.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+cd -- "$(dirname -- "${BASH_SOURCE[0]}")"
+NVCC="${NVCC:-/data/yue-cuda/cuda/toolkit/bin/nvcc}"
+if [[ ! -x "$NVCC" ]]; then NVCC="$(command -v nvcc)"; fi
+"$NVCC" -O3 -std=c++17 -gencode=arch=compute_89,code=sm_89 \
+  -o eqprop_gpu_cuda eqprop_gpu.cu