Refresh to v0.3.0 (39 codes); clean package + docs (drop stale cache dump and deposit tooling)

.gitattributes

@@ -1,35 +0,0 @@
-*.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

.pytest_cache/.gitignore

@@ -1,2 +0,0 @@
-# Created by pytest automatically.
-*

.pytest_cache/CACHEDIR.TAG

@@ -1,4 +0,0 @@
-Signature: 8a477f597d28d172789f06886806bc55
-# This file is a cache directory tag created by pytest.
-# For information about cache directory tags, see:
-#	https://bford.info/cachedir/spec.html

.pytest_cache/README.md

@@ -1,8 +0,0 @@
-# pytest cache directory #
-
-This directory contains data from the pytest's cache plugin,
-which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
-
-**Do not** commit this to version control.
-
-See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

.pytest_cache/v/cache/lastfailed

@@ -1,3 +0,0 @@
-{
-  "tests/test_contract.py::test_registry_has_thirty": true
-}

.pytest_cache/v/cache/nodeids

@@ -1,12 +0,0 @@
-[
-  "tests/test_contract.py::test_contract_returns_prediction",
-  "tests/test_contract.py::test_every_code_has_provenance_and_status",
-  "tests/test_contract.py::test_kecon_financial_firewall",
-  "tests/test_contract.py::test_kgate_clamps_and_fails_closed",
-  "tests/test_contract.py::test_kyro_reproduces_training_point",
-  "tests/test_contract.py::test_metrics_calibration",
-  "tests/test_contract.py::test_registry",
-  "tests/test_contract.py::test_registry_has_thirty",
-  "tests/test_contract.py::test_roadmap_codes_raise",
-  "tests/test_contract.py::test_tagged_provenance_requires_retired_by"
-]

.zenodo.json

@@ -1,9 +1,9 @@
 {
-  "title": "KODEX: the Kronos Family of Codes (AI/ML fusion surrogate suite) v0.1.0",
+  "title": "KODEX: the Kronos Family of Codes (AI/ML fusion surrogate suite) v0.3.0",
   "upload_type": "software",
   "language": "eng",
-  "version": "0.1.0",
-  "publication_date": "2026-09-10",
+  "version": "0.3.0",
+  "publication_date": "2026-09-29",
   "creators": [
     {
       "name": "Ford, P. I.",
@@ -193,5 +193,5 @@
     }
   ],
   "notes": "Draft-first deposit. Provenance chain: code -> benchmark -> on-disk data -> CGYRO/register/AI+Quantum DOI. See PROVENANCE.md and MANIFEST.sha256.",
-  "description": "<p><strong>KODEX &mdash; the Kronos Family of Codes.</strong> A benchmarked suite of AI/ML surrogate models that stand in for expensive fusion physics (CGYRO-class gyrokinetics, neutronics, equilibrium, control) with calibrated uncertainty and an abstention gate. One contract across the fleet: <code>predict(x) &rarr; (y, uncertainty, in_domain)</code>. Built on and tracing to the Kronos research corpus.</p><p>This release publishes the <strong>26 BUILT</strong> codes (package + real benchmark + docs). 4 further codes ship as honest ROADMAP: KEDGE, KHEAT, KRAD, KTENSOR.</p><p>Honest cards are kept intact: CGYRO-anchored surrogates use the mu=400 representative-mass turbulence map; the quantum members (KQUBIT/KQROSS/KSENSE) report validated null/negative results (no quantum advantage claimed); KWARD's disruption labels are heuristic (Ip current-quench, not physicist-verified) and its headline independent-precursor AUC (0.975) uses only n=1 Mirnov + P_rad; KECON is a generic-LCOE financial firewall carrying no Kronos economic numbers.</p><p>Documentation: <a href=\"https://kronosfusionenergy.com/kodex\">https://kronosfusionenergy.com/kodex</a> &middot; source: <a href=\"https://github.com/KronosFE/kronos-ml\">https://github.com/KronosFE/kronos-ml</a>.</p>"
+  "description": "<p><strong>KODEX &mdash; the Kronos Family of Codes.</strong> A benchmarked suite of AI/ML surrogate models that stand in for expensive fusion physics (CGYRO-class gyrokinetics, neutronics, equilibrium, control) with calibrated uncertainty and an abstention gate. One contract across the fleet: <code>predict(x) &rarr; (y, uncertainty, in_domain)</code>. Built on and tracing to the Kronos research corpus.</p><p>This release publishes the full <strong>39 BUILT</strong> codes (package + real benchmark + docs), including the v0.3.0 additions KMIND (whole-device foundation surrogate), KSCOUT (multi-fidelity campaign manager), and the quantum members KMIT (error mitigation) and KLINQ (linear solver).</p><p>Honest cards are kept intact: CGYRO-anchored surrogates use the mu=400 representative-mass turbulence map; the quantum members (KQUBIT/KQROSS/KSENSE) report validated null/negative results (no quantum advantage claimed); KWARD's disruption labels are heuristic (Ip current-quench, not physicist-verified) and its headline independent-precursor AUC (0.975) uses only n=1 Mirnov + P_rad; KECON is a generic-LCOE financial firewall carrying no Kronos economic numbers; the newer quantum members (KMIT, KLINQ) are real NISQ-era tools with no claimed advantage &mdash; quantum's meaningful role in fusion is post-~2036.</p><p>Documentation: <a href=\"https://kronosfusionenergy.com/kodex\">https://kronosfusionenergy.com/kodex</a> &middot; source: <a href=\"https://github.com/KronosFE/kronos-ml\">https://github.com/KronosFE/kronos-ml</a>.</p>"
 }

BENCHMARKS.md

@@ -6,16 +6,16 @@ are kept, not hidden. Nothing here is published until go-live.
 
 | # | Code | Status | Headline benchmark |
 |--|--|--|--|
-| 01 | **KAIROS** | BUILT | MPC tracking 0.0461 (<5%); Exp-B **0 escapes / 150,000**; 155.4 µs/step |
+| 01 | **KAIROS** | BUILT | MPC tracking 0.0461 (<5%); Exp-B **0 escapes / 150,000**; 77.8 µs/step |
 | 02 | **KFLOW** | BUILT | GNN RMSE@k8 0.0844 vs naive 0.1721 (beats naive; AC-18 0.05 bar **MISSED**, kept) |
 | 03 | **KGATE** | BUILT | model-free clamp: **0 escapes / 150,000 steps** |
 | 04 | **KHALO** | BUILT | sourced ECE 0.0327 +/- 0.0136 / cov90 0.888 +/- 0.034; live GP ECE 0.0771 |
 | 05 | **KMAT** | BUILT | DFT-validated CHGNet screen, 8 candidates |
 | 06 | **KOIL** | BUILT | live strain surrogate rel-L2 0.0038; sourced 0.24% @0.15 ms, quench AUC 0.9998 |
-| 07 | **KORE** | BUILT | learned NN equilibrium: rel-L2 0.0035 vs analytic, 2.337 ms/field; sourced FNO 2.5% vs 1% bar |
+| 07 | **KORE** | BUILT | learned NN equilibrium: rel-L2 0.0035 vs analytic, 0.318 ms/field; sourced FNO 2.5% vs 1% bar |
 | 08 | **KQUBIT** | BUILT | **REAL VQE** (PennyLane): recovers H2 ground state to 0.0002 mHa on default; runs on real QC hardware — no advantage yet |
 | 09 | **KWARD** | BUILT | real-device AUC 0.98 (591 MAST shots), ECE 0.0349; **independent-precursor AUC 0.975** (n=1 Mirnov + P_rad ONLY, label-independent); labels heuristic (Ip-quench) |
-| 10 | **KYRO** | BUILT | complete 16/16 map (12 turbulent / 4 quiet (16/16 complete)); turbulent/quiet **16/16 correct**, R²=0.858 / cov90=0.875; **0.329 ms vs 2.89 GPU-h/pt** (μ=400) |
+| 10 | **KYRO** | BUILT | complete 16/16 map (12 turbulent / 4 quiet (16/16 complete)); turbulent/quiet **16/16 correct**, R²=0.858 / cov90=0.875; **0.257 ms vs 2.89 GPU-h/pt** (μ=400) |
 | 11 | **KBREED** | BUILT | TBR surrogate R²=1.0 vs neutronics engine; nominal net TBR 0.742; OpenMC = auto fidelity upgrade |
 | 12 | **KBURN** | BUILT | dispatch surrogate R²=1.0 (fuel mix → captured power); +22% dynamic |
 | 13 | **KEYE** | BUILT | virtual-sensor fault detection 0.767 at FAR 0.0 |
@@ -23,23 +23,27 @@ are kept, not hidden. Nothing here is published until go-live.
 | 15 | **KFUSE** | BUILT | multi-fidelity: RMSE 1.481→1.05 (R²=0.787); 3rd fidelity = real-mass gold (deferred) |
 | 16 | **KHEAT** | BUILT | heating/current-drive surrogate: driven-current I_cd **R²=0.949** over 3888 configs (reduced CD; RF/NBI ray-tracing = upgrade) |
 | 17 | **KISO** | BUILT | servo R²=0.723 + **medical-isotope yield** from real FENDL-3.2 σ(E) (6 isotopes, Mo-99/Tc-99m flagship) |
-| 18 | **KPATH** | BUILT | MPC-imitation controller R²=0.879 over 6 axes |
-| 19 | **KQERN** | BUILT | **REAL quantum kernel**: MAST-disruption AUC 0.919 vs classical 0.929 (ties — honest null); runnable on real QC hardware |
-| 20 | **KQROSS** | BUILT | **REAL FT resource estimator**: classical↔quantum crossover ~N=50 needs ~6e+04 physical qubits, roadmap ~2032 — no FT advantage this decade |
-| 21 | **KSENSE** | BUILT | **REAL quantum metrology** (GHZ, PennyLane): ideal Heisenberg 4.0× vs dephased 2.05× ≈ SQL 2.01× — dephasing erases the advantage (honest null) |
-| 22 | **KTENSOR** | BUILT | SVD/MPS ROM of the real CGYRO flux DB: **effective rank ~2.93 of 4 — modestly compressible, NOT strongly low-rank** (honest characterization; classical, no quantum advantage) |
-| 23 | **KBENCH** | BUILT | open fusion-ML benchmark suite: **3 citable tasks** (CGYRO turbulence, MAST disruption, flux ROM) with real data + KODEX baselines |
-| 24 | **KDRIVE** | BUILT | RL policy (cross-entropy): tracking **0.0551** vs naive 0.1225, twin-in-the-loop |
-| 25 | **KDYN** | BUILT | **REAL Trotter quantum dynamics**: 1st-order error 1.34637→0.03381 over steps (~1/n); runs on real QC hardware — honest cost curve, no advantage yet |
-| 26 | **KECON** | BUILT | generic LCOE calculator + breakdown — **FINANCIAL FIREWALL (no Kronos numbers)** |
-| 27 | **KEDGE** | BUILT | divertor edge surrogate: heat-flux→target-temp **R²=1.0**, CuCrZr limit q~13.5 MW/m² (reduced 0-D; SOLPS/EIRENE = upgrade) |
-| 28 | **KFORGE** | BUILT | inverse-design chained KYRO+KORE → **found a quiet operating point** (a/L_T=2.228, shear=1.511, Q_tot≈0.0) |
-| 29 | **KFUEL** | BUILT | fuel-cycle balance: self-sufficient=True, doubling 5.17 yr (illustrative TBR) |
-| 30 | **KGEN** | BUILT | generative (PCA latent, dim 8); samples plausible equilibrium fields (diffusion = roadmap) |
-| 31 | **KLAW** | BUILT | equation discovery: 7 terms, R²=0.903 — **rediscovered the critical-gradient onset** from the CGYRO map |
-| 32 | **KPILOT** | BUILT | fleet router: plain-language query → the right code (LLM agent = roadmap upgrade) |
-| 33 | **KQOPT** | BUILT | **REAL QAOA optimizer**: 1.0 of optimum on a design QUBO (6 qubits); plug in your QUBO, run on real QC hardware — no speedup yet |
-| 34 | **KRAD** | BUILT | impurity-seeding radiation evaluator: 3 impurities (Ar, N, Ne); least core dilution = Ar |
-| 35 | **KSEEK** | BUILT | active-learning: proposes next CGYRO run (a/L_T=2.225, shear=0.58); LOO std-vs-error corr -0.283 (honest: weak on 16 pts) |
+| 18 | **KMIT** | BUILT | **REAL error mitigation**: ZNE cuts H2 energy error 44.38→5.029 mHa (0.887 removed); readout TV 0.1472→0.0 — real NISQ tool today, role post-~2036 |
+| 19 | **KPATH** | BUILT | MPC-imitation controller R²=0.879 over 6 axes |
+| 20 | **KQERN** | BUILT | **REAL quantum kernel**: MAST-disruption AUC 0.919 vs classical 0.929 (ties — honest null); runnable on real QC hardware |
+| 21 | **KQROSS** | BUILT | **REAL FT resource estimator**: classical↔quantum crossover ~N=50 needs ~6e+04 physical qubits, roadmap ~2032 — no FT advantage this decade |
+| 22 | **KSENSE** | BUILT | **REAL quantum metrology** (GHZ, PennyLane): ideal Heisenberg 4.0× vs dephased 2.05× ≈ SQL 2.01× — dephasing erases the advantage (honest null) |
+| 23 | **KTENSOR** | BUILT | SVD/MPS ROM of the real CGYRO flux DB: **effective rank ~2.93 of 4 — modestly compressible, NOT strongly low-rank** (honest characterization; classical, no quantum advantage) |
+| 24 | **KBENCH** | BUILT | open fusion-ML benchmark suite: **3 citable tasks** (CGYRO turbulence, MAST disruption, flux ROM) with real data + KODEX baselines |
+| 25 | **KDRIVE** | BUILT | RL policy (cross-entropy): tracking **0.0551** vs naive 0.1225, twin-in-the-loop |
+| 26 | **KDYN** | BUILT | **REAL Trotter quantum dynamics**: 1st-order error 1.34637→0.03381 over steps (~1/n); runs on real QC hardware — honest cost curve, no advantage yet |
+| 27 | **KECON** | BUILT | generic LCOE calculator + breakdown — **FINANCIAL FIREWALL (no Kronos numbers)** |
+| 28 | **KEDGE** | BUILT | divertor edge surrogate: heat-flux→target-temp **R²=1.0**, CuCrZr limit q~13.5 MW/m² (reduced 0-D; SOLPS/EIRENE = upgrade) |
+| 29 | **KFORGE** | BUILT | inverse-design chained KYRO+KORE → **found a quiet operating point** (a/L_T=2.228, shear=1.511, Q_tot≈0.0) |
+| 30 | **KFUEL** | BUILT | fuel-cycle balance: self-sufficient=True, doubling 5.17 yr (illustrative TBR) |
+| 31 | **KGEN** | BUILT | generative (PCA latent, dim 8); samples plausible equilibrium fields (diffusion = roadmap) |
+| 32 | **KLAW** | BUILT | equation discovery: 7 terms, R²=0.903 — **rediscovered the critical-gradient onset** from the CGYRO map |
+| 33 | **KLINQ** | BUILT | **REAL quantum linear solver** (VQLS): 4×4 reduced-MHD solve fidelity 1.0 vs classical (rel-resid 0.0); FT-HHL ~4e+04 phys qubits — no advantage, role post-~2036 |
+| 34 | **KMIND** | BUILT | **foundation model**: one shared trunk across 4 domains (66958 params); transfer vs matched single-task — pos ['equil'], neg none, neutral ['state', 'disrupt'] (transport data-starved) — honest multi-task result |
+| 35 | **KPILOT** | BUILT | fleet router: plain-language query → the right code (LLM agent = roadmap upgrade) |
+| 36 | **KQOPT** | BUILT | **REAL QAOA optimizer**: 1.0 of optimum on a design QUBO (6 qubits); plug in your QUBO, run on real QC hardware — no speedup yet |
+| 37 | **KRAD** | BUILT | impurity-seeding radiation evaluator: 3 impurities (Ar, N, Ne); least core dilution = Ar |
+| 38 | **KSCOUT** | BUILT | **multi-fidelity campaign**: tight 15.0 GPU-h over 16 hotspots → mean confidence ρ 0.638 vs 0.281 all-μ=400 (2.27×); triage-then-escalate |
+| 39 | **KSEEK** | BUILT | active-learning: proposes next CGYRO run (a/L_T=2.225, shear=0.58); LOO std-vs-error corr -0.283 (honest: weak on 16 pts) |
 
 _Regenerate: `PYTHONPATH=<kronos-ml>:<kronos-toolkit> python benchmarks/run_all.py`._

CITATION.cff

@@ -1,8 +1,8 @@
 cff-version: 1.2.0
 message: "If you use KODEX, please cite it as below."
 title: "KODEX: the Kronos Family of Codes (AI/ML fusion surrogate suite)"
-version: "0.1.0"
-date-released: "2026-09-10"
+version: "0.3.0"
+date-released: "2026-09-29"
 license: Apache-2.0
 repository-code: "https://github.com/KronosFE/kronos-ml"
 url: "https://kronosfusionenergy.com/kodex"

CODES.md

@@ -94,6 +94,10 @@ tensor-network / low-rank (MPS-style SVD) ROM of the real CGYRO A1e flux databas
 **REAL quantum kernel** (PennyLane) — embeds real MAST disruption features into a quantum feature map and classifies on the fidelity kernel; runs on a simulator now, real QC hardware pluggable. MAST-disruption AUC **0.919** vs classical RBF 0.929 (ties — a validated null); a real, runnable quantum-ML pipeline on real fusion data.
 *provenance SIM · retired_by **fault-tolerant quantum hardware (not available this decade)** · gates KX-L3.*
 
+### KMIT — QMITIGATION  `[BUILT]`  ✦v0.3
+**REAL quantum error mitigation** — zero-noise extrapolation (ZNE, global unitary folding) + inverse-confusion readout-error mitigation applied to the real KQUBIT H₂ VQE circuit (PennyLane default.mixed; sim now, real hardware pluggable). ZNE removes ~89% of the noise-induced energy error (44.4 → 5.0 mHa); readout mitigation cuts the measurement TV distance to ~0. Mitigation is the genuine NISQ tool TODAY — it recovers signal from noise, not a speedup. Honest: quantum's meaningful role in fusion is post-~2036.
+*provenance SIM · retired_by **fault-tolerant quantum hardware (not available this decade)** · gates KX-L3.*
+
 ## Phase 3 — cutting-edge + capstones
 
 ### KDRIVE — RL-control  `[BUILT]`
@@ -148,3 +152,15 @@ active-learning acquisition — proposes the next most-informative CGYRO run fro
 open, citable fusion-ML benchmark suite — 3 tasks (CGYRO turbulence, MAST disruption, flux ROM) with real on-disk data, fixed reproducible splits, metrics, and KODEX baselines to beat. A community leaderboard starting point, not a private result; honest that it's small by mainstream-ML standards (pilot fusion-ML benchmarks).
 *provenance n/a · retired_by **community-standard fusion-ML benchmarks**.*
 
+### KMIND — FOUNDATION  `[BUILT]`  ✦v0.3
+**whole-device foundation surrogate** — ONE shared-trunk multi-task neural net (per-domain input adapters → a shared plasma-state trunk → per-domain heads, ~67k params) trained JOINTLY across transport (KYRO), equilibrium (KORE), state (KFLOW) and disruption (KWARD) on the data those specialists use. Benchmarked head-by-head against a MATCHED single-task baseline on the same split: on the well-populated domains the shared representation shows **no negative transfer** (equilibrium slight positive, state/disruption neutral); transport is **data-starved (16 pts) and reported, not hidden**. MC-dropout uncertainty; per-domain trust gate (physical box for transport/equil, Mahalanobis for state/disrupt). The honest question a foundation model must answer — does one shared representation help or hurt each task? — answered with matched baselines.
+*provenance SIM · retired_by **a device-scale multi-task foundation model on real multi-diagnostic data** · gates BR-L2-A1e, AC-16, AC-18, AC-20.*
+
+### KLINQ — QLINSOLVE  `[BUILT]`  ✦v0.3
+**REAL quantum linear solver** — a variational quantum linear solver (VQLS) prepares the solution of a 4×4 reduced-MHD (discrete-Laplacian, SPD) linear system with a real quantum circuit (PennyLane; sim now, hardware pluggable), recovering the classical solution at fidelity ~1.0. Bundled with an honest fault-tolerant HHL resource estimate: a fusion-scale (N~1e6) sparse solve needs ~4e4 physical qubits — no advantage at real scale. Honest: quantum's meaningful role in fusion is post-~2036.
+*provenance SIM · retired_by **fault-tolerant quantum hardware (not available this decade)** · gates KX-L3.*
+
+### KSCOUT — MF-CAMPAIGN  `[BUILT]`  ✦v0.3
+**multi-fidelity Bayesian-optimization campaign manager** — extends KSEEK from a single next-point to a budget-constrained campaign that chooses which operating point AND which fidelity (reduced twin / μ=400 CGYRO / real-mass gold) to run next. Triage-then-escalate: cheap twin on every uncertain hotspot, escalate the most-uncertain to μ=400, reserve real-mass gold. Under a tight GPU-hour budget it reaches ~2.3× the mean truth-confidence of a naive all-μ=400 plan (which exhausts the budget and leaves most hotspots unexamined). Honest: fidelity correlations are assumptions (gold not yet run); GPU-hours only, no cost figures.
+*provenance SIM · retired_by **the full multi-fidelity CGYRO campaign (twin + μ=400 + real-mass gold)** · gates BR-L2-A1e.*
+

benchmarks/benchmarks.json

@@ -27,7 +27,7 @@
         "escapes": 0,
         "catch_rate": 1.0
       },
-      "live_mpc_step_us": 155.4,
+      "live_mpc_step_us": 77.8,
       "sourced": {
         "file": "track5_control/clamp_activation_stats.csv",
         "headline": "0 escapes / 150k steps / 3000 injected (AC-25); tracking <5%"
@@ -178,7 +178,7 @@
       "gates": [
         "KX-L3"
       ],
-      "note": "REAL quantum dynamics \u2014 Trotterized time-evolution of a transverse-field Ising 'kinetic' Hamiltonian (PennyLane); the honest 1/n_steps cost curve for simulating plasma-like dynamics on a quantum computer. Runs on a simulator now, hardware pluggable",
+      "note": "REAL quantum dynamics \u2014 Trotterized time-evolution of a transverse-field Ising 'kinetic' Hamiltonian (PennyLane); the honest 1/n_steps cost curve for simulating plasma-like dynamics on a quantum computer. Runs on a simulator now, hardware pluggable; quantum's role in fusion is post-~2036",
       "available": true
     },
     "benchmark": {
@@ -200,7 +200,7 @@
           "active_backend": "default",
           "ran_on_real_hardware": false,
           "how_to_use_real_qc": "set KODEX_QC_BACKEND=ibm and KODEX_QC_TOKEN=<your IBM Quantum token> to run this exact circuit on real quantum hardware",
-          "honest_timeline": "fault-tolerant quantum ADVANTAGE for fusion kernels is ~8-10 yr out; this tooling makes the TESTING real and runnable TODAY, same code path"
+          "honest_timeline": "fault-tolerant quantum ADVANTAGE for fusion kernels is ~8-10 yr out \u2014 a meaningful role in fusion only after ~2036; this tooling makes the TESTING real and runnable TODAY, same code path"
         },
         "verdict": "REAL Trotterized quantum dynamics: 1st-order error falls 1.34637 -> 0.03381 from 1 to 32 steps (~1/n) \u2014 the honest cost curve for simulating plasma-like Hamiltonian dynamics on a quantum computer. Runs on real hardware with KODEX_QC_BACKEND=ibm. No advantage at this size; a real, testable pipeline."
       },
@@ -613,6 +613,70 @@
       "note": "compact closure discovered from the 16/16 CGYRO map"
     }
   },
+  "KLINQ": {
+    "card": {
+      "name": "KLINQ",
+      "function": "QLINSOLVE",
+      "status": "BUILT",
+      "phase": 3,
+      "provenance": "SIM",
+      "retired_by": "fault-tolerant quantum hardware (not available this decade)",
+      "gates": [
+        "KX-L3"
+      ],
+      "note": "REAL quantum linear solver \u2014 a variational quantum linear solver (VQLS) prepares the solution of a small reduced-MHD linear system with a real quantum circuit (sim now, hardware pluggable), plus an honest fault-tolerant HHL resource estimate. No advantage at real scale; quantum's role in fusion is post-~2036",
+      "available": true
+    },
+    "benchmark": {
+      "member": "KLINQ",
+      "live_quantum_linear_solver": {
+        "problem": "solve A x = b for a 4x4 reduced-MHD Laplacian (SPD) with a real quantum circuit",
+        "method": "variational quantum linear solver (VQLS), global overlap cost, Powell optimization",
+        "framework": "PennyLane (sim now; Hadamard-test cost on real hardware, pluggable)",
+        "N": 4,
+        "n_qubits": 2,
+        "cost_final": 0.0,
+        "solution_fidelity_vs_classical": 1.0,
+        "residual_rel": 0.0,
+        "x_quantum": [
+          0.8,
+          0.6,
+          0.4,
+          0.2
+        ],
+        "x_classical": [
+          0.8,
+          0.6,
+          0.4,
+          0.2
+        ],
+        "ft_hhl_resource_estimate": {
+          "assumed_system": "N~1e+06 sparse SPD (reduced-MHD grid), kappa~1e+03",
+          "logical_qubits_needed": 31,
+          "physical_qubits_needed": "~4e+04",
+          "surface_code_phys_per_logical": 1250,
+          "roadmap_year_reach_logical": 2031,
+          "hardware_today": "~1e2-1e3 physical qubits, no error-corrected logical qubits",
+          "caveats": [
+            "HHL needs fault tolerance + sparse, well-conditioned A + efficient state prep, and returns |x> (aggregate readout), not the full vector",
+            "no fusion HHL advantage this decade \u2014 meaningful role post-~2036"
+          ]
+        },
+        "backend": {
+          "active_backend": "default",
+          "ran_on_real_hardware": false,
+          "how_to_use_real_qc": "set KODEX_QC_BACKEND=ibm and KODEX_QC_TOKEN=<your IBM Quantum token> to run this exact circuit on real quantum hardware",
+          "honest_timeline": "fault-tolerant quantum ADVANTAGE for fusion kernels is ~8-10 yr out \u2014 a meaningful role in fusion only after ~2036; this tooling makes the TESTING real and runnable TODAY, same code path"
+        },
+        "verdict": "REAL variational quantum linear solver recovers the 4x4 reduced-MHD solve at solution fidelity 1.0 vs classical (rel-residual 0.0) \u2014 a runnable quantum linear solver TODAY. The fault-tolerant HHL route for a fusion-scale (N~1e6) solve needs ~31 logical -> ~4e+04 physical qubits (roadmap ~2031). HONEST: no advantage at real scale; quantum's meaningful role in fusion is post-~2036. Runs on hardware with KODEX_QC_BACKEND=ibm."
+      },
+      "caveats": [
+        "no quantum advantage \u2014 quantum's role in fusion is post-~2036",
+        "VQLS residual is read from the simulator here; on hardware it needs Hadamard tests and its cost landscape can have barren plateaus at scale",
+        "the 4x4 system is a toy; classical solves it instantly \u2014 the point is a real, honest, hardware-ready quantum pipeline, not a speedup"
+      ]
+    }
+  },
   "KMAT": {
     "card": {
       "name": "KMAT",
@@ -649,6 +713,161 @@
       "note": "alloy screen BUILT; dpa/lifetime roadmap inside KMAT"
     }
   },
+  "KMIND": {
+    "card": {
+      "name": "KMIND",
+      "function": "FOUNDATION",
+      "status": "BUILT",
+      "phase": 3,
+      "provenance": "SIM",
+      "retired_by": "a device-scale multi-task foundation model on real multi-diagnostic data",
+      "gates": [
+        "BR-L2-A1e",
+        "AC-16",
+        "AC-18",
+        "AC-20"
+      ],
+      "note": "whole-device foundation surrogate \u2014 one shared-trunk multi-task net across transport / equilibrium / state / disruption, trained jointly; reports shared-representation transfer honestly (incl. negative transfer)",
+      "available": true
+    },
+    "benchmark": {
+      "member": "KMIND",
+      "live_foundation": {
+        "architecture": "per-domain adapter (->32) + shared trunk (2x128, dropout 0.1) + per-domain head; 4 domains, joint training 300 steps",
+        "domains": [
+          "transport",
+          "equil",
+          "state",
+          "disrupt"
+        ],
+        "params": 66958,
+        "transfer_vs_single_task": {
+          "transport": {
+            "metric": "r2_log_Qtot",
+            "multitask": 0.577,
+            "single_task_baseline": 0.571,
+            "delta": 0.006,
+            "transfer": "data_starved",
+            "n_train": 12,
+            "n_test": 4
+          },
+          "equil": {
+            "metric": "rel_l2_field",
+            "multitask": 0.009,
+            "single_task_baseline": 0.0117,
+            "delta": -0.0027,
+            "transfer": "positive",
+            "n_train": 600,
+            "n_test": 200
+          },
+          "state": {
+            "metric": "norm_rmse",
+            "multitask": 0.0239,
+            "single_task_baseline": 0.0224,
+            "delta": 0.0015,
+            "transfer": "neutral",
+            "n_train": 1500,
+            "n_test": 500
+          },
+          "disrupt": {
+            "metric": "roc_auc",
+            "multitask": 0.99,
+            "single_task_baseline": 0.993,
+            "delta": -0.003,
+            "transfer": "neutral",
+            "n_train": 443,
+            "n_test": 148
+          }
+        },
+        "positive_transfer_domains": [
+          "equil"
+        ],
+        "negative_transfer_domains": [],
+        "neutral_transfer_domains": [
+          "state",
+          "disrupt"
+        ],
+        "data_starved_domains": [
+          "transport"
+        ],
+        "mc_dropout_predict_ms": 4.05,
+        "backend": "CPU, torch, MC-dropout UQ",
+        "verdict": "One shared trunk across 4 fusion domains, benchmarked head-by-head against a MATCHED single-task baseline on the same split. On the well-populated domains the shared representation is positive ['equil'], negative none, neutral ['state', 'disrupt'] \u2014 no negative transfer. ['transport'] is data-starved (16 pts) and not judged held-out. Trained on real on-disk data (CGYRO map / analytic equilibria / twin sensor snapshots / MAST shots) \u2014 an honest multi-task result, not a blanket win."
+      },
+      "caveats": [
+        "transport has only ~16 points, so its head is data-starved and high-variance (a real limit, reported not hidden)",
+        "uncertainty is an MC-dropout epistemic proxy, not a calibrated conformal interval",
+        "equilibrium targets are the analytic Solov'ev family (as in KORE); state targets are the analytic-twin sensor snapshots (as in KFLOW)"
+      ]
+    }
+  },
+  "KMIT": {
+    "card": {
+      "name": "KMIT",
+      "function": "QMITIGATION",
+      "status": "BUILT",
+      "phase": 2,
+      "provenance": "SIM",
+      "retired_by": "fault-tolerant quantum hardware (not available this decade)",
+      "gates": [
+        "KX-L3"
+      ],
+      "note": "REAL quantum error mitigation \u2014 zero-noise extrapolation (ZNE, unitary folding) + readout-error mitigation on a real fusion quantum circuit (the KQUBIT H2 VQE state). Mitigation is the genuine NISQ tool TODAY; it recovers signal from noise, not a speedup. Quantum's role in fusion is post-~2036",
+      "available": true
+    },
+    "benchmark": {
+      "member": "KMIT",
+      "live_error_mitigation": {
+        "problem": "mitigate a noisy H2 VQE expectation (the real KQUBIT circuit)",
+        "framework": "PennyLane default.mixed; ZNE via global unitary folding + linear extrapolation",
+        "zne": {
+          "exact_energy_Ha": -1.857275,
+          "ideal_noiseless_Ha": -1.857275,
+          "noisy_Ha": -1.812895,
+          "zne_mitigated_Ha": -1.852246,
+          "noise_scales_lambda": [
+            1.0,
+            3.0,
+            5.0
+          ],
+          "energies_vs_lambda": [
+            -1.812895,
+            -1.725694,
+            -1.648692
+          ],
+          "error_noisy_mHa": 44.38,
+          "error_zne_mHa": 5.029,
+          "error_reduction_frac": 0.887,
+          "depolarizing_p": 0.04,
+          "backend": {
+            "active_backend": "default",
+            "ran_on_real_hardware": false,
+            "how_to_use_real_qc": "set KODEX_QC_BACKEND=ibm and KODEX_QC_TOKEN=<your IBM Quantum token> to run this exact circuit on real quantum hardware",
+            "honest_timeline": "fault-tolerant quantum ADVANTAGE for fusion kernels is ~8-10 yr out \u2014 a meaningful role in fusion only after ~2036; this tooling makes the TESTING real and runnable TODAY, same code path"
+          }
+        },
+        "readout_mitigation": {
+          "readout_bitflip_p": 0.08,
+          "tv_distance_noisy": 0.1472,
+          "tv_distance_mitigated": 0.0,
+          "tv_reduction_frac": 1.0,
+          "method": "inverse confusion-matrix (linear) readout correction"
+        },
+        "backend": {
+          "active_backend": "default",
+          "ran_on_real_hardware": false,
+          "how_to_use_real_qc": "set KODEX_QC_BACKEND=ibm and KODEX_QC_TOKEN=<your IBM Quantum token> to run this exact circuit on real quantum hardware",
+          "honest_timeline": "fault-tolerant quantum ADVANTAGE for fusion kernels is ~8-10 yr out \u2014 a meaningful role in fusion only after ~2036; this tooling makes the TESTING real and runnable TODAY, same code path"
+        },
+        "verdict": "REAL error mitigation on a fusion quantum circuit: ZNE cuts the noisy-energy error 44.38 -> 5.029 mHa (89% of the error removed) and inverse-confusion readout correction cuts the measurement TV distance 0.1472 -> 0.0 (100%). Mitigation is the REAL NISQ tool today \u2014 it recovers signal from noise. HONEST: it is NOT a speedup; quantum's meaningful role in fusion is post-~2036, and mitigation cost grows with noise. Runs on real hardware with KODEX_QC_BACKEND=ibm."
+      },
+      "caveats": [
+        "no quantum advantage \u2014 quantum's role in fusion is post-~2036",
+        "ZNE assumes a smooth noise->observable relation; it extrapolates, it does not eliminate noise, and its overhead grows as noise grows",
+        "readout mitigation uses a known confusion matrix; on hardware you must calibrate it"
+      ]
+    }
+  },
   "KOIL": {
     "card": {
       "name": "KOIL",
@@ -701,7 +920,7 @@
       "live_learned_surrogate": {
         "rel_l2_vs_analytic": 0.0035,
         "ensemble_cov90": 0.778,
-        "infer_ms": 2.337,
+        "infer_ms": 0.318,
         "grid": "16x16",
         "n_heldout": 120
       },
@@ -768,7 +987,7 @@
       "gates": [
         "KX-L3"
       ],
-      "note": "REAL quantum-kernel classifier \u2014 embeds real MAST disruption features into a quantum feature map and classifies on the fidelity kernel (PennyLane); runs on a simulator now, real hardware pluggable. Honest: ties the classical kernel \u2014 a validated no-advantage result, but a real, runnable quantum-ML pipeline",
+      "note": "REAL quantum-kernel classifier \u2014 embeds real MAST disruption features into a quantum feature map and classifies on the fidelity kernel (PennyLane); runs on a simulator now, real hardware pluggable. Honest: ties the classical kernel \u2014 a validated no-advantage result, but a real, runnable quantum-ML pipeline; role in fusion post-~2036",
       "available": true
     },
     "benchmark": {
@@ -792,7 +1011,7 @@
           "active_backend": "default",
           "ran_on_real_hardware": false,
           "how_to_use_real_qc": "set KODEX_QC_BACKEND=ibm and KODEX_QC_TOKEN=<your IBM Quantum token> to run this exact circuit on real quantum hardware",
-          "honest_timeline": "fault-tolerant quantum ADVANTAGE for fusion kernels is ~8-10 yr out; this tooling makes the TESTING real and runnable TODAY, same code path"
+          "honest_timeline": "fault-tolerant quantum ADVANTAGE for fusion kernels is ~8-10 yr out \u2014 a meaningful role in fusion only after ~2036; this tooling makes the TESTING real and runnable TODAY, same code path"
         },
         "verdict": "REAL quantum kernel classifies MAST disruptions at AUC 0.919 vs classical RBF 0.929 (Delta -0.010) \u2014 no advantage: a validated null, but a REAL runnable quantum-ML pipeline on real fusion data. Runs on hardware with KODEX_QC_BACKEND=ibm.",
         "caveats": [
@@ -817,7 +1036,7 @@
       "gates": [
         "KX-L3"
       ],
-      "note": "REAL QAOA quantum optimizer \u2014 solves a combinatorial design QUBO on an actual quantum circuit (PennyLane); runs on a simulator now, real hardware pluggable, and you can plug in your own QUBO. Honest: standard ~0.7-1.0 approx ratio, no speedup at this size (~8-10 yr to advantage)",
+      "note": "REAL QAOA quantum optimizer \u2014 solves a combinatorial design QUBO on an actual quantum circuit (PennyLane); runs on a simulator now, real hardware pluggable, and you can plug in your own QUBO. Honest: standard ~0.7-1.0 approx ratio, no speedup at this size (advantage post-~2036)",
       "available": true
     },
     "benchmark": {
@@ -842,7 +1061,7 @@
           "active_backend": "default",
           "ran_on_real_hardware": false,
           "how_to_use_real_qc": "set KODEX_QC_BACKEND=ibm and KODEX_QC_TOKEN=<your IBM Quantum token> to run this exact circuit on real quantum hardware",
-          "honest_timeline": "fault-tolerant quantum ADVANTAGE for fusion kernels is ~8-10 yr out; this tooling makes the TESTING real and runnable TODAY, same code path"
+          "honest_timeline": "fault-tolerant quantum ADVANTAGE for fusion kernels is ~8-10 yr out \u2014 a meaningful role in fusion only after ~2036; this tooling makes the TESTING real and runnable TODAY, same code path"
         },
         "verdict": "REAL QAOA reaches 100% of the brute-force optimum (cut 6/6, p=2, 6 qubits) on the default backend \u2014 a working quantum optimizer, runnable on hardware with KODEX_QC_BACKEND=ibm. HONEST: no speedup vs classical at this size; advantage is ~8-10 yr out."
       },
@@ -864,7 +1083,7 @@
         "AC-43",
         "BR-SX-08"
       ],
-      "note": "REAL fault-tolerant resource estimator \u2014 computes the classical<->quantum crossover N, the surface-code physical-qubit overhead, and the logical-qubit roadmap year for a fusion electronic-structure kernel (order-of-magnitude, literature-scaled). Verdict: no FT advantage this decade \u2014 the machine does not exist yet",
+      "note": "REAL fault-tolerant resource estimator \u2014 computes the classical<->quantum crossover N, the surface-code physical-qubit overhead, and the logical-qubit roadmap year for a fusion electronic-structure kernel (order-of-magnitude, literature-scaled). Verdict: no FT advantage this decade \u2014 the machine does not exist yet; meaningful role post-~2036",
       "available": true
     },
     "benchmark": {
@@ -899,7 +1118,7 @@
         "AC-44",
         "KX-L3-A4"
       ],
-      "note": "REAL variational quantum eigensolver (VQE) for a molecular Hamiltonian \u2014 a runnable quantum program (PennyLane): executes on a simulator now and on real quantum hardware when you plug in a backend. Honest: no quantum advantage yet (~8-10 yr out); the tooling + testing are real TODAY",
+      "note": "REAL variational quantum eigensolver (VQE) for a molecular Hamiltonian \u2014 a runnable quantum program (PennyLane): executes on a simulator now and on real quantum hardware when you plug in a backend. Honest: no quantum advantage yet (~8-10 yr out); the tooling + testing are real TODAY \u2014 quantum's role in fusion is post-~2036",
       "available": true
     },
     "benchmark": {
@@ -926,7 +1145,7 @@
           "active_backend": "default",
           "ran_on_real_hardware": false,
           "how_to_use_real_qc": "set KODEX_QC_BACKEND=ibm and KODEX_QC_TOKEN=<your IBM Quantum token> to run this exact circuit on real quantum hardware",
-          "honest_timeline": "fault-tolerant quantum ADVANTAGE for fusion kernels is ~8-10 yr out; this tooling makes the TESTING real and runnable TODAY, same code path"
+          "honest_timeline": "fault-tolerant quantum ADVANTAGE for fusion kernels is ~8-10 yr out \u2014 a meaningful role in fusion only after ~2036; this tooling makes the TESTING real and runnable TODAY, same code path"
         },
         "verdict": "REAL VQE recovers the H2 ground state to 0.0002 mHa on the default backend (within 1.6 mHa chemical accuracy). Runs on real quantum hardware when you set KODEX_QC_BACKEND=ibm. HONEST: no quantum advantage this decade \u2014 the value now is a real, testable quantum pipeline, not a speedup."
       },
@@ -968,6 +1187,198 @@
       "caveat": "small seeding scan (few impurities); reduced 0-D radiation model"
     }
   },
+  "KSCOUT": {
+    "card": {
+      "name": "KSCOUT",
+      "function": "MF-CAMPAIGN",
+      "status": "BUILT",
+      "phase": 3,
+      "provenance": "SIM",
+      "retired_by": "the full multi-fidelity CGYRO campaign (twin + mu=400 + real-mass gold)",
+      "gates": [
+        "BR-L2-A1e"
+      ],
+      "note": "multi-fidelity Bayesian-optimization campaign manager \u2014 extends KSEEK: chooses which operating point AND which fidelity (reduced twin / mu=400 CGYRO / real-mass gold) to run next, greedily maximizing truth-weighted information per GPU-hour under a budget",
+      "available": true
+    },
+    "benchmark": {
+      "member": "KSCOUT",
+      "live_mf_campaign": {
+        "source": "KYRO GP over the completed 16-pt CGYRO A1e map",
+        "budget_gpu_h": 15.0,
+        "target_hotspots": 16,
+        "policy": "twin-triage every hotspot, escalate most-uncertain to mu=400, reserve gold",
+        "fidelities": {
+          "twin": {
+            "gpu_h": 0.0,
+            "rho": 0.55,
+            "desc": "reduced analytic twin (near-free triage)"
+          },
+          "cgyro_mu400": {
+            "gpu_h": 2.89,
+            "rho": 0.9,
+            "desc": "CGYRO representative mu=400 (measured GPU-h)"
+          },
+          "gold_mu3672": {
+            "gpu_h": 28.9,
+            "rho": 1.0,
+            "desc": "CGYRO real-mass gold (est. ~10x mu=400; not yet run)"
+          }
+        },
+        "multi_fidelity_plan": [
+          {
+            "a_LT": 3.25,
+            "shear": 1.4,
+            "fidelity": "cgyro_mu400",
+            "gpu_h": 2.99,
+            "gp_std": 0.5041,
+            "truth_confidence_rho": 0.9
+          },
+          {
+            "a_LT": 2.25,
+            "shear": 1.4,
+            "fidelity": "cgyro_mu400",
+            "gpu_h": 2.99,
+            "gp_std": 0.5041,
+            "truth_confidence_rho": 0.9
+          },
+          {
+            "a_LT": 3.25,
+            "shear": 0.6,
+            "fidelity": "cgyro_mu400",
+            "gpu_h": 2.99,
+            "gp_std": 0.5041,
+            "truth_confidence_rho": 0.9
+          },
+          {
+            "a_LT": 2.25,
+            "shear": 0.6,
+            "fidelity": "cgyro_mu400",
+            "gpu_h": 2.99,
+            "gp_std": 0.5041,
+            "truth_confidence_rho": 0.9
+          },
+          {
+            "a_LT": 3.25,
+            "shear": 1.0,
+            "fidelity": "twin",
+            "gpu_h": 0.1,
+            "gp_std": 0.4831,
+            "truth_confidence_rho": 0.55
+          },
+          {
+            "a_LT": 2.25,
+            "shear": 1.0,
+            "fidelity": "twin",
+            "gpu_h": 0.1,
+            "gp_std": 0.4831,
+            "truth_confidence_rho": 0.55
+          },
+          {
+            "a_LT": 2.75,
+            "shear": 0.6,
+            "fidelity": "twin",
+            "gpu_h": 0.1,
+            "gp_std": 0.4831,
+            "truth_confidence_rho": 0.55
+          },
+          {
+            "a_LT": 2.75,
+            "shear": 1.4,
+            "fidelity": "twin",
+            "gpu_h": 0.1,
+            "gp_std": 0.4831,
+            "truth_confidence_rho": 0.55
+          },
+          {
+            "a_LT": 2.75,
+            "shear": 1.0,
+            "fidelity": "twin",
+            "gpu_h": 0.1,
+            "gp_std": 0.4623,
+            "truth_confidence_rho": 0.55
+          },
+          {
+            "a_LT": 2.25,
+            "shear": 0.4,
+            "fidelity": "twin",
+            "gpu_h": 0.1,
+            "gp_std": 0.3838,
+            "truth_confidence_rho": 0.55
+          },
+          {
+            "a_LT": 2.25,
+            "shear": 1.6,
+            "fidelity": "twin",
+            "gpu_h": 0.1,
+            "gp_std": 0.3838,
+            "truth_confidence_rho": 0.55
+          },
+          {
+            "a_LT": 3.25,
+            "shear": 1.6,
+            "fidelity": "twin",
+            "gpu_h": 0.1,
+            "gp_std": 0.3838,
+            "truth_confidence_rho": 0.55
+          },
+          {
+            "a_LT": 3.25,
+            "shear": 0.4,
+            "fidelity": "twin",
+            "gpu_h": 0.1,
+            "gp_std": 0.3838,
+            "truth_confidence_rho": 0.55
+          },
+          {
+            "a_LT": 2.0,
+            "shear": 1.4,
+            "fidelity": "twin",
+            "gpu_h": 0.1,
+            "gp_std": 0.3838,
+            "truth_confidence_rho": 0.55
+          },
+          {
+            "a_LT": 3.5,
+            "shear": 1.4,
+            "fidelity": "twin",
+            "gpu_h": 0.1,
+            "gp_std": 0.3838,
+            "truth_confidence_rho": 0.55
+          },
+          {
+            "a_LT": 2.0,
+            "shear": 0.6,
+            "fidelity": "twin",
+            "gpu_h": 0.1,
+            "gp_std": 0.3838,
+            "truth_confidence_rho": 0.55
+          }
+        ],
+        "mf_runs": 16,
+        "mf_gpu_h_used": 13.56,
+        "mf_runs_by_fidelity": {
+          "twin": 12,
+          "cgyro_mu400": 4,
+          "gold_mu3672": 0
+        },
+        "mf_mean_confidence_rho": 0.638,
+        "baseline_all_mu400": {
+          "n_runs": 5,
+          "gpu_h_used": 14.95,
+          "mean_confidence_rho": 0.281,
+          "unvisited_hotspots": 11
+        },
+        "mf_confidence_gain_x_vs_all_mu400": 2.27,
+        "verdict": "Under a tight 15.0 GPU-h budget across 16 uncertain operating points, the multi-fidelity policy triages ALL 16 with cheap twin runs and escalates 4 to mu=400 (0 to real-mass gold), reaching mean truth-confidence rho 0.638 \u2014 vs 0.281 for a naive all-mu=400 plan that exhausts the budget after 5 points and leaves 11 hotspots unexamined (2.27x). A real cost-aware campaign manager: look everywhere cheaply, spend the expensive fidelity where KYRO is least sure."
+      },
+      "caveats": [
+        "the per-fidelity rho (correlation-with-truth) values are ASSUMPTIONS \u2014 the real-mass gold has not been run \u2014 so this is a planning heuristic, not a measured speedup; the advantage holds only while budget < hotspots x mu=400 cost",
+        "GP std comes from only 16 points (directional, like KSEEK)",
+        "GPU-hours only; no compute-cost figures (product-econ rule)"
+      ]
+    }
+  },
   "KSEEK": {
     "card": {
       "name": "KSEEK",
@@ -1022,7 +1433,7 @@
       "gates": [
         "HX-29"
       ],
-      "note": "REAL quantum-metrology evaluation (PennyLane mixed-state) \u2014 GHZ interferometry: ideal gives Heisenberg (gain ~ N) scaling, but realistic dephasing (NV/SQUID/SERF reality) collapses it back to the standard quantum limit (~sqrt(N)). Honest null where fusion disruptions live",
+      "note": "REAL quantum-metrology evaluation (PennyLane mixed-state) \u2014 GHZ interferometry: ideal gives Heisenberg (gain ~ N) scaling, but realistic dephasing (NV/SQUID/SERF reality) collapses it back to the standard quantum limit (~sqrt(N)). Honest null where fusion disruptions live; quantum's role in fusion is post-~2036",
       "available": true
     },
     "benchmark": {
@@ -1091,7 +1502,7 @@
           "active_backend": "default",
           "ran_on_real_hardware": false,
           "how_to_use_real_qc": "set KODEX_QC_BACKEND=ibm and KODEX_QC_TOKEN=<your IBM Quantum token> to run this exact circuit on real quantum hardware",
-          "honest_timeline": "fault-tolerant quantum ADVANTAGE for fusion kernels is ~8-10 yr out; this tooling makes the TESTING real and runnable TODAY, same code path"
+          "honest_timeline": "fault-tolerant quantum ADVANTAGE for fusion kernels is ~8-10 yr out \u2014 a meaningful role in fusion only after ~2036; this tooling makes the TESTING real and runnable TODAY, same code path"
         },
         "verdict": "REAL quantum-metrology computation: over N=2->8 the ideal GHZ gain grows 4.0x (Heisenberg ~ N), but with per-qubit dephasing (p=0.2) the dephased GHZ grows only 2.05x \u2014 essentially the SQL rate (2.01x, ~sqrt(N)). Dephasing ERASES the Heisenberg *scaling* to a bounded constant (gain turns over near N~9). HONEST NULL: no quantum-sensing advantage for fusion disruptions this decade \u2014 but a real, runnable metrology tool."
       },
@@ -1112,7 +1523,7 @@
       "gates": [
         "KX-L3"
       ],
-      "note": "tensor-network / low-rank ROM compression of the real CGYRO A1e flux database (classical MPS-style SVD; a many-body method and bridge to quantum kernels \u2014 NO quantum-advantage claim)",
+      "note": "tensor-network / low-rank ROM compression of the real CGYRO A1e flux database (classical MPS-style SVD; a many-body method and bridge to quantum kernels \u2014 NO quantum-advantage claim; quantum's role in fusion is post-~2036)",
       "available": true
     },
     "benchmark": {
@@ -1263,9 +1674,9 @@
         "map": "12 turbulent / 4 quiet (16/16 complete)"
       },
       "speed": {
-        "surrogate_ms_per_point": 0.329,
+        "surrogate_ms_per_point": 0.257,
         "cgyro_gpu_h_per_point_measured": 2.89,
-        "speedup_x_vs_cgyro": "3.2e+07",
+        "speedup_x_vs_cgyro": "4.1e+07",
         "speedup_note": "ms inference vs GPU-hours for the CONVERGED flux value",
         "fidelity": "representative mu=400; real-mass gold deferred"
       },

benchmarks/run_all.py

@@ -181,6 +181,31 @@ def _headline(name, b):
         r = b.get("live_impurity_seeding", {})
         return (f"impurity-seeding radiation evaluator: {r.get('n_impurities')} impurities "
                 f"({', '.join(r.get('impurities', []))}); least core dilution = {r.get('least_core_dilution_impurity')}")
+    if name == "KMIND":
+        lf = b.get("live_foundation", {})
+        pos = lf.get("positive_transfer_domains", []); neg = lf.get("negative_transfer_domains", [])
+        neu = lf.get("neutral_transfer_domains", []); st = lf.get("data_starved_domains", [])
+        return (f"**foundation model**: one shared trunk across {len(lf.get('domains', []))} domains "
+                f"({lf.get('params', '?')} params); transfer vs matched single-task — pos {pos or 'none'}, "
+                f"neg {neg or 'none'}, neutral {neu or 'none'}"
+                + (" (transport data-starved)" if st else "") + " — honest multi-task result")
+    if name == "KMIT":
+        m = b.get("live_error_mitigation", {}); z = m.get("zne", {}); ro = m.get("readout_mitigation", {})
+        return (f"**REAL error mitigation**: ZNE cuts H2 energy error {z.get('error_noisy_mHa')}→"
+                f"{z.get('error_zne_mHa')} mHa ({z.get('error_reduction_frac')} removed); readout TV "
+                f"{ro.get('tv_distance_noisy')}→{ro.get('tv_distance_mitigated')} — real NISQ tool today, "
+                f"role post-~2036")
+    if name == "KLINQ":
+        q = b.get("live_quantum_linear_solver", {}); hhl = q.get("ft_hhl_resource_estimate", {})
+        return (f"**REAL quantum linear solver** (VQLS): 4×4 reduced-MHD solve fidelity "
+                f"{q.get('solution_fidelity_vs_classical')} vs classical (rel-resid {q.get('residual_rel')}); "
+                f"FT-HHL {hhl.get('physical_qubits_needed')} phys qubits — no advantage, role post-~2036")
+    if name == "KSCOUT":
+        c = b.get("live_mf_campaign", {}); base = c.get("baseline_all_mu400", {})
+        return (f"**multi-fidelity campaign**: tight {c.get('budget_gpu_h')} GPU-h over "
+                f"{c.get('target_hotspots')} hotspots → mean confidence ρ {c.get('mf_mean_confidence_rho')} "
+                f"vs {base.get('mean_confidence_rho')} all-μ=400 "
+                f"({c.get('mf_confidence_gain_x_vs_all_mu400')}×); triage-then-escalate")
     return b.get("note", b.get("headline", "roadmap"))
 
 

codemeta.json

@@ -2,8 +2,8 @@
   "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
   "@type": "SoftwareSourceCode",
   "name": "KODEX: the Kronos Family of Codes",
-  "version": "0.1.0",
-  "dateModified": "2026-09-10",
+  "version": "0.3.0",
+  "dateModified": "2026-09-29",
   "license": "https://spdx.org/licenses/Apache-2.0",
   "codeRepository": "https://github.com/KronosFE/kronos-ml",
   "url": "https://kronosfusionenergy.com/kodex",

kronos_ml/members/__init__.py

@@ -16,3 +16,5 @@ from . import advanced     # noqa: F401  KLAW, KDRIVE, KGEN, KFUEL
 from . import capstone     # noqa: F401  KFORGE, KPILOT
 from . import neutronics   # noqa: F401  KBREED, KFLUX
 from . import roadmap      # noqa: F401  KHEAT, KEDGE, KRAD, KECON
+from . import foundation   # noqa: F401  KMIND (v0.3.0)
+from . import quantum_v3    # noqa: F401  KMIT, KLINQ (v0.3.0)

kronos_ml/members/advanced.py

@@ -358,3 +358,136 @@ class KBENCH(Surrogate):
                                 "ROM) with real on-disk data + reproducible KODEX baselines — a community "
                                 "leaderboard starting point, not a private result")},
                 "caveat": "small by mainstream-ML standards (CGYRO = 16 pts); honest pilot fusion-ML benchmarks"}
+
+
+# ------------------------------------------------------------------ KSCOUT
+@register
+class KSCOUT(Surrogate):
+    name = "KSCOUT"; function = "MF-CAMPAIGN"; phase = 3; status = "BUILT"
+    provenance = "SIM"
+    retired_by = "the full multi-fidelity CGYRO campaign (twin + mu=400 + real-mass gold)"
+    real_codes = ("multi-fidelity Bayesian optimization", "cost-aware acquisition")
+    gates = ("BR-L2-A1e",)
+    note = ("multi-fidelity Bayesian-optimization campaign manager — extends KSEEK: chooses which "
+            "operating point AND which fidelity (reduced twin / mu=400 CGYRO / real-mass gold) to "
+            "run next, greedily maximizing truth-weighted information per GPU-hour under a budget")
+
+    _BOX = ((2.0, 3.5), (0.4, 1.6))          # a_LT, shear (matches KYRO / KSEEK)
+    _C0 = 0.10                                # fixed per-run setup overhead (GPU-h equiv.)
+    _HOTSPOTS = 16                            # target uncertain locations for a campaign
+    # honest fidelity model: measured mu=400 cost; twin ~free; gold ~10x mu=400 (estimate, not yet run).
+    # rho = ASSUMED correlation-with-truth per fidelity (gold=1 by definition); labelled as assumptions.
+    _FIDELITIES = {
+        "twin":         {"gpu_h": 0.0,  "rho": 0.55, "desc": "reduced analytic twin (near-free triage)"},
+        "cgyro_mu400":  {"gpu_h": 2.89, "rho": 0.90, "desc": "CGYRO representative mu=400 (measured GPU-h)"},
+        "gold_mu3672":  {"gpu_h": 28.9, "rho": 1.00, "desc": "CGYRO real-mass gold (est. ~10x mu=400; not yet run)"},
+    }
+
+    def _grid(self, n=31):
+        a = np.linspace(*self._BOX[0], n); s = np.linspace(*self._BOX[1], n)
+        A, S = np.meshgrid(a, s)
+        return np.c_[A.ravel(), S.ravel()]
+
+    def _hotspots(self, n_hotspots, min_sep=0.16):
+        """The n most-uncertain operating points (KYRO GP std), min-separated + away from data."""
+        gp = get("KYRO")._fit()
+        G = self._grid()
+        _, std = gp.predict(G); std = np.asarray(std).ravel()
+        Xtr = data.cgyro_flux_map_final()[["a_LT", "shear"]].to_numpy(float)
+        span = np.array([self._BOX[0][1] - self._BOX[0][0], self._BOX[1][1] - self._BOX[1][0]])
+        picks = []
+        for idx in np.argsort(-std):
+            g = G[idx]
+            d_tr = np.linalg.norm((g - Xtr) / span, axis=1).min()
+            d_ch = min([np.linalg.norm((g - c[0]) / span) for c in picks], default=9.0)
+            if min(d_tr, d_ch) < min_sep:
+                continue
+            picks.append((g, float(std[idx])))
+            if len(picks) >= n_hotspots:
+                break
+        return picks
+
+    def _cost(self, fid):
+        return self._FIDELITIES[fid]["gpu_h"] + self._C0
+
+    def _plan(self, budget, n_hotspots=None):
+        """Triage-and-escalate: twin-triage every hotspot, then escalate the most-uncertain to
+        mu=400, then the single most-critical to real-mass gold — all within the GPU-h budget."""
+        n_hotspots = n_hotspots or self._HOTSPOTS
+        hs = self._hotspots(n_hotspots)              # sorted by std desc
+        c_t, c_m, c_g = (self._cost("twin"), self._cost("cgyro_mu400"), self._cost("gold_mu3672"))
+        tiers = [None] * len(hs); used = 0.0
+        # tier 1 — cheap twin triage on as many hotspots as the budget allows (highest std first)
+        for i in range(len(hs)):
+            if used + c_t <= budget + 1e-9:
+                tiers[i] = "twin"; used += c_t
+        # tier 2 — escalate the single most-uncertain to real-mass gold if affordable
+        if tiers and tiers[0] == "twin" and used + c_g <= budget + 1e-9:
+            tiers[0] = "gold_mu3672"; used += c_g
+        # tier 3 — escalate the next most-uncertain to mu=400 while budget remains
+        for i in range(len(hs)):
+            if tiers[i] == "twin" and used + c_m <= budget + 1e-9:
+                tiers[i] = "cgyro_mu400"; used += c_m
+        plan = []
+        for (g, s), tier in zip(hs, tiers):
+            if tier is None:
+                continue
+            plan.append({"a_LT": round(float(g[0]), 3), "shear": round(float(g[1]), 3),
+                         "fidelity": tier, "gpu_h": round(self._cost(tier), 2),
+                         "gp_std": round(float(s), 4),
+                         "truth_confidence_rho": self._FIDELITIES[tier]["rho"]})
+        return plan, round(used, 2), hs
+
+    def _mean_confidence(self, plan, n_hotspots):
+        """Mean truth-confidence (rho) achieved across ALL target hotspots (unvisited = 0)."""
+        return round(sum(p["truth_confidence_rho"] for p in plan) / n_hotspots, 3)
+
+    def _baseline_all_mu400(self, budget, n_hotspots):
+        """Naive baseline: spend the whole budget at mu=400 on the highest-std hotspots."""
+        c_m = self._cost("cgyro_mu400")
+        n = min(n_hotspots, int((budget + 1e-9) // c_m))
+        return {"n_runs": n, "gpu_h_used": round(n * c_m, 2),
+                "mean_confidence_rho": round(n * self._FIDELITIES["cgyro_mu400"]["rho"] / n_hotspots, 3),
+                "unvisited_hotspots": n_hotspots - n}
+
+    def _predict(self, x):
+        """x = GPU-hour budget (float) -> the recommended multi-fidelity campaign plan."""
+        budget = float(np.ravel(np.asarray(x, float))[0]) if x is not None else 15.0
+        plan, used, _ = self._plan(budget)
+        by_fid = {f: sum(1 for p in plan if p["fidelity"] == f) for f in self._FIDELITIES}
+        return Prediction(plan, None, True,
+                          note=f"multi-fidelity campaign: {len(plan)} runs {by_fid}, {used} GPU-h of {budget}")
+
+    def benchmark(self):
+        budget = 15.0                                # tight budget: mu=400 can't cover every hotspot
+        n = self._HOTSPOTS
+        plan, used, hs = self._plan(budget, n)
+        by_fid = {f: sum(1 for p in plan if p["fidelity"] == f) for f in self._FIDELITIES}
+        mf_conf = self._mean_confidence(plan, n)
+        base = self._baseline_all_mu400(budget, n)
+        ratio = round(mf_conf / base["mean_confidence_rho"], 2) if base["mean_confidence_rho"] > 1e-9 else None
+        return {"member": self.name,
+                "live_mf_campaign": {
+                    "source": "KYRO GP over the completed 16-pt CGYRO A1e map",
+                    "budget_gpu_h": budget, "target_hotspots": n,
+                    "policy": "twin-triage every hotspot, escalate most-uncertain to mu=400, reserve gold",
+                    "fidelities": {k: {kk: v[kk] for kk in ("gpu_h", "rho", "desc")}
+                                   for k, v in self._FIDELITIES.items()},
+                    "multi_fidelity_plan": plan,
+                    "mf_runs": len(plan), "mf_gpu_h_used": used, "mf_runs_by_fidelity": by_fid,
+                    "mf_mean_confidence_rho": mf_conf,
+                    "baseline_all_mu400": base,
+                    "mf_confidence_gain_x_vs_all_mu400": ratio,
+                    "verdict": (f"Under a tight {budget} GPU-h budget across {n} uncertain operating points, the "
+                                f"multi-fidelity policy triages ALL {n} with cheap twin runs and escalates "
+                                f"{by_fid['cgyro_mu400']} to mu=400 ({by_fid['gold_mu3672']} to real-mass gold), "
+                                f"reaching mean truth-confidence rho {mf_conf} — vs {base['mean_confidence_rho']} "
+                                f"for a naive all-mu=400 plan that exhausts the budget after {base['n_runs']} "
+                                f"points and leaves {base['unvisited_hotspots']} hotspots unexamined ({ratio}x). "
+                                f"A real cost-aware campaign manager: look everywhere cheaply, spend the "
+                                f"expensive fidelity where KYRO is least sure.")},
+                "caveats": ["the per-fidelity rho (correlation-with-truth) values are ASSUMPTIONS — the "
+                            "real-mass gold has not been run — so this is a planning heuristic, not a "
+                            "measured speedup; the advantage holds only while budget < hotspots x mu=400 cost",
+                            "GP std comes from only 16 points (directional, like KSEEK)",
+                            "GPU-hours only; no compute-cost figures (product-econ rule)"]}

kronos_ml/members/foundation.py

@@ -0,0 +1,333 @@
+"""KMIND — whole-device foundation surrogate (shared-trunk multi-task model).
+
+ONE shared plasma-state trunk feeds four domain heads — transport (KYRO),
+equilibrium (KORE), state (KFLOW) and disruption (KWARD) — trained JOINTLY on the
+on-disk data those specialists use.  Per-domain input adapters project each
+domain's heterogeneous inputs into a common embedding; the shared trunk learns a
+representation every head reads; per-domain heads emit the domain output.
+
+The honest question a foundation model has to answer: does forcing four fusion
+sub-problems through ONE shared representation help or hurt each of them vs a
+matched single-task specialist?  `benchmark()` trains the multi-task model AND a
+matched single-task baseline per domain on the SAME split and reports the
+transfer — positive OR negative — in each domain's own metric.  No hype: a shared
+representation that hurts a task is reported as hurting it.
+
+CPU-only, deterministic (fixed seed), torch (lazy import).  Uncertainty is an
+MC-dropout epistemic proxy; the per-domain in_domain gate is a Mahalanobis
+distance to that domain's training inputs.
+"""
+from __future__ import annotations
+
+import time
+import numpy as np
+
+from .. import register, get
+from ..base import Surrogate, Prediction
+from .. import uq, metrics, data
+from .._torch import torch
+from .equil import _field, _A, _K, _D
+
+_D_EMB = 32          # shared embedding width (adapter output)
+_H = 128             # shared trunk width
+_DROP = 0.1          # dropout (also the MC-dropout head)
+_STEPS = 300         # joint / baseline training steps (same for fairness)
+_BATCH = 64
+_MC = 30             # MC-dropout passes for predictive std
+_DOMAINS = ("transport", "equil", "state", "disrupt")
+
+
+# ---- per-domain data builders (all read-only, on-disk) -------------------
+
+def _transport_xy():
+    df = data.cgyro_flux_map_final()
+    X = df[["a_LT", "shear"]].to_numpy(float)
+    y = np.log10(np.clip(df.Q_tot.to_numpy(float), 0, None) + 1e-4).reshape(-1, 1)
+    return X, y
+
+
+def _equil_xy(n=800, seed=uq.SEED):
+    rng = np.random.default_rng(seed)
+    P = np.c_[rng.uniform(*_A, n), rng.uniform(*_K, n), rng.uniform(*_D, n)]
+    Y = np.array([_field(*p) for p in P], float)
+    return P.astype(float), Y
+
+
+def _state_xy(n=2000, seed=uq.SEED):
+    z = data.gnn_snapshots()
+    Xobs = np.nan_to_num(np.asarray(z["Xn_obs"], float))
+    Yclean = np.nan_to_num(np.asarray(z["Xn_clean"], float))
+    if len(Xobs) > n:                       # deterministic subsample for speed
+        idx = np.random.default_rng(seed).choice(len(Xobs), n, replace=False)
+        Xobs, Yclean = Xobs[idx], Yclean[idx]
+    return Xobs, Yclean
+
+
+def _disrupt_xy():
+    X, y, _ = get("KWARD")._real_features()
+    return np.asarray(X, float), np.asarray(y, int).reshape(-1, 1)
+
+
+_BUILDERS = {"transport": _transport_xy, "equil": _equil_xy,
+             "state": _state_xy, "disrupt": _disrupt_xy}
+_KIND = {"transport": "reg", "equil": "reg", "state": "reg", "disrupt": "cls"}
+# physical in-domain boxes for the low-D parametric domains (match KYRO / KORE);
+# the high-D domains (state, disrupt) use a Mahalanobis gate on training inputs
+_BOX = {"transport": ((2.0, 3.5), (0.4, 1.6)),
+        "equil": ((0.8, 1.2), (1.5, 2.5), (-0.5, 0.5))}
+
+
+def _spec(name, test_frac=0.25, seed=uq.SEED):
+    """Build a domain spec: standardized train/test tensors + inversion stats + gate."""
+    X, Y = _BUILDERS[name]()
+    n = len(X)
+    rng = np.random.default_rng(seed + hash(name) % 1000)
+    perm = rng.permutation(n)
+    nte = max(2, int(round(test_frac * n)))
+    te, tr = perm[:nte], perm[nte:]
+    Xtr, Xte, Ytr, Yte = X[tr], X[te], Y[tr], Y[te]
+    xmu, xsd = Xtr.mean(0), Xtr.std(0) + 1e-8
+    kind = _KIND[name]
+    if kind == "reg":
+        ymu, ysd = Ytr.mean(0), Ytr.std(0) + 1e-8
+    else:
+        ymu, ysd = np.zeros(Y.shape[1]), np.ones(Y.shape[1])   # raw {0,1} labels
+    gate = None if name in _BOX else uq.MahalanobisGate(0.05).fit(Xtr)
+    return {"name": name, "kind": kind, "in_dim": X.shape[1], "out_dim": Y.shape[1],
+            "Xtr": Xtr, "Xte": Xte, "Ytr": Ytr, "Yte": Yte,
+            "xmu": xmu, "xsd": xsd, "ymu": ymu, "ysd": ysd, "gate": gate, "n": n}
+
+
+def _in_domain(sp, x_raw):
+    """Per-domain trust gate, queried on RAW inputs: a physical box for the low-D
+    parametric domains (transport/equil), Mahalanobis distance for the rest."""
+    x = np.asarray(x_raw, float).ravel()
+    if sp["name"] in _BOX:
+        b = _BOX[sp["name"]]
+        return bool(len(x) >= len(b) and all(lo <= x[i] <= hi for i, (lo, hi) in enumerate(b)))
+    return bool(sp["gate"].in_domain(x.reshape(1, -1)))
+
+
+def _stdx(sp, X):
+    return ((np.atleast_2d(np.asarray(X, float)) - sp["xmu"]) / sp["xsd"]).astype("float32")
+
+
+def _stdy(sp, Y):
+    return ((np.asarray(Y, float) - sp["ymu"]) / sp["ysd"]).astype("float32")
+
+
+def _invy(sp, Yn):
+    return np.asarray(Yn, float) * sp["ysd"] + sp["ymu"]
+
+
+# ---- the shared-trunk multi-task network ---------------------------------
+
+def _build_net(specs, seed=uq.SEED):
+    t = torch(); t.set_num_threads(1); t.manual_seed(seed)   # single-thread -> reproducible
+    nn = t.nn
+
+    class MultiTask(nn.Module):
+        def __init__(self):
+            super().__init__()
+            self.adapters = nn.ModuleDict({
+                s["name"]: nn.Sequential(nn.Linear(s["in_dim"], _D_EMB), nn.SiLU())
+                for s in specs})
+            self.trunk = nn.Sequential(
+                nn.Linear(_D_EMB, _H), nn.SiLU(), nn.Dropout(_DROP),
+                nn.Linear(_H, _H), nn.SiLU(), nn.Dropout(_DROP))
+            self.heads = nn.ModuleDict({
+                s["name"]: nn.Linear(_H, s["out_dim"]) for s in specs})
+
+        def forward(self, name, x):
+            return self.heads[name](self.trunk(self.adapters[name](x)))
+
+    return MultiTask()
+
+
+def _train(net, specs, steps=_STEPS, seed=uq.SEED):
+    t = torch(); nn = t.nn
+    opt = t.optim.Adam(net.parameters(), lr=3e-3)
+    mse = nn.MSELoss(); bce = nn.BCEWithLogitsLoss()
+    rng = np.random.default_rng(seed)
+    # pre-tensor the standardized train sets
+    packs = []
+    for sp in specs:
+        Xn = t.tensor(_stdx(sp, sp["Xtr"]))
+        Yn = t.tensor(_stdy(sp, sp["Ytr"]))
+        packs.append((sp, Xn, Yn))
+    net.train()
+    for _ in range(steps):
+        opt.zero_grad(); loss = 0.0
+        for sp, Xn, Yn in packs:
+            m = len(Xn); b = min(_BATCH, m)
+            idx = t.tensor(rng.choice(m, b, replace=False))
+            out = net(sp["name"], Xn[idx])
+            loss = loss + (bce(out, Yn[idx]) if sp["kind"] == "cls"
+                           else mse(out, Yn[idx]))
+        loss.backward(); opt.step()
+    net.eval()
+    return net
+
+
+def _mc_forward(net, name, Xn, kind, passes=_MC):
+    """MC-dropout: keep dropout ON, run several passes -> (mean, std)."""
+    t = torch()
+    net.train()                              # dropout active
+    outs = []
+    with t.no_grad():
+        for _ in range(passes):
+            o = net(name, t.tensor(np.asarray(Xn, "float32"))).numpy()
+            outs.append(_sigmoid(o) if kind == "cls" else o)
+    net.eval()
+    outs = np.array(outs)
+    return outs.mean(0), outs.std(0)
+
+
+def _sigmoid(z):
+    return 1.0 / (1.0 + np.exp(-np.clip(z, -30, 30)))
+
+
+def _domain_metric(sp, pred_std_mean):
+    """Score the (standardized) prediction against the held-out truth in the
+    domain's OWN metric.  pred_std_mean is the standardized-space mean output."""
+    kind = sp["kind"]; Yte = sp["Yte"]
+    if kind == "cls":
+        from sklearn.metrics import roc_auc_score
+        p = _sigmoid(pred_std_mean).ravel()
+        auc = float(roc_auc_score(Yte.ravel(), p)) if len(np.unique(Yte)) > 1 else float("nan")
+        return {"metric": "roc_auc", "value": round(auc, 3), "higher_better": True}
+    pred = _invy(sp, pred_std_mean)
+    if sp["name"] == "transport":
+        return {"metric": "r2_log_Qtot", "value": round(metrics.r2(Yte.ravel(), pred.ravel()), 3),
+                "higher_better": True}
+    if sp["name"] == "equil":
+        rl2 = float(np.mean([metrics.rel_l2(Yte[i], pred[i]) for i in range(len(Yte))]))
+        return {"metric": "rel_l2_field", "value": round(rl2, 4), "higher_better": False}
+    # state: range-normalized RMSE (KFLOW convention)
+    rng = sp["Ytr"].max(0) - sp["Ytr"].min(0) + 1e-9
+    nrmse = float(np.sqrt(np.mean(((pred - Yte) / rng) ** 2)))
+    return {"metric": "norm_rmse", "value": round(nrmse, 4), "higher_better": False}
+
+
+@register
+class KMIND(Surrogate):
+    name = "KMIND"; function = "FOUNDATION"; phase = 3; status = "BUILT"
+    provenance = "SIM"
+    retired_by = "a device-scale multi-task foundation model on real multi-diagnostic data"
+    real_codes = ("multi-task representation learning", "KYRO", "KORE", "KFLOW", "KWARD")
+    gates = ("BR-L2-A1e", "AC-16", "AC-18", "AC-20")
+    note = ("whole-device foundation surrogate — one shared-trunk multi-task net across "
+            "transport / equilibrium / state / disruption, trained jointly; reports "
+            "shared-representation transfer honestly (incl. negative transfer)")
+
+    def __init__(self):
+        self._net = None; self._specs = None
+
+    def _fit(self):
+        if self._net is None:
+            self._specs = [_spec(n) for n in _DOMAINS]
+            self._net = _train(_build_net(self._specs), self._specs)
+        return self._net, self._specs
+
+    def _sp(self, name):
+        _, specs = self._fit()
+        for sp in specs:
+            if sp["name"] == name:
+                return sp
+        raise KeyError(name)
+
+    def _predict(self, x):
+        """x = (domain, input) or {"domain": name, "x": input}, domain in
+        {transport, equil, state, disrupt}.  -> Prediction(y, MC-dropout std, in_domain)."""
+        if isinstance(x, dict):
+            name, xi = x.get("domain"), x.get("x")
+        elif isinstance(x, (tuple, list)) and len(x) == 2 and x[0] in _DOMAINS:
+            name, xi = x
+        else:
+            raise ValueError("KMIND expects (domain, input) or {'domain','x'}; "
+                             f"domain in {list(_DOMAINS)}")
+        net, _ = self._fit(); sp = self._sp(name)
+        Xn = _stdx(sp, xi)
+        mean, std = _mc_forward(net, name, Xn, sp["kind"])
+        if sp["kind"] == "cls":
+            y = float(mean.ravel()[0]); unc = float(std.ravel()[0])
+            note = f"{name} head: disruption probability {y:.3f} (MC-dropout std {unc:.3f})"
+        else:
+            inv_mean = _invy(sp, mean)[0]; inv_std = (std * sp["ysd"])[0]
+            y = float(inv_mean) if sp["out_dim"] == 1 else inv_mean
+            unc = float(np.mean(inv_std)) if sp["out_dim"] > 1 else float(inv_std)
+            tgt = "log10 Q_tot" if name == "transport" else ("psi field" if name == "equil"
+                  else "clean sensor state")
+            note = f"{name} head via shared trunk -> {tgt} (MC-dropout epistemic std)"
+        return Prediction(y, unc, _in_domain(sp, xi), note=note)
+
+    def benchmark(self):
+        net, specs = self._fit()
+        # multi-task test predictions per domain (deterministic mean, dropout off)
+        t = torch()
+        multi = {}
+        with t.no_grad():
+            for sp in specs:
+                out = net(sp["name"], t.tensor(_stdx(sp, sp["Xte"]))).numpy()
+                multi[sp["name"]] = _domain_metric(sp, out)
+        # matched single-task baselines: same architecture (adapter+trunk+head),
+        # SAME split + steps, trained on that ONE domain only
+        _MIN_TEST = 10                          # below this, held-out metric is too noisy to judge
+        transfer = {}
+        for sp in specs:
+            base_net = _train(_build_net([sp]), [sp])
+            with t.no_grad():
+                bo = base_net(sp["name"], t.tensor(_stdx(sp, sp["Xte"]))).numpy()
+            base_m = _domain_metric(sp, bo)
+            mm = multi[sp["name"]]
+            n_test = int(len(sp["Xte"]))
+            delta = round(mm["value"] - base_m["value"], 4)
+            if n_test < _MIN_TEST:
+                direction = "data_starved"      # e.g. transport: 16 pts total, held-out R2 unreliable
+            else:
+                better = ((mm["value"] > base_m["value"]) if mm["higher_better"]
+                          else (mm["value"] < base_m["value"]))
+                eps = 0.01 if mm["higher_better"] else 0.002
+                direction = ("positive" if (better and abs(delta) > eps)
+                             else "negative" if (not better and abs(delta) > eps) else "neutral")
+            transfer[sp["name"]] = {
+                "metric": mm["metric"], "multitask": mm["value"],
+                "single_task_baseline": base_m["value"], "delta": delta,
+                "transfer": direction, "n_train": int(sp["n"] - n_test), "n_test": n_test}
+        pos = [d for d, v in transfer.items() if v["transfer"] == "positive"]
+        neg = [d for d, v in transfer.items() if v["transfer"] == "negative"]
+        neu = [d for d, v in transfer.items() if v["transfer"] == "neutral"]
+        starved = [d for d, v in transfer.items() if v["transfer"] == "data_starved"]
+        t0 = time.perf_counter()
+        for _ in range(50):
+            self._predict(("transport", [3.0, 1.0]))
+        ms = (time.perf_counter() - t0) / 50 * 1e3
+        return {"member": self.name,
+                "live_foundation": {
+                    "architecture": (f"per-domain adapter (->{_D_EMB}) + shared trunk "
+                                     f"(2x{_H}, dropout {_DROP}) + per-domain head; {len(specs)} domains, "
+                                     f"joint training {_STEPS} steps"),
+                    "domains": list(_DOMAINS),
+                    "params": int(sum(p.numel() for p in net.parameters())),
+                    "transfer_vs_single_task": transfer,
+                    "positive_transfer_domains": pos,
+                    "negative_transfer_domains": neg,
+                    "neutral_transfer_domains": neu,
+                    "data_starved_domains": starved,
+                    "mc_dropout_predict_ms": round(ms, 2),
+                    "backend": "CPU, torch, MC-dropout UQ",
+                    "verdict": (f"One shared trunk across {len(specs)} fusion domains, benchmarked head-by-head "
+                                f"against a MATCHED single-task baseline on the same split. On the well-populated "
+                                f"domains the shared representation is positive {pos or 'none'}, negative "
+                                f"{neg or 'none'}, neutral {neu or 'none'} — "
+                                f"{'no negative transfer' if not neg else 'some negative transfer'}. "
+                                + (f"{starved} is data-starved "
+                                   f"({transfer[starved[0]]['n_train'] + transfer[starved[0]]['n_test']} pts) "
+                                   f"and not judged held-out. " if starved else "")
+                                + f"Trained on real on-disk data (CGYRO map / analytic equilibria / twin "
+                                f"sensor snapshots / MAST shots) — an honest multi-task result, not a blanket win.")},
+                "caveats": ["transport has only ~16 points, so its head is data-starved and high-variance "
+                            "(a real limit, reported not hidden)",
+                            "uncertainty is an MC-dropout epistemic proxy, not a calibrated conformal interval",
+                            "equilibrium targets are the analytic Solov'ev family (as in KORE); state targets "
+                            "are the analytic-twin sensor snapshots (as in KFLOW)"]}

kronos_ml/members/quantum.py

@@ -27,7 +27,7 @@ class KQUBIT(Surrogate):
     note = ("REAL variational quantum eigensolver (VQE) for a molecular Hamiltonian — a "
             "runnable quantum program (PennyLane): executes on a simulator now and on real "
             "quantum hardware when you plug in a backend. Honest: no quantum advantage yet "
-            "(~8-10 yr out); the tooling + testing are real TODAY")
+            "(~8-10 yr out); the tooling + testing are real TODAY — quantum's role in fusion is post-~2036")
 
     # H2 molecular Hamiltonian, 2-qubit parity-reduced (standard Qiskit/IBM textbook coeffs, Ha)
     _COEFFS = (-1.052373245772859, 0.39793742484318045, -0.39793742484318045,
@@ -137,7 +137,7 @@ class KQROSS(Surrogate):
     note = ("REAL fault-tolerant resource estimator — computes the classical<->quantum crossover N, "
             "the surface-code physical-qubit overhead, and the logical-qubit roadmap year for a fusion "
             "electronic-structure kernel (order-of-magnitude, literature-scaled). Verdict: no FT "
-            "advantage this decade — the machine does not exist yet")
+            "advantage this decade — the machine does not exist yet; meaningful role post-~2036")
 
     # order-of-magnitude scaling model (literature-scaled; illustrative, honestly labelled)
     _D = 25                                # surface-code distance
@@ -207,7 +207,7 @@ class KSENSE(Surrogate):
     note = ("REAL quantum-metrology evaluation (PennyLane mixed-state) — GHZ interferometry: ideal "
             "gives Heisenberg (gain ~ N) scaling, but realistic dephasing (NV/SQUID/SERF reality) "
             "collapses it back to the standard quantum limit (~sqrt(N)). Honest null where fusion "
-            "disruptions live")
+            "disruptions live; quantum's role in fusion is post-~2036")
 
     _P = 0.2                                  # per-qubit dephasing (realistic sensor decoherence)
 
@@ -284,7 +284,7 @@ class KTENSOR(Surrogate):
     gates = ("KX-L3",)
     note = ("tensor-network / low-rank ROM compression of the real CGYRO A1e flux "
             "database (classical MPS-style SVD; a many-body method and bridge to "
-            "quantum kernels — NO quantum-advantage claim)")
+            "quantum kernels — NO quantum-advantage claim; quantum's role in fusion is post-~2036)")
 
     _COLS = ("a_LT", "shear", "Q_i", "Q_e")   # operating grid + saturated fluxes
 
@@ -395,7 +395,7 @@ class KQERN(Surrogate):
     note = ("REAL quantum-kernel classifier — embeds real MAST disruption features into a "
             "quantum feature map and classifies on the fidelity kernel (PennyLane); runs on a "
             "simulator now, real hardware pluggable. Honest: ties the classical kernel — a "
-            "validated no-advantage result, but a real, runnable quantum-ML pipeline")
+            "validated no-advantage result, but a real, runnable quantum-ML pipeline; role in fusion post-~2036")
 
     _N = 64
     _FEATS = (0, 6, 7, 8)          # ip_mean, beta_n, li, q95 (subset of KWARD's real features)
@@ -490,7 +490,7 @@ class KQOPT(Surrogate):
     note = ("REAL QAOA quantum optimizer — solves a combinatorial design QUBO on an actual "
             "quantum circuit (PennyLane); runs on a simulator now, real hardware pluggable, and "
             "you can plug in your own QUBO. Honest: standard ~0.7-1.0 approx ratio, no speedup "
-            "at this size (~8-10 yr to advantage)")
+            "at this size (advantage post-~2036)")
 
     # a fixed 6-node design QUBO (illustrative MaxCut-style configuration problem)
     _EDGES = ((0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 0), (0, 2), (3, 5))
@@ -586,7 +586,8 @@ class KDYN(Surrogate):
     gates = ("KX-L3",)
     note = ("REAL quantum dynamics — Trotterized time-evolution of a transverse-field Ising "
             "'kinetic' Hamiltonian (PennyLane); the honest 1/n_steps cost curve for simulating "
-            "plasma-like dynamics on a quantum computer. Runs on a simulator now, hardware pluggable")
+            "plasma-like dynamics on a quantum computer. Runs on a simulator now, hardware pluggable; "
+            "quantum's role in fusion is post-~2036")
 
     _NQ = 3; _J = 1.0; _HX = 0.8; _T = 1.0
 

kronos_ml/members/quantum_v3.py

@@ -0,0 +1,286 @@
+"""KODEX v0.3.0 quantum additions — honest, runnable-today NISQ tooling.
+
+KMIT  — quantum ERROR MITIGATION: zero-noise extrapolation (ZNE) + readout-error
+        mitigation applied to a real fusion quantum circuit (the KQUBIT H2 VQE
+        state).  Mitigation is the technique NISQ practitioners actually run
+        today — it claws signal back out of noise; it is NOT a speedup.
+KLINQ — quantum LINEAR SOLVER: a variational quantum linear solver (VQLS) that
+        prepares the solution of a small reduced-MHD linear system with a real
+        quantum circuit, plus an honest fault-tolerant HHL resource estimate.
+
+Framing (founder, 2026-09-19): we see quantum computing taking a meaningful role
+in fusion only AFTER ~2036 — the tooling and testing are real and runnable TODAY
+(here, on a simulator now and on real hardware via KODEX_QC_BACKEND=ibm), the
+advantage is not.
+"""
+from __future__ import annotations
+
+import numpy as np
+
+from .. import register, get
+from ..base import Surrogate, Prediction
+from .. import quantum_backend as qc
+
+_QC_ROLE_YEAR = 2036          # honest: quantum's meaningful role in fusion is post-~2036
+
+
+# ============================================================ KMIT
+@register
+class KMIT(Surrogate):
+    name = "KMIT"; function = "QMITIGATION"; phase = 2; status = "BUILT"
+    provenance = "SIM"
+    retired_by = "fault-tolerant quantum hardware (not available this decade)"
+    real_codes = ("zero-noise extrapolation", "readout-error mitigation", "PennyLane")
+    gates = ("KX-L3",)
+    note = ("REAL quantum error mitigation — zero-noise extrapolation (ZNE, unitary "
+            "folding) + readout-error mitigation on a real fusion quantum circuit "
+            "(the KQUBIT H2 VQE state). Mitigation is the genuine NISQ tool TODAY; it "
+            f"recovers signal from noise, not a speedup. Quantum's role in fusion is "
+            f"post-~{_QC_ROLE_YEAR}")
+
+    _P = 0.04                 # per-qubit depolarizing rate (NISQ-ish)
+    _READOUT = 0.08           # per-qubit readout bit-flip probability
+
+    # ---- ZNE on the KQUBIT H2 VQE circuit ----
+    def _zne(self):
+        import pennylane as qml
+        kq = get("KQUBIT"); kq._run_vqe()
+        params, H = kq._vqe_params, kq._hamiltonian()
+        ansatz = kq._ansatz
+        exact = kq._vqe["exact_energy_Ha"]
+
+        dev_clean = qml.device("default.qubit", wires=2)
+
+        @qml.qnode(dev_clean)
+        def ideal():
+            ansatz(params)
+            return qml.expval(H)
+        e_ideal = float(ideal())          # noiseless expval at the VQE params
+
+        dev = qml.device("default.mixed", wires=2)
+
+        def _noise():
+            for w in (0, 1):
+                qml.DepolarizingChannel(self._P, wires=w)
+
+        @qml.qnode(dev)
+        def folded(k):
+            """Global unitary folding: ansatz (adjoint.ansatz)^k -> logical ansatz,
+            noise scale lambda = 2k+1."""
+            ansatz(params); _noise()
+            for _ in range(k):
+                qml.adjoint(ansatz)(params); _noise()
+                ansatz(params); _noise()
+            return qml.expval(H)
+
+        lambdas = np.array([1, 3, 5], float)     # k = 0, 1, 2
+        energies = np.array([float(folded(int((lam - 1) / 2))) for lam in lambdas])
+        # linear ZNE extrapolation to zero noise
+        slope, intercept = np.polyfit(lambdas, energies, 1)
+        e_noisy = float(energies[0])
+        e_zne = float(intercept)
+        err_noisy = abs(e_noisy - e_ideal)
+        err_zne = abs(e_zne - e_ideal)
+        reduction = (err_noisy - err_zne) / err_noisy if err_noisy > 1e-9 else 0.0
+        return {"exact_energy_Ha": round(exact, 6),
+                "ideal_noiseless_Ha": round(e_ideal, 6),
+                "noisy_Ha": round(e_noisy, 6),
+                "zne_mitigated_Ha": round(e_zne, 6),
+                "noise_scales_lambda": lambdas.tolist(),
+                "energies_vs_lambda": [round(float(e), 6) for e in energies],
+                "error_noisy_mHa": round(err_noisy * 1e3, 3),
+                "error_zne_mHa": round(err_zne * 1e3, 3),
+                "error_reduction_frac": round(float(reduction), 3),
+                "depolarizing_p": self._P, "backend": qc.backend_note()}
+
+    # ---- readout-error mitigation on a Bell distribution ----
+    def _readout_mitigation(self):
+        r = self._READOUT
+        ideal = np.array([0.5, 0.0, 0.0, 0.5])          # Bell |Phi+> probs
+        M1 = np.array([[1 - r, r], [r, 1 - r]])         # per-qubit readout confusion
+        M = np.kron(M1, M1)
+        noisy = M @ ideal
+        mitig = np.linalg.solve(M, noisy)
+        mitig = np.clip(mitig, 0, None); mitig = mitig / mitig.sum()
+        tv = lambda a, b: float(0.5 * np.abs(a - b).sum())
+        tv_noisy, tv_mit = tv(noisy, ideal), tv(mitig, ideal)
+        return {"readout_bitflip_p": r,
+                "tv_distance_noisy": round(tv_noisy, 4),
+                "tv_distance_mitigated": round(tv_mit, 4),
+                "tv_reduction_frac": round((tv_noisy - tv_mit) / tv_noisy, 3) if tv_noisy > 1e-9 else 0.0,
+                "method": "inverse confusion-matrix (linear) readout correction"}
+
+    def _predict(self, x):
+        """x = per-qubit depolarizing rate p (float) -> ZNE-mitigated H2 energy at that noise."""
+        if x is not None:
+            try:
+                self._P = float(np.ravel(np.asarray(x, float))[0])
+            except Exception:
+                pass
+        z = self._zne()
+        return Prediction(z["zne_mitigated_Ha"], z["error_zne_mHa"], True,
+                          note=(f"ZNE-mitigated H2 energy {z['zne_mitigated_Ha']} Ha "
+                                f"(noisy err {z['error_noisy_mHa']} -> {z['error_zne_mHa']} mHa); "
+                                f"backend={z['backend']['active_backend']}"))
+
+    def benchmark(self):
+        z = self._zne(); ro = self._readout_mitigation()
+        return {"member": self.name,
+                "live_error_mitigation": {
+                    "problem": "mitigate a noisy H2 VQE expectation (the real KQUBIT circuit)",
+                    "framework": "PennyLane default.mixed; ZNE via global unitary folding + linear extrapolation",
+                    "zne": z, "readout_mitigation": ro,
+                    "backend": z["backend"],
+                    "verdict": (f"REAL error mitigation on a fusion quantum circuit: ZNE cuts the noisy-energy "
+                                f"error {z['error_noisy_mHa']} -> {z['error_zne_mHa']} mHa "
+                                f"({z['error_reduction_frac']:.0%} of the error removed) and inverse-confusion "
+                                f"readout correction cuts the measurement TV distance "
+                                f"{ro['tv_distance_noisy']} -> {ro['tv_distance_mitigated']} "
+                                f"({ro['tv_reduction_frac']:.0%}). Mitigation is the REAL NISQ tool today — it "
+                                f"recovers signal from noise. HONEST: it is NOT a speedup; quantum's meaningful "
+                                f"role in fusion is post-~{_QC_ROLE_YEAR}, and mitigation cost grows with noise. "
+                                f"Runs on real hardware with KODEX_QC_BACKEND=ibm.")},
+                "caveats": [f"no quantum advantage — quantum's role in fusion is post-~{_QC_ROLE_YEAR}",
+                            "ZNE assumes a smooth noise->observable relation; it extrapolates, it does not "
+                            "eliminate noise, and its overhead grows as noise grows",
+                            "readout mitigation uses a known confusion matrix; on hardware you must calibrate it"]}
+
+
+# ============================================================ KLINQ
+@register
+class KLINQ(Surrogate):
+    name = "KLINQ"; function = "QLINSOLVE"; phase = 3; status = "BUILT"
+    provenance = "SIM"
+    retired_by = "fault-tolerant quantum hardware (not available this decade)"
+    real_codes = ("variational quantum linear solver", "HHL resource estimate", "PennyLane")
+    gates = ("KX-L3",)
+    note = ("REAL quantum linear solver — a variational quantum linear solver (VQLS) prepares the "
+            "solution of a small reduced-MHD linear system with a real quantum circuit (sim now, "
+            "hardware pluggable), plus an honest fault-tolerant HHL resource estimate. No advantage "
+            f"at real scale; quantum's role in fusion is post-~{_QC_ROLE_YEAR}")
+
+    _NQ = 2                                  # N = 4 linear system
+    _N = 4
+
+    def _system(self, b=None):
+        """A small SPD reduced-MHD operator: 1-D discrete Laplacian (tridiagonal),
+        the shape a linearized force-balance / diffusion solve takes."""
+        A = (np.diag([2.0] * self._N) + np.diag([-1.0] * (self._N - 1), 1)
+             + np.diag([-1.0] * (self._N - 1), -1))
+        if b is None:
+            b = np.array([1.0, 0.0, 0.0, 0.0])
+        b = np.asarray(b, float).ravel()[: self._N]
+        b = b / (np.linalg.norm(b) + 1e-12)
+        return A, b
+
+    def _ansatz_state(self, theta, dev):
+        import pennylane as qml
+
+        @qml.qnode(dev)
+        def state(t):
+            # 2-layer hardware-efficient ansatz on 2 qubits
+            qml.RY(t[0], 0); qml.RY(t[1], 1)
+            qml.CNOT([0, 1])
+            qml.RY(t[2], 0); qml.RY(t[3], 1)
+            qml.CNOT([1, 0])
+            qml.RY(t[4], 0); qml.RY(t[5], 1)
+            return qml.state()
+        return np.real(np.asarray(state(theta)))     # SPD system -> real solution
+
+    def _solve(self, b=None):
+        if getattr(self, "_res", None) is not None and b is None:
+            return self._res
+        import pennylane as qml
+        from scipy.optimize import minimize
+        from .. import uq
+        A, bvec = self._system(b)
+        dev = qc.get_device(wires=self._NQ)
+
+        def cost(theta):
+            x = self._ansatz_state(theta, dev)
+            Ax = A @ x
+            nAx = np.linalg.norm(Ax) + 1e-12
+            overlap = float(bvec @ (Ax / nAx))       # want A|x> parallel to |b>
+            return 1.0 - overlap ** 2                 # global VQLS cost
+
+        rng = np.random.default_rng(uq.SEED)
+        best = None
+        for _ in range(4):                            # a few restarts for robustness
+            t0 = rng.uniform(0, 2 * np.pi, 6)
+            r = minimize(cost, t0, method="Powell",
+                         options={"maxiter": 4000, "xtol": 1e-8, "ftol": 1e-10})
+            if best is None or r.fun < best.fun:
+                best = r
+        theta = best.x
+        x_q = self._ansatz_state(theta, dev)
+        # VQLS solves up to scale & sign: fix by projecting onto the classical solution direction
+        x_cl = np.linalg.solve(A, bvec)
+        x_q_dir = x_q / (np.linalg.norm(x_q) + 1e-12)
+        x_cl_dir = x_cl / (np.linalg.norm(x_cl) + 1e-12)
+        if x_q_dir @ x_cl_dir < 0:
+            x_q_dir = -x_q_dir
+        fidelity = float((x_q_dir @ x_cl_dir) ** 2)   # state fidelity of the solutions
+        # rescale quantum direction to the true magnitude for a usable x
+        alpha = float((A @ x_q_dir) @ bvec) / float((A @ x_q_dir) @ (A @ x_q_dir) + 1e-12)
+        x_q_scaled = alpha * x_q_dir
+        resid = float(np.linalg.norm(A @ x_q_scaled - bvec) / (np.linalg.norm(bvec) + 1e-12))
+        res = {"N": self._N, "n_qubits": self._NQ, "cost_final": round(float(best.fun), 6),
+               "solution_fidelity_vs_classical": round(fidelity, 4),
+               "residual_rel": round(resid, 4),
+               "x_quantum": [round(float(v), 4) for v in x_q_scaled],
+               "x_classical": [round(float(v), 4) for v in x_cl],
+               "backend": qc.backend_note()}
+        if b is None:
+            self._res = res
+        return res
+
+    # ---- honest fault-tolerant HHL resource estimate (KQROSS-style) ----
+    def _hhl_estimate(self, N=1_000_000, kappa=1e3, precision_bits=10):
+        """Order-of-magnitude FT-HHL cost for a fusion-scale sparse linear solve."""
+        n_logical = int(np.ceil(np.log2(N))) + precision_bits + 1     # system + clock + ancilla
+        phys_per_logical = 2 * 25 * 25                                # surface code d=25 (~1250)
+        phys = n_logical * phys_per_logical
+        # HHL ~ O(kappa/eps) calls; classical CG ~ O(sqrt(kappa)) matvecs — quantum needs
+        # sparse, well-conditioned, and only reads out an aggregate, else state-prep/readout kill it
+        roadmap_year = 2027 + 3.0 * np.log10(max(n_logical, 1) / 1.0)  # ~10x logical / 3 yr from ~1 in 2027
+        return {"assumed_system": f"N~{N:.0e} sparse SPD (reduced-MHD grid), kappa~{kappa:.0e}",
+                "logical_qubits_needed": n_logical,
+                "physical_qubits_needed": f"~{phys:.0e}",
+                "surface_code_phys_per_logical": phys_per_logical,
+                "roadmap_year_reach_logical": int(round(roadmap_year)),
+                "hardware_today": "~1e2-1e3 physical qubits, no error-corrected logical qubits",
+                "caveats": ["HHL needs fault tolerance + sparse, well-conditioned A + efficient state "
+                            "prep, and returns |x> (aggregate readout), not the full vector",
+                            f"no fusion HHL advantage this decade — meaningful role post-~{_QC_ROLE_YEAR}"]}
+
+    def _predict(self, x):
+        """x = right-hand-side vector b (len<=4) or None -> quantum solution x of A x = b."""
+        r = self._solve(None if x is None else x)
+        return Prediction(r["x_quantum"], r["residual_rel"], True,
+                          note=(f"VQLS solution (fidelity {r['solution_fidelity_vs_classical']} vs classical, "
+                                f"rel-residual {r['residual_rel']}); backend={r['backend']['active_backend']}"))
+
+    def benchmark(self):
+        r = self._solve()
+        hhl = self._hhl_estimate()
+        return {"member": self.name,
+                "live_quantum_linear_solver": {
+                    "problem": "solve A x = b for a 4x4 reduced-MHD Laplacian (SPD) with a real quantum circuit",
+                    "method": "variational quantum linear solver (VQLS), global overlap cost, Powell optimization",
+                    "framework": "PennyLane (sim now; Hadamard-test cost on real hardware, pluggable)",
+                    **{k: r[k] for k in ("N", "n_qubits", "cost_final", "solution_fidelity_vs_classical",
+                                         "residual_rel", "x_quantum", "x_classical")},
+                    "ft_hhl_resource_estimate": hhl, "backend": r["backend"],
+                    "verdict": (f"REAL variational quantum linear solver recovers the 4x4 reduced-MHD solve at "
+                                f"solution fidelity {r['solution_fidelity_vs_classical']} vs classical "
+                                f"(rel-residual {r['residual_rel']}) — a runnable quantum linear solver TODAY. "
+                                f"The fault-tolerant HHL route for a fusion-scale (N~1e6) solve needs "
+                                f"~{hhl['logical_qubits_needed']} logical -> {hhl['physical_qubits_needed']} "
+                                f"physical qubits (roadmap ~{hhl['roadmap_year_reach_logical']}). HONEST: no "
+                                f"advantage at real scale; quantum's meaningful role in fusion is "
+                                f"post-~{_QC_ROLE_YEAR}. Runs on hardware with KODEX_QC_BACKEND=ibm.")},
+                "caveats": [f"no quantum advantage — quantum's role in fusion is post-~{_QC_ROLE_YEAR}",
+                            "VQLS residual is read from the simulator here; on hardware it needs Hadamard "
+                            "tests and its cost landscape can have barren plateaus at scale",
+                            "the 4x4 system is a toy; classical solves it instantly — the point is a real, "
+                            "honest, hardware-ready quantum pipeline, not a speedup"]}

kronos_ml/quantum_backend.py

@@ -62,6 +62,7 @@ def backend_note() -> dict:
         "ran_on_real_hardware": real,
         "how_to_use_real_qc": ("set KODEX_QC_BACKEND=ibm and KODEX_QC_TOKEN=<your IBM Quantum "
                                "token> to run this exact circuit on real quantum hardware"),
-        "honest_timeline": ("fault-tolerant quantum ADVANTAGE for fusion kernels is ~8-10 yr out; "
-                            "this tooling makes the TESTING real and runnable TODAY, same code path"),
+        "honest_timeline": ("fault-tolerant quantum ADVANTAGE for fusion kernels is ~8-10 yr out — a "
+                            "meaningful role in fusion only after ~2036; this tooling makes the TESTING "
+                            "real and runnable TODAY, same code path"),
     }

publish/LIVE_RECORDS.md

@@ -1,36 +0,0 @@
-# KODEX — live deposit records (per code)
-
-Status 2026-09-10: **Zenodo, OSF, Figshare = published** (26 each). **Harvard Dataverse = 25 submitted for curator review** (DOIs reserved; publish on Harvard approval) — **KLAW (doi:10.7910/DVN/ANAFXK) still to submit**. GitHub / PyPI / Hugging Face / Internet Archive = pending.
-
-Author: Ford, P. I. · ORCID 0000-0003-0395-1752 · Kronos Fusion Energy · Apache-2.0. Each record's homepage = kronosfusionenergy.com/kodex/<code>.
-
-| Code | Zenodo DOI | Figshare DOI | Dataverse DOI (in review) | OSF |
-|--|--|--|--|--|
-| **KAIROS** | 10.5281/zenodo.22694265 | 10.6084/m9.figshare.33553966 | 10.7910/DVN/GOZGCM | [db6uh](https://osf.io/db6uh/) |
-| **KBREED** | 10.5281/zenodo.22694267 | 10.6084/m9.figshare.33559312 | 10.7910/DVN/OPJHP3 | [2m3ce](https://osf.io/2m3ce/) |
-| **KBURN** | 10.5281/zenodo.22694269 | 10.6084/m9.figshare.33559324 | 10.7910/DVN/ITN6JZ | [8e6fn](https://osf.io/8e6fn/) |
-| **KDRIVE** | 10.5281/zenodo.22694271 | 10.6084/m9.figshare.33559333 | 10.7910/DVN/YKKLQ7 | [xhkuy](https://osf.io/xhkuy/) |
-| **KECON** | 10.5281/zenodo.22694273 | 10.6084/m9.figshare.33559345 | 10.7910/DVN/WBHQ7S | [b5qmx](https://osf.io/b5qmx/) |
-| **KEYE** | 10.5281/zenodo.22694279 | 10.6084/m9.figshare.33559357 | 10.7910/DVN/5UILC8 | [5qzp4](https://osf.io/5qzp4/) |
-| **KFLOW** | 10.5281/zenodo.22694283 | 10.6084/m9.figshare.33559369 | 10.7910/DVN/XUXC7B | [hjrzb](https://osf.io/hjrzb/) |
-| **KFLUX** | 10.5281/zenodo.22694287 | 10.6084/m9.figshare.33559378 | 10.7910/DVN/3F0NCW | [fmjc2](https://osf.io/fmjc2/) |
-| **KFORGE** | 10.5281/zenodo.22694289 | 10.6084/m9.figshare.33559390 | 10.7910/DVN/OVOVVN | [5zg6j](https://osf.io/5zg6j/) |
-| **KFUEL** | 10.5281/zenodo.22694291 | 10.6084/m9.figshare.33559402 | 10.7910/DVN/89A8GS | [xuz8a](https://osf.io/xuz8a/) |
-| **KFUSE** | 10.5281/zenodo.22694294 | 10.6084/m9.figshare.33559414 | 10.7910/DVN/SMA2OP | [exhkc](https://osf.io/exhkc/) |
-| **KGATE** | 10.5281/zenodo.22694297 | 10.6084/m9.figshare.33559423 | 10.7910/DVN/2CKPZH | [mbu37](https://osf.io/mbu37/) |
-| **KGEN** | 10.5281/zenodo.22694307 | 10.6084/m9.figshare.33559435 | 10.7910/DVN/OCTF8U | [svbwq](https://osf.io/svbwq/) |
-| **KHALO** | 10.5281/zenodo.22694309 | 10.6084/m9.figshare.33559447 | 10.7910/DVN/V5YM23 | [ne89y](https://osf.io/ne89y/) |
-| **KISO** | 10.5281/zenodo.22694311 | 10.6084/m9.figshare.33559459 | 10.7910/DVN/ELXAEY | [hjqek](https://osf.io/hjqek/) |
-| **KLAW** | 10.5281/zenodo.22694315 | 10.6084/m9.figshare.33559468 | 10.7910/DVN/ANAFXK | [kfp4t](https://osf.io/kfp4t/) |
-| **KMAT** | 10.5281/zenodo.22694319 | 10.6084/m9.figshare.33559480 | 10.7910/DVN/IJG9FT | [y4j2p](https://osf.io/y4j2p/) |
-| **KOIL** | 10.5281/zenodo.22694323 | 10.6084/m9.figshare.33559492 | 10.7910/DVN/N5WLNR | [2rb68](https://osf.io/2rb68/) |
-| **KORE** | 10.5281/zenodo.22694327 | 10.6084/m9.figshare.33559504 | 10.7910/DVN/DCFLOI | [sxm5v](https://osf.io/sxm5v/) |
-| **KPATH** | 10.5281/zenodo.22694329 | 10.6084/m9.figshare.33559513 | 10.7910/DVN/8QIUD4 | [fbcyw](https://osf.io/fbcyw/) |
-| **KPILOT** | 10.5281/zenodo.22694331 | 10.6084/m9.figshare.33559525 | 10.7910/DVN/EYD6FZ | [aqxe8](https://osf.io/aqxe8/) |
-| **KQROSS** | 10.5281/zenodo.22694333 | 10.6084/m9.figshare.33559537 | 10.7910/DVN/IIDBCF | [zp82a](https://osf.io/zp82a/) |
-| **KQUBIT** | 10.5281/zenodo.22694336 | 10.6084/m9.figshare.33559546 | 10.7910/DVN/2BC8BL | [eqr9z](https://osf.io/eqr9z/) |
-| **KSENSE** | 10.5281/zenodo.22694338 | 10.6084/m9.figshare.33559558 | 10.7910/DVN/5LQJAF | [psr8h](https://osf.io/psr8h/) |
-| **KWARD** | 10.5281/zenodo.22694342 | 10.6084/m9.figshare.33559570 | 10.7910/DVN/VPYXHS | [ugfpr](https://osf.io/ugfpr/) |
-| **KYRO** | 10.5281/zenodo.22694348 | 10.6084/m9.figshare.33559582 | 10.7910/DVN/2YQQOX | [5m6vu](https://osf.io/5m6vu/) |
-
-_Generated from publish/state/*.json. Zenodo/Figshare DOIs are permanent; Dataverse DOIs activate when Harvard curators approve the review submissions._

publish/MANIFEST.sha256

@@ -1,41 +0,0 @@
-# KODEX SHA-256 manifest (v0.1.0, 2026-09-10)
-
-2ac66d4d7d4a89054d47e15215b9d6eca8e527503763b9b05c85b65160f5d8ec  .gitignore
-8695a176b58590a0bbc6b7ede1c0ce4a270c54115aa06777e1462bfebe86bd1a  .zenodo.json
-b1ee5fa8a901a64265186e58788f420b94c37151a61144a3c24ed37d782325e3  BENCHMARKS.md
-9bb42b66491b72e95cfc26b4139c767ec7eda643d479061183c65af55db56d44  CITATION.cff
-889dc088a39f3b908cc627dcbd09e252a75abea42f716f664eafcf7d8b7ff578  CODES.md
-16f411de9a68f30ea8f05572c7a2aebe8cd923acec35bb55441b1a92861ce7c2  FAMILY.md
-ae87ebecd1f321a19799e21f6fe25e4a74261f16c91e6cb6cc248e6197dcf838  LICENSE
-faf6dbd85a3cd3b9879201b7470e7ba858ae560108b7c984ec33809081d51a3d  README.md
-8d2e3d7856756d03007be14187b5dd5bf10e22160e9f04103015141c04643d42  benchmarks/benchmarks.json
-361ef1108dc3ea2c4d6499b47ea4617a528a53bef4254abafdb889568a2772d3  benchmarks/run_all.py
-5e138e573eeaaaf7a5c2b0c74570adbf7cb132058f2c8c2dd7c25e3c18a4d77f  checkpoints/kore_mlp_seed0.pt
-a251c80fc84f2c46be0a8aa822bc5a3619c32019627d0d35001531d0b5d3be19  checkpoints/kore_mlp_seed1.pt
-525cecaf99600dd7ccddb1d25a84fa216ab71739d73c39b62bb04d1e434bfd76  checkpoints/kore_mlp_seed2.pt
-6e5136d13e3e0b8335d146e65dce940b54e38e0e6a7bfe1fbdb3af8ea8483d88  codemeta.json
-162d8a2ba10cead49dd9be7276dc7c57177f151f174d1ea623ad1f65fce2d43a  demo.ipynb
-b4233195b725817a61d1801f7c744159486076bae1c3bb9fd7d0e9ab9070f3dd  kronos_ml/__init__.py
-835650847427eb59f9240a6bbcd1db4ec739eacef974aa0200944bbe3348043e  kronos_ml/_torch.py
-c094cca7d3393317f8e412f41211b073be1701560b8c2923f84ab1e0bf770753  kronos_ml/base.py
-510bf0fe2c2ce159dec25629ad903e3b0de1e97fdc2621b80efce87e4d6c33a7  kronos_ml/data.py
-5d34c8aec99f9f7c5e6f62cb3b02b1aafeb311bb94d38f880d9ae6de63e51733  kronos_ml/members/__init__.py
-e5b88836b177c757a4f2db0925eac364ad12abe8c18038e14be9432286c03e61  kronos_ml/members/advanced.py
-f87aaf941a7ee00200f18bd35d68880e5365d62aa48bb029ab64e0091f16888e  kronos_ml/members/capstone.py
-2b1d273280c16b1771cf1fd745aa558b967d9dac0684eb722dfdc867812fe9d1  kronos_ml/members/control.py
-5c340f9813497f5382b3a5324b76311b216f5696c9d8f3b2d0fb8f7491d7f671  kronos_ml/members/disrupt.py
-3f881fef3d4b8b255907c3adda0c3936b335c4aadb51e7a566bf4095bd058c29  kronos_ml/members/equil.py
-56d7f4b0b4072224772e3a59f1642ef4e5f5afaf70575636775a73a891f6e0d3  kronos_ml/members/fusion.py
-a8639ff450bb27a42771a2251ee852291ecaf09c4a1795cfc790ce67a84b808e  kronos_ml/members/magnet.py
-9265df980412b82ef2185fb3d143c93780f4da76fda72fa4b6b010b6ae06b3de  kronos_ml/members/materials.py
-f843996eeaa949e470ecce22713e5505649ce9fc1a7f5a6cdfca425a2ded09dc  kronos_ml/members/neutronics.py
-2708133806780dce88184fa19c03b3760f207788c78d9e8edddcecd35f991e5e  kronos_ml/members/plant.py
-ad05706b4f588e413b1314ebe7b3069c57a21ccf040d6fb762eb731aeda41584  kronos_ml/members/quantum.py
-c9b921c1131b95831366c0197663b486ea1c9a302b119ef3880249d6c897c7bf  kronos_ml/members/roadmap.py
-75c01157cea0ab64f6a3458d76e69fa2be386fd5e4c6168d6e08d41e46a53c15  kronos_ml/members/spine.py
-eca2a363d02653b4fbe5e68df2ca41ecb5c277fd66fea22694681d648ecf7f64  kronos_ml/members/state.py
-f6466e59e49482d4423fb0415e3a7e4377eada9d2544a734a23a82974730e60f  kronos_ml/members/transport.py
-508a45df51b194c435bfdd2d79658bff66bb77913a0ea66cea40116a7867266a  kronos_ml/metrics.py
-578e86ef6f3faa7cce6682541d6cedb52c7f652d187085088dc3a4e8ccd4b5db  kronos_ml/uq.py
-0f1af657ccf7539ab9dbbc2dd5408afa08085670d9c896bd5e95cbb4352124ec  pyproject.toml
-54516950a748b00bc0992388ae3ae1a3fda3739307e7f2b651670896fb30c823  tests/test_contract.py

publish/PROVENANCE.md

@@ -1,42 +0,0 @@
-# KODEX provenance & traceability (v0.1.0, 2026-09-10)
-
-Each BUILT code traces: **code -> real benchmark -> on-disk data/method -> Kronos corpus DOI -> /kodex page.**
-
-| # | Code | Ph | Provenance | Real source/method | Corpus anchor | Page |
-|--|--|--|--|--|--|--|
-| 01 | **KAIROS** | 1 | TWIN | receding-horizon MPC | references:10.5281/zenodo.21842371; references:10.5281/zenodo.22645689 | kairos |
-| 02 | **KBREED** | 2 | SIM | openmc | references:10.5281/zenodo.22645689 | kbreed |
-| 03 | **KBURN** | 2 | TWIN | plant systems model | references:10.5281/zenodo.21842371; references:10.5281/zenodo.22645689 | kburn |
-| 04 | **KDRIVE** | 3 | TWIN | reinforcement learning | references:10.5281/zenodo.21842371; references:10.5281/zenodo.22645689 | kdrive |
-| 05 | **KECON** | 3 | n/a | open LCOE methodology | references:10.5281/zenodo.21842371; references:10.5281/zenodo.22645689 | kecon |
-| 06 | **KEYE** | 2 | SIM | sensor fusion, signal validation | references:10.5281/zenodo.21842371; references:10.5281/zenodo.22645689 | keye |
-| 07 | **KFLOW** | 1 | SIM | message-passing GNN | references:10.5281/zenodo.21842371; references:10.5281/zenodo.22645689 | kflow |
-| 08 | **KFLUX** | 2 | SIM | openmc | references:10.5281/zenodo.22645689 | kflux |
-| 09 | **KFORGE** | 3 | CGYRO-urep | differential evolution over the fleet | isDerivedFrom:10.5281/zenodo.22136279 | kforge |
-| 10 | **KFUEL** | 3 | SIM | fuel-cycle systems model | references:10.5281/zenodo.21842371; references:10.5281/zenodo.22645689 | kfuel |
-| 11 | **KFUSE** | 2 | CGYRO-urep | multi-fidelity GP, CGYRO | isDerivedFrom:10.5281/zenodo.22136279 | kfuse |
-| 12 | **KGATE** | 1 | TWIN | CBF certificate, hardware failsafe | references:10.5281/zenodo.21842371; references:10.5281/zenodo.22645689 | kgate |
-| 13 | **KGEN** | 3 | ANALYTIC | generative model | references:10.5281/zenodo.21842371; references:10.5281/zenodo.22645689 | kgen |
-| 14 | **KHALO** | 1 | SIM | deep-ensemble, conformal | references:10.5281/zenodo.21842371; references:10.5281/zenodo.22645689 | khalo |
-| 15 | **KISO** | 2 | SIM | isotope PI servo, FENDL-3.2 activation | references:10.5281/zenodo.22645689; isDerivedFrom:https://www-nds.iaea.org/fendl/ | kiso |
-| 16 | **KLAW** | 3 | CGYRO-urep | sparse regression / SINDy | isDerivedFrom:10.5281/zenodo.22136279 | klaw |
-| 17 | **KMAT** | 1 | SIM | CHGNet, DFT | references:10.5281/zenodo.21842371; references:10.5281/zenodo.22645689 | kmat |
-| 18 | **KOIL** | 1 | SIM | finite-element stress solve | references:10.5281/zenodo.21842371; references:10.5281/zenodo.22645689 | koil |
-| 19 | **KORE** | 1 | ANALYTIC | Grad-Shafranov FD solver | references:10.5281/zenodo.21842371; references:10.5281/zenodo.22645689 | kore |
-| 20 | **KPATH** | 2 | TWIN | MPC scenario optimizer | references:10.5281/zenodo.21842371; references:10.5281/zenodo.22645689 | kpath |
-| 21 | **KPILOT** | 3 | n/a | fleet router / tool dispatcher | references:10.5281/zenodo.21842371; references:10.5281/zenodo.22645689 | kpilot |
-| 22 | **KQROSS** | 2 | SIM | FT resource estimation | isDerivedFrom:10.5281/zenodo.21842371 | kqross |
-| 23 | **KQUBIT** | 1 | SIM | VQE, quantum chemistry | isDerivedFrom:10.5281/zenodo.21842371 | kqubit |
-| 24 | **KSENSE** | 2 | SIM | NV/SQUID/SERF magnetometry | isDerivedFrom:10.5281/zenodo.21842371 | ksense |
-| 25 | **KWARD** | 1 | REAL-ANCHOR | real MAST shots (FAIR-MAST) | isDerivedFrom:https://mastapp.site; references:10.5281/zenodo.22645689 | kward |
-| 26 | **KYRO** | 1 | CGYRO-urep | cgyro, gene, gs2, tglf | isDerivedFrom:10.5281/zenodo.22136279 | kyro |
-
-## Held as ROADMAP (4)
-
-- **KEDGE** (ROADMAP, phase 3) — divertor / SOL / edge heat-flux transport surrogate
-- **KHEAT** (PARTIAL, phase 2) — RF / NBI heating & current-drive actuator-response surrogate
-- **KRAD** (ROADMAP, phase 3) — impurity seeding / radiation / divertor-detachment control
-- **KTENSOR** (PARTIAL, phase 2) — tensor-network simulation & compression — a classical many-body method and a bridge to quantum for kernel problems
-
-Anchor DOIs: CGYRO `10.5281/zenodo.22136279` · Register `10.5281/zenodo.22645689` · AI+Quantum `10.5281/zenodo.21842371` · toolkit https://github.com/KronosFE/kronos-toolkit
-

publish/PUBLISH_RUNBOOK.md

@@ -1,158 +0,0 @@
-# KODEX — publish runbook (PER-CODE, DRAFT-FIRST)
-
-**Release:** KODEX v0.1.0 — the Kronos Family of Codes.
-**Model:** **26 per-code records** on each data repository (Zenodo / OSF / Figshare / Harvard Dataverse /
-Internet Archive) — each BUILT code gets its own record + DOI. **GitHub = ONE repo** (`kronos-ml`, 26
-modules). **PyPI = ONE package** (`kronos-ml`, 26 importable codes). **Held as ROADMAP (not published):**
-KHEAT, KTENSOR, KEDGE, KRAD.
-**Author on every record:** Ford, P. I. · ORCID `0000-0003-0395-1752` · Kronos Fusion Energy · Apache-2.0.
-
-> **Draft-first, two-step per data venue.** Step 1 `*_draft.py` creates all 26 records as **private/
-> unpublished** and uploads each code's files — nothing is public. Step 2 `*_publish_all.py` is a **dry run
-> by default** and publishes only with an explicit **`--yes`** — that `--yes` is your single deliberate
-> authorization for that venue's 26. The draft scripts NEVER publish; the publish scripts do nothing
-> without `--yes`. (Internet Archive is one step — items are public on upload — so `ia_upload_all.py`
-> requires `--yes` and IS the publish.)
-
-Per-code metadata lives in `publish/records/<code>/metadata.json`; each record's homepage is
-`kronosfusionenergy.com/kodex/<code>`, with its physics-source + the shared Kronos anchors
-(register `10.5281/zenodo.22645689`, CGYRO `10.5281/zenodo.22136279`, AI+Quantum `10.5281/zenodo.21842371`,
-toolkit) as related-identifiers, honest card preserved. Per-code attach set: `<code>.py` (source excerpt),
-`benchmark.json`, `card.md`, `CITATION.cff`, `LICENSE`, `MANIFEST.sha256`. The repo-root `.zenodo.json`,
-`CITATION.cff`, `codemeta.json` describe the **GitHub/PyPI package** (the one-repo/one-package side).
-
-## Token map
-
-| Venue | Credential | Env var | Status |
-|---|---|---|---|
-| GitHub | SSH key | — | ✅ ready |
-| Zenodo | token `deposit:write` | `ZENODO_TOKEN` | ✅ ready |
-| OSF | token `osf.full_write` | `OSF_TOKEN` | ✅ ready |
-| Figshare | personal token | `FIGSHARE_TOKEN` | ✅ ready |
-| Internet Archive | `ia configure` (S3 keys) | — | ✅ ready |
-| Harvard Dataverse | API token (115-paper/books token) | `DATAVERSE_TOKEN` + `DATAVERSE_CONTACT_EMAIL` | ⏳ token needed |
-| PyPI | API token | `TWINE_PASSWORD` (`TWINE_USERNAME=__token__`) | ⏳ fast-follow |
-| Hugging Face | write token | `HF_TOKEN` | ⏳ fast-follow |
-
-## Preflight (once)
-
-```bash
-cd "/Users/pford/Desktop/Kronos Fusion Energy/04 - IT INFRASTRUCTURE/07 - IT Infrastructure & Code Repos/Code Repos (live)/kronos-ml"
-PY=~/kronos-hpc-build/ml311_venv/bin/python
-$PY -m pytest tests/ -q                 # expect 9 passed
-$PY publish/_percode.py                  # (re)builds publish/records/<code>/ for all 26 (resume-safe)
-```
-
-> ⚠ **numpy pin:** this venv must keep **numpy<2** (torch 2.2.2 needs it; numpy 2.x breaks KORE). If a
-> tool ever pulls numpy 2.x back in, run `$PY -m pip install "numpy==1.26.4"` before benchmarking.
-
----
-
-## 1) GitHub — ONE repo (git@github.com:KronosFE/kronos-ml.git)
-
-```bash
-git init -b main
-git add .
-git commit -m "KODEX v0.1.0 — Kronos Family of Codes (26 BUILT surrogates)"
-git tag -a v0.1.0 -m "KODEX v0.1.0"
-# create the repo PRIVATE on GitHub, then:
-git remote add origin git@github.com:KronosFE/kronos-ml.git
-git push -u origin main --tags
-# → review; when ready, make public + draft a Release from tag v0.1.0.
-# Do NOT enable the GitHub↔Zenodo webhook (we deposit Zenodo per-code below).
-```
-
-## 2) Zenodo — 26 per-code records
-
-```bash
-export ZENODO_TOKEN=...                  # rehearse first: export ZENODO_BASE=https://sandbox.zenodo.org
-$PY publish/zenodo_draft.py              # creates 26 DRAFTS (resume-safe), nothing public
-$PY publish/zenodo_publish_all.py        # DRY RUN — lists the 26 drafts
-$PY publish/zenodo_publish_all.py --yes  # ← your one authorization: publishes all 26, mints DOIs
-```
-
-## 3) OSF — 26 private projects → public
-
-```bash
-export OSF_TOKEN=...
-$PY publish/osf_draft.py                 # 26 PRIVATE projects
-$PY publish/osf_publish_all.py           # DRY RUN
-$PY publish/osf_publish_all.py --yes     # ← make all 26 public
-```
-
-## 4) Figshare — 26 draft articles → published
-
-```bash
-export FIGSHARE_TOKEN=...
-$PY publish/figshare_draft.py            # 26 DRAFT articles (DOIs reserved, not published)
-$PY publish/figshare_publish_all.py      # DRY RUN
-$PY publish/figshare_publish_all.py --yes
-```
-
-## 5) Harvard Dataverse — 26 datasets (published by CURATORS, not by --yes)
-
-STATUS 2026-09-10: the 26 drafts are created; **25 were submitted for Harvard curator review**
-(`review:true` in state) and publish when a Harvard **curator approves** — NOT via a depositor
-`--yes`. `dataverse_publish_all.py` now refuses to `:publish` review-queued datasets (a direct
-publish on an In-Review dataset errors), so `--yes` is a no-op for the 25. Two open items before
-curators approve (the published version is immutable):
-
-1. **KLAW** (`doi:10.7910/DVN/ANAFXK`) was NOT submitted for review — submit it so it isn't stranded:
-   ```bash
-   export DATAVERSE_TOKEN=...
-   curl -H "X-Dataverse-key:$DATAVERSE_TOKEN" -X POST \
-     "https://dataverse.harvard.edu/api/datasets/:persistentId/submitForReview?persistentId=doi:10.7910/DVN/ANAFXK"
-   # then set "review": true for KLAW in publish/state/dataverse_drafts.json
-   ```
-2. **License field**: the drafts carry no dataset-level license, so Harvard will publish them as
-   **CC0** unless Apache-2.0 is set. Check + set before approval:
-   ```bash
-   curl -s -H "X-Dataverse-key:$DATAVERSE_TOKEN" https://dataverse.harvard.edu/api/licenses | grep -i apache
-   # if Apache-2.0 is installed, set it on each draft version (API) before curator approval;
-   # otherwise the Apache-2.0 statement in the description + bundled LICENSE stand, and you accept CC0.
-   ```
-(Re-running `dataverse_draft.py` is safe — it skips the 26 already-created datasets.)
-
-## 6) Internet Archive — 26 items (public on upload; one step)
-
-```bash
-ia configure                             # once, with your IA S3 keys
-$PY publish/ia_upload_all.py             # DRY RUN — lists the 26 item identifiers
-$PY publish/ia_upload_all.py --yes       # ← uploads 26 items (PUBLIC immediately)
-```
-
----
-
-## Fast-follow (when the tokens land)
-
-### PyPI — ONE package
-```bash
-$PY -m build
-export TWINE_USERNAME=__token__ TWINE_PASSWORD=pypi-...
-$PY -m twine upload --repository testpypi dist/*      # rehearse first
-$PY -m twine upload dist/*
-```
-
-### Hugging Face — per-code model repos (or one)
-```bash
-export HF_TOKEN=...
-$PY -m pip install -q huggingface_hub
-# one suite repo:
-huggingface-cli upload KronosFE/kronos-ml . . --repo-type=model --token "$HF_TOKEN"
-# (per-code repos KronosFE/kodex-<code> can be scripted the same way if preferred)
-```
-
----
-
-## Rollback (discard drafts — nothing was public)
-- **Zenodo / Figshare / Dataverse:** delete the unpublished drafts in each UI (or via each API).
-- **OSF:** projects are private until `--yes`; delete in the UI.
-- **GitHub:** repo stays private until you flip it.
-- **Internet Archive:** items are public on upload — only run `--yes` when you're sure; ask IA support to
-  dark an item if needed.
-- Re-running any `*_draft.py` is safe: it skips codes already in `publish/state/<venue>_drafts.json`.
-
-## Provenance recorded in every record
-code → real benchmark (`benchmark.json`) → on-disk data/method → Kronos corpus DOI → `/kodex/<code>` page.
-Honest cards intact: μ=400 representative-mass (CGYRO codes); validated null result (quantum codes);
-KWARD heuristic labels + independent-precursor AUC 0.975 (n=1 Mirnov + P_rad only); KECON financial firewall.

publish/_deposit_common.py

@@ -1,68 +0,0 @@
-"""Shared helpers for the KODEX draft-first deposits.
-
-Builds a clean release archive and defines the attach list + metadata. Imported by
-zenodo_draft.py / osf_draft.py / figshare_draft.py. NONE of those scripts ever call
-a venue's publish/complete endpoint — they create a DRAFT and upload files, then
-print the draft URL for the founder to review and publish herself.
-"""
-from __future__ import annotations
-import json, os, zipfile
-from pathlib import Path
-
-REPO = Path(__file__).resolve().parent.parent
-PUB = REPO / "publish"
-VERSION = json.load(open(PUB / "_scaffolding_summary.json"))["version"]
-ARCHIVE = PUB / f"kronos-ml-v{VERSION}-source.zip"
-
-# individual human-readable artifacts attached alongside the source archive
-DOCS = ["README.md", "FAMILY.md", "CODES.md", "BENCHMARKS.md", "benchmarks/benchmarks.json",
-        "demo.ipynb", "CITATION.cff", "LICENSE", "codemeta.json", ".zenodo.json",
-        "publish/PROVENANCE.md", "publish/MANIFEST.sha256"]
-
-_SKIP_DIRS = {"__pycache__", ".git", ".ipynb_checkpoints", ".pytest_cache", "dist"}
-_SKIP_SUFFIX = {".pyc", ".pyo"}
-
-
-def build_archive() -> Path:
-    """Zip the whole package (source + tests + docs + manifest), minus cruft."""
-    with zipfile.ZipFile(ARCHIVE, "w", zipfile.ZIP_DEFLATED) as z:
-        for root, dirs, files in os.walk(REPO):
-            dirs[:] = [d for d in dirs if d not in _SKIP_DIRS]
-            for fn in files:
-                p = Path(root) / fn
-                if p.suffix in _SKIP_SUFFIX or p == ARCHIVE:
-                    continue
-                if p.name.endswith(".parquet"):
-                    continue
-                z.write(p, p.relative_to(REPO))
-    return ARCHIVE
-
-
-def attach_paths() -> list[Path]:
-    """Full attach set: the source archive + the individual docs f7 asked for."""
-    out = [build_archive()]
-    for rel in DOCS:
-        p = REPO / rel
-        if p.exists():
-            out.append(p)
-    return out
-
-
-def zenodo_metadata() -> dict:
-    return json.load(open(REPO / ".zenodo.json"))
-
-
-def require_env(var: str) -> str:
-    v = os.environ.get(var)
-    if not v:
-        raise SystemExit(f"[STOP] environment variable {var} is not set. "
-                         f"Export your token first (see PUBLISH_RUNBOOK.md).")
-    return v
-
-
-if __name__ == "__main__":
-    paths = attach_paths()
-    print(f"archive: {ARCHIVE.name}")
-    print(f"attach set ({len(paths)} files):")
-    for p in paths:
-        print(f"  {p.relative_to(REPO)}  ({p.stat().st_size:,} B)")

publish/_percode.py

@@ -1,256 +0,0 @@
-"""Per-code deposit engine for KODEX (26 BUILT codes -> 26 records per data venue).
-
-Generates publish/records/<kname>/ (metadata + per-code attach set) and provides the
-shared helpers the venue scripts use to loop. State (created draft ids/DOIs) is written
-to publish/state/<venue>_drafts.json so a run can resume and the batch-publish step
-knows exactly what to act on.
-
-DRAFT-FIRST: nothing here publishes. The *_draft.py scripts create drafts; the separate
-*_publish_all.py scripts publish only drafts listed in the state file, only with --yes.
-"""
-from __future__ import annotations
-import hashlib, html, inspect, json, os, random, re, shutil, sys, time
-from datetime import date
-from pathlib import Path
-
-_RETRY_CODES = {403, 408, 425, 429, 500, 502, 503, 504}
-
-
-def http_retry(fn, *, tries=6, base=0.8, label=""):
-    """Call fn() -> requests.Response; retry transient/rate-limit codes with expo backoff.
-    Returns the final Response (caller still checks .ok / raises). 2xx returns immediately."""
-    r = None
-    for i in range(tries):
-        r = fn()
-        if 200 <= r.status_code < 300 or r.status_code not in _RETRY_CODES or i == tries - 1:
-            return r
-        wait = base * (2 ** i) + random.random() * 0.4
-        sys.stderr.write(f"  [retry] {label} {r.status_code}; sleep {wait:.1f}s ({i+1}/{tries})\n")
-        time.sleep(wait)
-    return r
-
-REPO = Path(__file__).resolve().parent.parent
-PUB = REPO / "publish"
-REC_ROOT = PUB / "records"
-STATE_ROOT = PUB / "state"
-sys.path.insert(0, str(REPO)); sys.path.insert(0, str(REPO.parent / "kronos-toolkit"))
-os.environ.setdefault("PYTHONWARNINGS", "ignore")
-import warnings; warnings.filterwarnings("ignore")
-import kronos_ml as K
-
-TODAY = date.today().isoformat()
-VERSION = K.__version__
-ORCID = "0000-0003-0395-1752"
-AFFIL = "Kronos Fusion Energy"
-KODEX = "https://kronosfusionenergy.com/kodex"
-REPO_URL = "https://github.com/KronosFE/kronos-ml"
-TOOLKIT_URL = "https://github.com/KronosFE/kronos-toolkit"
-LICENSE = "Apache-2.0"
-
-DOI_REGISTER = "10.5281/zenodo.22645689"
-DOI_CGYRO = "10.5281/zenodo.22136279"
-DOI_AIQ = "10.5281/zenodo.21842371"
-
-KEYWORDS_BASE = ["fusion energy", "spherical tokamak", "D-3He", "AI/ML surrogate model",
-                 "uncertainty quantification", "digital twin", "Kronos Fusion Energy"]
-
-
-def built():
-    """The codes a publish run acts on: every BUILT code, unless KODEX_PUBLISH_ONLY
-    restricts it to an explicit allow-list (comma/space-separated code names).
-
-    The allow-list is how an operator deposits a deliberate SUBSET (e.g. only the
-    v0.2.0 additions) without touching the rest of the fleet — it does NOT change any
-    code's real status, so the package stays honest. Unset = all BUILT (default). A
-    named code that is not currently BUILT is a hard error, so a typo can never
-    silently narrow (or widen) the set.
-    """
-    names = sorted(n for n in K.list_surrogates() if K.get(n).status == "BUILT")
-    only = os.environ.get("KODEX_PUBLISH_ONLY", "").strip()
-    if only:
-        want = {c.strip().upper() for c in re.split(r"[,\s]+", only) if c.strip()}
-        unknown = want - set(names)
-        if unknown:
-            raise SystemExit(f"[STOP] KODEX_PUBLISH_ONLY names not in the BUILT set: "
-                             f"{sorted(unknown)} (BUILT: {names})")
-        names = [n for n in names if n in want]
-        sys.stderr.write(f"[scope] KODEX_PUBLISH_ONLY -> {len(names)} codes: {names}\n")
-    return names
-
-
-def physics_source(s):
-    """(relation, identifier, note) list tracing a code to its real physics source."""
-    p = (s.provenance or "").upper()
-    if "CGYRO" in p:
-        return [("isDerivedFrom", DOI_CGYRO, "CGYRO A1e nonlinear-kinetic turbulence map (mu=400)")]
-    if p == "REAL-ANCHOR":
-        return [("isDerivedFrom", "https://mastapp.site", "FAIR-MAST real-device data (UKAEA)")]
-    if s.name in ("KQUBIT", "KQROSS", "KSENSE", "KTENSOR"):
-        return [("isDerivedFrom", DOI_AIQ, "Kronos AI + Quantum deposit")]
-    if s.name in ("KBREED", "KFLUX"):
-        return [("references", DOI_REGISTER, "De-Risking Register neutronics gates")]
-    if s.name == "KISO":
-        return [("isDerivedFrom", "https://www-nds.iaea.org/fendl/", "FENDL-3.2 activation data (IAEA)"),
-                ("references", DOI_REGISTER, "De-Risking Register")]
-    return [("references", DOI_AIQ, "Kronos AI + Quantum corpus")]
-
-
-def _headline(name, b):
-    try:
-        from benchmarks.run_all import _headline as hl
-        return hl(name, b)
-    except Exception:
-        return (b or {}).get("note", "")
-
-
-def record_meta(name, b=None):
-    s = K.get(name); kn = name.lower()
-    if b is None:
-        b = s.benchmark()
-    page = f"{KODEX}/{kn}"
-    src = physics_source(s)
-    related = [{"relation": "isDocumentedBy", "identifier": page, "resource_type": "publication-other"},
-               {"relation": "isPartOf", "identifier": KODEX, "resource_type": "publication-other"},
-               {"relation": "isSupplementTo", "identifier": REPO_URL, "resource_type": "software"},
-               {"relation": "references", "identifier": DOI_REGISTER, "resource_type": "publication"},
-               {"relation": "isCompiledBy", "identifier": TOOLKIT_URL, "resource_type": "software"}]
-    for rel, ident, _ in src:
-        rtype = "dataset" if ident.startswith("10.") or "mast" in ident or "fendl" in ident else "other"
-        related.append({"relation": rel, "identifier": ident, "resource_type": rtype})
-    # dedupe by (relation, identifier), keeping first (e.g. register DOI appended by both
-    # the base list and physics_source for KBREED/KFLUX/KISO)
-    _seen, _ded = set(), []
-    for r in related:
-        k = (r["relation"], r["identifier"])
-        if k not in _seen:
-            _seen.add(k); _ded.append(r)
-    related = _ded
-    desc = (f"<p><strong>KODEX &mdash; {name}</strong> ({s.function}). {(s.note or '').strip()}</p>"
-            f"<p><strong>Benchmark:</strong> {_headline(name, b)}</p>"
-            f"<p>Part of KODEX, the Kronos Family of Codes &mdash; a benchmarked AI/ML fusion "
-            f"surrogate suite with calibrated uncertainty and an abstention gate "
-            f"(<code>predict(x) &rarr; (y, uncertainty, in_domain)</code>). Provenance: "
-            f"{'; '.join(f'{r} {i}' for r, i, _ in src)}. Home: <a href=\"{page}\">{page}</a> &middot; "
-            f"suite: <a href=\"{REPO_URL}\">{REPO_URL}</a>. Licensed under Apache-2.0. "
-            f"Honest card preserved verbatim.</p>")
-    # plaintext variant for venues whose description field does NOT render HTML (OSF)
-    desc_plain = html.unescape(re.sub(r"<[^>]+>", "", desc)).strip()
-    return {
-        "kname": name, "page": page,
-        "title": f"KODEX — {name}: {s.function}",
-        "version": VERSION, "publication_date": TODAY, "language": "eng",
-        "upload_type": "software",
-        "creators": [{"name": "Ford, P. I.", "orcid": ORCID, "affiliation": AFFIL}],
-        "license": {"id": LICENSE},
-        "keywords": KEYWORDS_BASE + [s.function, f"KODEX:{name}"],
-        "related_identifiers": related,
-        "description": desc,
-        "description_plain": desc_plain,
-        "notes": (f"Draft-first per-code deposit. Full package: {REPO_URL}. "
-                  f"Provenance chain in card.md + MANIFEST.sha256."),
-    }
-
-
-def _sha(p):
-    h = hashlib.sha256()
-    with open(p, "rb") as f:
-        for c in iter(lambda: f.read(1 << 16), b""):
-            h.update(c)
-    return h.hexdigest()
-
-
-def build_records():
-    REC_ROOT.mkdir(parents=True, exist_ok=True)
-    STATE_ROOT.mkdir(parents=True, exist_ok=True)
-    names = built()
-    for name in names:
-        d = REC_ROOT / name.lower()
-        if (d / "metadata.json").exists() and (d / "MANIFEST.sha256").exists():
-            continue                       # resume: already generated
-        s = K.get(name); kn = name.lower()
-        b = s.benchmark()                  # compute ONCE, reuse
-        d.mkdir(exist_ok=True)
-        # 1) source excerpt (the class), readable
-        try:
-            src_code = inspect.getsource(type(s))
-        except Exception:
-            src_code = f"# source not extractable for {name}\n"
-        (d / f"{kn}.py").write_text(
-            f'"""KODEX {name} — source excerpt (class). Full runnable package: {REPO_URL}"""\n\n'
-            + src_code)
-        # 2) benchmark
-        (d / "benchmark.json").write_text(json.dumps(b, default=str, indent=2) + "\n")
-        # 3) card
-        c = s.card()
-        (d / "card.md").write_text(
-            f"# KODEX {name} — card\n\n"
-            + "\n".join(f"- **{k}:** {v}" for k, v in c.items()) + "\n\n"
-            + f"Benchmark headline: {_headline(name, b)}\n")
-        # 4) per-code CITATION.cff
-        (d / "CITATION.cff").write_text("\n".join([
-            "cff-version: 1.2.0",
-            f"title: \"KODEX — {name}: {s.function} (Kronos Family of Codes)\"",
-            f"version: \"{VERSION}\"", f"date-released: \"{TODAY}\"",
-            f"license: {LICENSE}", f"url: \"{KODEX}/{kn}\"",
-            f"repository-code: \"{REPO_URL}\"", "type: software", "authors:",
-            "  - family-names: Ford", "    given-names: \"P. I.\"",
-            f"    orcid: \"https://orcid.org/{ORCID}\"", f"    affiliation: \"{AFFIL}\"",
-        ]) + "\n")
-        # 5) LICENSE
-        shutil.copyfile(REPO / "LICENSE", d / "LICENSE")
-        # 6) metadata
-        (d / "metadata.json").write_text(json.dumps(record_meta(name, b), indent=2) + "\n")
-        # 7) manifest
-        files = [p for p in sorted(d.iterdir()) if p.name != "MANIFEST.sha256"]
-        (d / "MANIFEST.sha256").write_text(
-            f"# KODEX {name} SHA-256 ({VERSION}, {TODAY})\n"
-            + "\n".join(f"{_sha(p)}  {p.name}" for p in files) + "\n")
-    (PUB / "_percode_summary.json").write_text(json.dumps(
-        {"version": VERSION, "date": TODAY, "n_records": len(names), "codes": names}, indent=2) + "\n")
-    return names
-
-
-def record_dir(kname):
-    return REC_ROOT / kname.lower()
-
-
-def attach_paths(kname):
-    d = record_dir(kname)
-    # metadata.json is included so the uploaded file set exactly equals the set the
-    # MANIFEST.sha256 hashes (sha256sum -c then verifies clean; -c skips the un-self-listed manifest)
-    order = [f"{kname.lower()}.py", "benchmark.json", "card.md",
-             "CITATION.cff", "LICENSE", "metadata.json", "MANIFEST.sha256"]
-    return [d / f for f in order if (d / f).exists()]
-
-
-def load_meta(kname):
-    return json.loads((record_dir(kname) / "metadata.json").read_text())
-
-
-def state_path(venue):
-    return STATE_ROOT / f"{venue}_drafts.json"
-
-
-def read_state(venue):
-    p = state_path(venue)
-    return json.loads(p.read_text()) if p.exists() else {}
-
-
-def write_state(venue, st):
-    STATE_ROOT.mkdir(parents=True, exist_ok=True)
-    state_path(venue).write_text(json.dumps(st, indent=2) + "\n")
-
-
-def require_env(var):
-    v = os.environ.get(var)
-    if not v:
-        raise SystemExit(f"[STOP] environment variable {var} is not set (see PUBLISH_RUNBOOK.md).")
-    return v
-
-
-if __name__ == "__main__":
-    names = build_records()
-    print(f"built {len(names)} per-code records under publish/records/:")
-    for n in names:
-        ap = attach_paths(n)
-        print(f"  {n.lower():9s} {len(ap)} files, meta title={load_meta(n)['title']!r}")

publish/_percode_summary.json

@@ -1,42 +0,0 @@
-{
-  "version": "0.2.0",
-  "date": "2026-09-11",
-  "n_records": 35,
-  "codes": [
-    "KAIROS",
-    "KBENCH",
-    "KBREED",
-    "KBURN",
-    "KDRIVE",
-    "KDYN",
-    "KECON",
-    "KEDGE",
-    "KEYE",
-    "KFLOW",
-    "KFLUX",
-    "KFORGE",
-    "KFUEL",
-    "KFUSE",
-    "KGATE",
-    "KGEN",
-    "KHALO",
-    "KHEAT",
-    "KISO",
-    "KLAW",
-    "KMAT",
-    "KOIL",
-    "KORE",
-    "KPATH",
-    "KPILOT",
-    "KQERN",
-    "KQOPT",
-    "KQROSS",
-    "KQUBIT",
-    "KRAD",
-    "KSEEK",
-    "KSENSE",
-    "KTENSOR",
-    "KWARD",
-    "KYRO"
-  ]
-}

publish/_scaffolding_summary.json

@@ -1,40 +0,0 @@
-{
-  "version": "0.1.0",
-  "date": "2026-09-10",
-  "built": [
-    "KAIROS",
-    "KBREED",
-    "KBURN",
-    "KDRIVE",
-    "KECON",
-    "KEYE",
-    "KFLOW",
-    "KFLUX",
-    "KFORGE",
-    "KFUEL",
-    "KFUSE",
-    "KGATE",
-    "KGEN",
-    "KHALO",
-    "KISO",
-    "KLAW",
-    "KMAT",
-    "KOIL",
-    "KORE",
-    "KPATH",
-    "KPILOT",
-    "KQROSS",
-    "KQUBIT",
-    "KSENSE",
-    "KWARD",
-    "KYRO"
-  ],
-  "n_built": 26,
-  "held": [
-    "KEDGE",
-    "KHEAT",
-    "KRAD",
-    "KTENSOR"
-  ],
-  "n_files_hashed": 39
-}

publish/dataverse_draft.py

@@ -1,105 +0,0 @@
-#!/usr/bin/env python
-"""Create 26 DRAFT Harvard Dataverse datasets (one per BUILT KODEX code) in the
-kronos-fusion-energy collection.
-
-DRAFT-FIRST: Dataverse datasets are created UNPUBLISHED. Never calls the publish
-action. Resume-safe via publish/state/dataverse_drafts.json (pid recorded the moment
-the dataset is created). Prints the API error body on failure so a 400 names its field.
-After review, run dataverse_publish_all.py --yes.
-
-    export DATAVERSE_TOKEN=...
-    export DATAVERSE_CONTACT_EMAIL=...     # shown PUBLICLY — use a public-safe address
-    # optional: DATAVERSE_COLLECTION=kronos-fusion-energy  DATAVERSE_BASE=https://dataverse.harvard.edu
-    python publish/dataverse_draft.py
-"""
-from __future__ import annotations
-import os, sys
-import requests
-from _percode import built, attach_paths, load_meta, read_state, write_state, require_env, ORCID
-
-BASE = os.environ.get("DATAVERSE_BASE", "https://dataverse.harvard.edu").rstrip("/")
-COLLECTION = os.environ.get("DATAVERSE_COLLECTION", "kronos-fusion-energy")
-
-
-def _prim(name, value, multiple=False, cls="primitive"):
-    return {"typeName": name, "multiple": multiple, "typeClass": cls, "value": value}
-
-
-def _dataset_json(m, contact_email):
-    author = {"authorName": _prim("authorName", "Ford, P. I."),
-              "authorAffiliation": _prim("authorAffiliation", "Kronos Fusion Energy"),
-              "authorIdentifierScheme": {"typeName": "authorIdentifierScheme", "multiple": False,
-                                         "typeClass": "controlledVocabulary", "value": "ORCID"},
-              "authorIdentifier": _prim("authorIdentifier", ORCID)}
-    contact = {"datasetContactName": _prim("datasetContactName", "Ford, P. I."),
-               "datasetContactAffiliation": _prim("datasetContactAffiliation", "Kronos Fusion Energy"),
-               "datasetContactEmail": _prim("datasetContactEmail", contact_email)}
-    desc = {"dsDescriptionValue": _prim("dsDescriptionValue", m["description"])}
-    kws = [{"keywordValue": _prim("keywordValue", k)} for k in m["keywords"]]
-    # only well-formed DOI publications (bare-URL entries live in the description instead)
-    pubs = []
-    for r in m["related_identifiers"]:
-        ident = r["identifier"]
-        if ident.startswith("10."):
-            pubs.append({"publicationIDType": {"typeName": "publicationIDType", "multiple": False,
-                                               "typeClass": "controlledVocabulary", "value": "doi"},
-                         "publicationIDNumber": _prim("publicationIDNumber", ident),
-                         "publicationURL": _prim("publicationURL", f"https://doi.org/{ident}")})
-    fields = [_prim("title", m["title"]),
-              _prim("author", [author], True, "compound"),
-              _prim("datasetContact", [contact], True, "compound"),
-              _prim("dsDescription", [desc], True, "compound"),
-              _prim("subject", ["Physics"], True, "controlledVocabulary"),
-              _prim("keyword", kws, True, "compound")]
-    if pubs:
-        fields.append(_prim("publication", pubs, True, "compound"))
-    # Harvard's license picker has no Apache-2.0, and a license-less dataset defaults to CC0.
-    # So set Custom Terms of Use = Apache-2.0 text (per f7's live run) to override the CC0 default.
-    apache_terms = ("Licensed under the Apache License, Version 2.0 "
-                    "(http://www.apache.org/licenses/LICENSE-2.0). The full license text is in the "
-                    "bundled LICENSE file; citation metadata in CITATION.cff.")
-    return {"datasetVersion": {"termsOfUse": apache_terms,
-                               "metadataBlocks": {"citation": {"fields": fields}}}}
-
-
-def main():
-    token = require_env("DATAVERSE_TOKEN")
-    contact = os.environ.get("DATAVERSE_CONTACT_EMAIL")
-    if not contact:
-        raise SystemExit("[STOP] set DATAVERSE_CONTACT_EMAIL (public on the record) first.")
-    h = {"X-Dataverse-key": token}
-    s = requests.Session()
-    state = read_state("dataverse")
-    names = built()
-    for i, name in enumerate(names, 1):
-        rec = state.get(name, {})
-        if rec.get("done"):
-            print(f"[dataverse] ({i}/{len(names)}) {name}: complete (skip)"); continue
-        m = load_meta(name)
-        pid = rec.get("pid")
-        if not pid:
-            r = s.post(f"{BASE}/api/dataverses/{COLLECTION}/datasets", headers=h,
-                       json=_dataset_json(m, contact))
-            if not r.ok:
-                print(f"[dataverse] {name}: create FAILED {r.status_code}: {r.text[:500]}")
-                return 1
-            pid = r.json()["data"].get("persistentId")
-            state[name] = {"pid": pid,
-                           "url": f"{BASE}/dataset.xhtml?persistentId={pid}&version=DRAFT"}
-            write_state("dataverse", state)
-        for path in attach_paths(name):
-            with open(path, "rb") as fh:
-                r = s.post(f"{BASE}/api/datasets/:persistentId/add", headers=h,
-                           params={"persistentId": pid}, files={"file": (path.name, fh)})
-            if not r.ok and "duplicate" not in r.text.lower() and "exists" not in r.text.lower():
-                print(f"[dataverse] {name}/{path.name}: add FAILED {r.status_code}: {r.text[:300]}")
-                return 1
-        state[name]["done"] = True
-        write_state("dataverse", state)
-        print(f"[dataverse] ({i}/{len(names)}) {name}: DRAFT {pid}")
-    print(f"\n[dataverse] {sum(1 for r in state.values() if r.get('done'))} drafts (NONE published). Then:")
-    print("            python publish/dataverse_publish_all.py --yes")
-
-
-if __name__ == "__main__":
-    sys.exit(main())

publish/dataverse_publish_all.py

@@ -1,59 +0,0 @@
-#!/usr/bin/env python
-"""Publish the 26 per-code Harvard Dataverse DRAFTS created by dataverse_draft.py.
-
-IRREVERSIBLE STEP. DRY RUN by default; publishes (major version) only with --yes,
-only the datasets recorded in publish/state/dataverse_drafts.json.
-
-    export DATAVERSE_TOKEN=...
-    python publish/dataverse_publish_all.py           # dry run
-    python publish/dataverse_publish_all.py --yes      # publish
-"""
-from __future__ import annotations
-import argparse, os, sys
-import requests
-from _percode import read_state, write_state, require_env
-
-BASE = os.environ.get("DATAVERSE_BASE", "https://dataverse.harvard.edu").rstrip("/")
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--yes", action="store_true")
-    args = ap.parse_args()
-    state = read_state("dataverse")
-    # records submitted for Harvard CURATOR review (review:true) are published by the
-    # curators on approval, NOT by a depositor :publish call (which errors on an In-Review
-    # dataset). Only ever direct-publish records that are NOT in the review queue.
-    in_review = {n: r for n, r in state.items() if r.get("review") and not r.get("published")}
-    pending = {n: r for n, r in state.items()
-               if r.get("pid") and not r.get("published") and not r.get("review")}
-    if in_review:
-        print(f"[dataverse] {len(in_review)} dataset(s) are in Harvard curator review — "
-              f"published on curator APPROVAL, not here. Skipping: {', '.join(sorted(in_review))}")
-    if not pending:
-        print("[dataverse] no directly-publishable drafts (all are curator-review or already "
-              "published). Nothing to do — await Harvard curators."); return
-    print(f"[dataverse] {len(pending)} NON-review draft(s) directly publishable on {BASE}:")
-    for n, r in pending.items():
-        print(f"    {n:9s} {r['pid']}")
-    if not args.yes:
-        print("\n[dataverse] DRY RUN — nothing published. Re-run with --yes.")
-        return
-    h = {"X-Dataverse-key": require_env("DATAVERSE_TOKEN")}
-    s = requests.Session()
-    ok = 0
-    for n, r in pending.items():
-        resp = s.post(f"{BASE}/api/datasets/:persistentId/actions/:publish",
-                      headers=h, params={"persistentId": r["pid"], "type": "major"})
-        if not resp.ok:                      # don't let one failure abort the batch
-            print(f"[dataverse] {n}: publish FAILED {resp.status_code}: {resp.text[:200]}")
-            continue
-        r["published"] = True
-        write_state("dataverse", state)
-        ok += 1
-        print(f"[dataverse] PUBLISHED {n}: {r['pid']}")
-    print(f"\n[dataverse] published {ok}/{len(pending)} non-review records.")
-
-
-if __name__ == "__main__":
-    sys.exit(main())

publish/figshare_draft.py

@@ -1,119 +0,0 @@
-#!/usr/bin/env python
-"""Create 26 DRAFT Figshare articles (one per BUILT KODEX code).
-
-DRAFT-FIRST: never calls /publish. Creates private articles, reserves DOIs (a
-reservation is not a publication), uploads each code's attach set via the multipart
-flow. Resume-safe via publish/state/figshare_drafts.json (article id recorded the
-moment it is created, so a mid-upload failure never orphans it). After review, run
-figshare_publish_all.py --yes.
-
-    export FIGSHARE_TOKEN=...
-    python publish/figshare_draft.py
-"""
-from __future__ import annotations
-import hashlib, sys
-import requests
-from _percode import built, attach_paths, load_meta, read_state, write_state, require_env
-
-API = "https://api.figshare.com/v2"
-
-
-def _md5(path):
-    h = hashlib.md5()
-    with open(path, "rb") as f:
-        for c in iter(lambda: f.read(1 << 16), b""):
-            h.update(c)
-    return h.hexdigest()
-
-
-def _refs(meta):
-    """Figshare 'references' must be valid URLs — DOIs -> https://doi.org/..., keep only
-    http(s), dedupe, preserve order."""
-    out, seen = [], set()
-    for r in meta["related_identifiers"]:
-        ident = r["identifier"].strip()
-        url = f"https://doi.org/{ident}" if ident.startswith("10.") else ident
-        if url.startswith("http") and url not in seen:
-            seen.add(url); out.append(url)
-    return out
-
-
-def _tags(meta):
-    """Figshare tags: each >= 3 chars; keep it modest."""
-    out, seen = [], set()
-    for k in meta["keywords"]:
-        k = k.strip()
-        if len(k) >= 3 and k.lower() not in seen:
-            seen.add(k.lower()); out.append(k)
-    return out[:10]
-
-
-def _existing_files(s, h, article_id):
-    try:
-        r = s.get(f"{API}/account/articles/{article_id}/files", headers=h)
-        return {f["name"] for f in r.json()} if r.ok else set()
-    except Exception:
-        return set()
-
-
-def _upload(s, h, article_id, path):
-    size = path.stat().st_size
-    r = s.post(f"{API}/account/articles/{article_id}/files", headers=h,
-               json={"name": path.name, "md5": _md5(path), "size": size}); r.raise_for_status()
-    file_url = r.json()["location"]
-    info = s.get(file_url, headers=h).json()
-    up = s.get(info["upload_url"], headers=h).json()
-    with open(path, "rb") as fh:
-        for part in up["parts"]:
-            fh.seek(part["startOffset"])
-            chunk = fh.read(part["endOffset"] - part["startOffset"] + 1)
-            s.put(f"{info['upload_url']}/{part['partNo']}", headers=h, data=chunk).raise_for_status()
-    s.post(file_url, headers=h).raise_for_status()
-
-
-def main():
-    token = require_env("FIGSHARE_TOKEN")
-    h = {"Authorization": f"token {token}"}
-    s = requests.Session()
-    state = read_state("figshare")
-    names = built()
-    for i, name in enumerate(names, 1):
-        rec = state.get(name, {})
-        if rec.get("done"):
-            print(f"[figshare] ({i}/{len(names)}) {name}: complete (skip)"); continue
-        m = load_meta(name)
-        aid = rec.get("id")
-        if not aid:
-            body = {"title": m["title"], "description": m["description"],
-                    "defined_type": "software", "tags": _tags(m), "references": _refs(m),
-                    # explicit author (ORCID is linked via the uploading Figshare account)
-                    "authors": [{"name": "Ford, P. I."}],
-                    # LEAF categories only — parent 29152 is not assignable (per f7's live run)
-                    "categories": [30202, 29173, 26836]}
-            r = s.post(f"{API}/account/articles", headers=h, json=body)
-            if not r.ok:
-                print(f"[figshare] {name}: create FAILED {r.status_code}: {r.text[:400]}")
-                print(f"           body.tags={body['tags']}")
-                print(f"           body.references={body['references']}")
-                return 1
-            aid = int(r.json()["location"].rstrip("/").split("/")[-1])
-            state[name] = {"id": aid, "url": f"https://figshare.com/account/articles/{aid}"}
-            write_state("figshare", state)
-            try:
-                s.post(f"{API}/account/articles/{aid}/reserve_doi", headers=h).raise_for_status()
-            except Exception:
-                pass
-        have = _existing_files(s, h, aid)
-        for path in attach_paths(name):
-            if path.name in have:
-                continue                      # already uploaded (resumed) -> idempotent
-            _upload(s, h, aid, path)
-        state[name]["done"] = True
-        write_state("figshare", state)
-        print(f"[figshare] ({i}/{len(names)}) {name}: DRAFT {aid}")
-    print(f"\n[figshare] {sum(1 for r in state.values() if r.get('done'))} drafts (NONE published). Then:")
-    print("           python publish/figshare_publish_all.py --yes")
-
-
-if __name__ == "__main__":
-    sys.exit(main())

publish/figshare_publish_all.py

@@ -1,47 +0,0 @@
-#!/usr/bin/env python
-"""Publish the 26 per-code Figshare DRAFTS created by figshare_draft.py.
-
-IRREVERSIBLE STEP. DRY RUN by default; publishes only with --yes, only the articles
-recorded in publish/state/figshare_drafts.json.
-
-    export FIGSHARE_TOKEN=...
-    python publish/figshare_publish_all.py           # dry run
-    python publish/figshare_publish_all.py --yes      # publish
-"""
-from __future__ import annotations
-import argparse, sys
-import requests
-from _percode import read_state, write_state, require_env
-
-API = "https://api.figshare.com/v2"
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--yes", action="store_true")
-    args = ap.parse_args()
-    state = read_state("figshare")
-    pending = {n: r for n, r in state.items() if r.get("id") and not r.get("published")}
-    if not pending:
-        print("[figshare] no unpublished drafts in state (run figshare_draft.py first)."); return
-    print(f"[figshare] {len(pending)} draft(s) to publish:")
-    for n, r in pending.items():
-        print(f"    {n:9s} id={r['id']}")
-    if not args.yes:
-        print("\n[figshare] DRY RUN — nothing published. Re-run with --yes.")
-        return
-    h = {"Authorization": f"token {require_env('FIGSHARE_TOKEN')}"}
-    s = requests.Session()
-    for n, r in pending.items():
-        resp = s.post(f"{API}/account/articles/{r['id']}/publish", headers=h)
-        resp.raise_for_status()
-        loc = resp.json().get("location", "")
-        r["published"] = True
-        r["public_url"] = loc
-        write_state("figshare", state)
-        print(f"[figshare] PUBLISHED {n}: {loc}")
-    print(f"\n[figshare] published {len(pending)} records.")
-
-
-if __name__ == "__main__":
-    sys.exit(main())

publish/ia_upload_all.py

@@ -1,47 +0,0 @@
-#!/usr/bin/env python
-"""Upload the 26 per-code KODEX records to the Internet Archive (one item per code).
-
-NOTE: Internet Archive items become PUBLIC on upload — there is no private-draft state —
-so this IS the publish step for IA. DRY RUN by default; uploads only with --yes.
-Requires the `ia` CLI configured (`ia configure` with your S3 keys) once.
-
-    python publish/ia_upload_all.py            # dry run (lists items + files)
-    python publish/ia_upload_all.py --yes       # upload (public)
-"""
-from __future__ import annotations
-import argparse, subprocess, sys
-from _percode import built, attach_paths, load_meta, VERSION
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--yes", action="store_true")
-    args = ap.parse_args()
-    names = built()
-    print(f"[ia] {len(names)} items to upload (identifier = kronos-ml-kodex-<code>-v{VERSION}):")
-    plans = []
-    for name in names:
-        m = load_meta(name)
-        ident = f"kronos-ml-kodex-{name.lower()}-v{VERSION}"
-        files = [str(p) for p in attach_paths(name)]
-        plans.append((ident, m, files))
-        print(f"    {ident}  ({len(files)} files)")
-    if not args.yes:
-        print("\n[ia] DRY RUN — nothing uploaded. Re-run with --yes (items go PUBLIC on upload).")
-        return
-    for ident, m, files in plans:
-        cmd = ["ia", "upload", ident, *files,
-               f"--metadata=title:{m['title']}",
-               "--metadata=creator:Ford, P. I.",
-               "--metadata=licenseurl:https://spdx.org/licenses/Apache-2.0",
-               f"--metadata=external-identifier:{m['page']}",
-               "--metadata=subject:fusion; spherical tokamak; AI/ML surrogate; Kronos Fusion Energy"]
-        r = subprocess.run(cmd)
-        if r.returncode != 0:
-            print(f"[ia] FAILED {ident} (rc={r.returncode})"); return r.returncode
-        print(f"[ia] uploaded https://archive.org/details/{ident}")
-    print(f"\n[ia] uploaded {len(plans)} items.")
-
-
-if __name__ == "__main__":
-    sys.exit(main())

publish/kronos-ml-v0.1.0-source.zip

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

publish/osf_draft.py

@@ -1,71 +0,0 @@
-#!/usr/bin/env python
-"""Create 26 PRIVATE OSF projects (one per BUILT KODEX code).
-
-DRAFT-FIRST: each project is created private (public=false) and never made public here.
-Resume-safe via publish/state/osf_drafts.json. Throttled + retried against OSF's
-rate-limiting (403/429). After review, run osf_publish_all.py --yes.
-
-    export OSF_TOKEN=...
-    python publish/osf_draft.py
-"""
-from __future__ import annotations
-import sys, time
-import requests
-from _percode import (built, attach_paths, load_meta, read_state, write_state,
-                      require_env, http_retry)
-
-API = "https://api.osf.io/v2"
-WB = "https://files.osf.io/v1"
-PACE_FILE = 0.6      # seconds between file uploads
-PACE_PROJECT = 1.2   # seconds between projects
-
-
-def main():
-    token = require_env("OSF_TOKEN")
-    h = {"Authorization": f"Bearer {token}"}
-    hj = {**h, "Content-Type": "application/vnd.api+json"}
-    s = requests.Session()
-    state = read_state("osf")
-    names = built()
-    for i, name in enumerate(names, 1):
-        rec = state.get(name, {})
-        node = rec.get("id")
-        if rec.get("done"):
-            print(f"[osf] ({i}/{len(names)}) {name}: complete (skip)"); continue
-        m = load_meta(name)
-        if not node:            # create the project (retry rate-limits)
-            payload = {"data": {"type": "nodes", "attributes": {
-                "title": m["title"], "category": "software",
-                # OSF renders the description as PLAIN TEXT (no HTML) -> use the stripped variant
-                "description": m.get("description_plain", m["description"]),
-                "public": False, "tags": m["keywords"][:25]}}}
-            r = http_retry(lambda: s.post(f"{API}/nodes/", headers=hj, json=payload),
-                           label=f"osf-create {name}")
-            if not r.ok:
-                print(f"[osf] {name}: create FAILED {r.status_code}: {r.text[:300]}"); return 1
-            node = r.json()["data"]["id"]
-            state[name] = {"id": node, "url": f"https://osf.io/{node}/"}
-            write_state("osf", state)
-            time.sleep(PACE_PROJECT)
-        # upload files (throttled; 409 = already there = fine)
-        for path in attach_paths(name):
-            def _put():
-                with open(path, "rb") as fh:
-                    return s.put(f"{WB}/resources/{node}/providers/osfstorage/", headers=h,
-                                 params={"kind": "file", "name": path.name}, data=fh)
-            r = http_retry(_put, label=f"osf-upload {name}/{path.name}")
-            if r.status_code == 409:
-                pass  # file already exists (resumed) -> treat as done
-            elif not r.ok:
-                print(f"[osf] {name}/{path.name}: upload FAILED {r.status_code}: {r.text[:200]}")
-                return 1
-            time.sleep(PACE_FILE)
-        state[name]["done"] = True
-        write_state("osf", state)
-        print(f"[osf] ({i}/{len(names)}) {name}: PRIVATE {node} ({len(attach_paths(name))} files)")
-    print(f"\n[osf] {sum(1 for r in state.values() if r.get('done'))} private projects (NONE public). Then:")
-    print("      python publish/osf_publish_all.py --yes")
-
-
-if __name__ == "__main__":
-    sys.exit(main())

publish/osf_publish_all.py

@@ -1,47 +0,0 @@
-#!/usr/bin/env python
-"""Make the 26 per-code OSF projects PUBLIC (created private by osf_draft.py).
-
-IRREVERSIBLE STEP. DRY RUN by default; flips projects to public only with --yes,
-and only those recorded in publish/state/osf_drafts.json.
-
-    export OSF_TOKEN=...
-    python publish/osf_publish_all.py           # dry run
-    python publish/osf_publish_all.py --yes      # make public
-"""
-from __future__ import annotations
-import argparse, sys
-import requests
-from _percode import read_state, write_state, require_env
-
-API = "https://api.osf.io/v2"
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--yes", action="store_true")
-    args = ap.parse_args()
-    state = read_state("osf")
-    pending = {n: r for n, r in state.items() if r.get("id") and not r.get("public")}
-    if not pending:
-        print("[osf] no private projects in state (run osf_draft.py first)."); return
-    print(f"[osf] {len(pending)} project(s) to make public:")
-    for n, r in pending.items():
-        print(f"    {n:9s} {r.get('url','')}")
-    if not args.yes:
-        print("\n[osf] DRY RUN — nothing made public. Re-run with --yes.")
-        return
-    hj = {"Authorization": f"Bearer {require_env('OSF_TOKEN')}",
-          "Content-Type": "application/vnd.api+json"}
-    s = requests.Session()
-    for n, r in pending.items():
-        payload = {"data": {"type": "nodes", "id": r["id"], "attributes": {"public": True}}}
-        resp = s.patch(f"{API}/nodes/{r['id']}/", headers=hj, json=payload)
-        resp.raise_for_status()
-        r["public"] = True
-        write_state("osf", state)
-        print(f"[osf] PUBLIC {n}: {r.get('url')}")
-    print(f"\n[osf] made {len(pending)} projects public.")
-
-
-if __name__ == "__main__":
-    sys.exit(main())

publish/records/kairos/CITATION.cff

@@ -1,13 +0,0 @@
-cff-version: 1.2.0
-title: "KODEX — KAIROS: CONTROL (Kronos Family of Codes)"
-version: "0.2.0"
-date-released: "2026-09-11"
-license: Apache-2.0
-url: "https://kronosfusionenergy.com/kodex/kairos"
-repository-code: "https://github.com/KronosFE/kronos-ml"
-type: software
-authors:
-  - family-names: Ford
-    given-names: "P. I."
-    orcid: "https://orcid.org/0000-0003-0395-1752"
-    affiliation: "Kronos Fusion Energy"

publish/records/kairos/LICENSE

@@ -1,189 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but not
-      limited to compiled object code, generated documentation, and
-      conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work.
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including the
-      original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or Derivative
-          Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2026 Kronos Fusion Energy
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

publish/records/kairos/MANIFEST.sha256

@@ -1,7 +0,0 @@
-# KODEX KAIROS SHA-256 (0.2.0, 2026-09-11)
-d334149c67e6fab06da1157e5cd47129d2bf4e738754afeb20176b6bacb89d54  CITATION.cff
-ae87ebecd1f321a19799e21f6fe25e4a74261f16c91e6cb6cc248e6197dcf838  LICENSE
-4519abc8cba84d5ba68e5e0cc5faef0dac4094a970a6a4a39f993abcfc4931be  benchmark.json
-f99514c0fb9ad18571bfafcdd8579f51323285a65c66f90140d91cb781a58243  card.md
-203323e21eb15172090486e0fdde9367a3c13b7e1fb3d66d5b280108b7f15f32  kairos.py
-85ff663bac08f45a66d216dbbed1bf62143b7fa0943192c6f6e91f4ca3cf4c47  metadata.json

publish/records/kairos/benchmark.json

@@ -1,19 +0,0 @@
-{
-  "member": "KAIROS",
-  "live_tracking_rms_frac": 0.0461,
-  "live_expB_model_failure": {
-    "adversaries": [
-      "drift",
-      "edge_seeker",
-      "nan_garbage"
-    ],
-    "steps": 150000,
-    "escapes": 0,
-    "catch_rate": 1.0
-  },
-  "live_mpc_step_us": 96.1,
-  "sourced": {
-    "file": "track5_control/clamp_activation_stats.csv",
-    "headline": "0 escapes / 150k steps / 3000 injected (AC-25); tracking <5%"
-  }
-}

publish/records/kairos/card.md

@@ -1,13 +0,0 @@
-# KODEX KAIROS — card
-
-- **name:** KAIROS
-- **function:** CONTROL
-- **status:** BUILT
-- **phase:** 1
-- **provenance:** TWIN
-- **retired_by:** validated real-time plant controller (device-in-the-loop)
-- **gates:** ['AC-24', 'AC-25']
-- **note:** real-time closed-loop MPC control (analytic finite-horizon QP); supplies the model-free L4 clamp that KGATE enforces
-- **available:** True
-
-Benchmark headline: MPC tracking 0.0461 (<5%); Exp-B **0 escapes / 150,000**; 96.1 µs/step

publish/records/kairos/kairos.py

@@ -1,57 +0,0 @@
-"""KODEX KAIROS — source excerpt (class). Full runnable package: https://github.com/KronosFE/kronos-ml"""
-
-@register
-class KAIROS(Surrogate):
-    name = "KAIROS"; function = "CONTROL"; phase = 1; status = "BUILT"
-    provenance = "TWIN"
-    retired_by = "validated real-time plant controller (device-in-the-loop)"
-    real_codes = ("receding-horizon MPC",)
-    gates = ("AC-24", "AC-25")
-    note = ("real-time closed-loop MPC control (analytic finite-horizon QP); "
-            "supplies the model-free L4 clamp that KGATE enforces")
-
-    def _predict(self, x):
-        """x = (state6, ref6) -> next command from the MPC, clamped by KGATE."""
-        state, ref = x
-        u = _mpc(state, ref)
-        safe, ok = get("KGATE").clamp(u)
-        in_dom = bool(np.allclose(safe, u, atol=1e-6))
-        return Prediction(safe, None, in_dom,
-                          note="MPC step, clamped" if not in_dom else "MPC step, in envelope")
-
-    def benchmark(self):
-        rng = np.random.default_rng(uq.SEED)
-        clamp = get("KGATE").clamp
-        # (1) closed-loop tracking: drive from a start state to a setpoint
-        ref = np.array([2.2, 0.3, 3.0, 1.0, 0.2, 30.0])
-        x = np.array([2.0, 0.0, 2.0, 0.5, 0.1, 20.0])
-        for _ in range(200):
-            safe, _ = clamp(_mpc(x, ref)); x = _plant_step(x, safe, rng)
-        rng_scale = np.array([1, 1, 4.2, 3, 0.4, 47.21])
-        track_rms = float(np.sqrt(np.mean(((x - ref) / rng_scale) ** 2)))
-        # (2) Exp-B: broken controllers emit unsafe commands; clamp must catch all
-        from .spine import _LO, _HI
-        adversaries = {
-            "drift": lambda: _HI * (1 + 0.5 * rng.random(6)),
-            "edge_seeker": lambda: _HI + 5,
-            "nan_garbage": lambda: np.where(rng.random(6) < 0.3, np.nan, _HI * 3),
-        }
-        escapes = 0; steps = 0
-        for _, gen in adversaries.items():
-            for _ in range(50_000):
-                safe, _ = clamp(gen()); steps += 1
-                if not (np.all(safe >= _LO - 1e-9) and np.all(safe <= _HI + 1e-9)):
-                    escapes += 1
-        # (3) real latency of an MPC step + clamp
-        t0 = time.perf_counter()
-        for _ in range(2000):
-            clamp(_mpc(x, ref))
-        us = (time.perf_counter() - t0) / 2000 * 1e6
-        return {"member": self.name,
-                "live_tracking_rms_frac": round(track_rms, 4),
-                "live_expB_model_failure": {"adversaries": list(adversaries),
-                                            "steps": steps, "escapes": escapes,
-                                            "catch_rate": 1.0 - escapes / steps},
-                "live_mpc_step_us": round(us, 1),
-                "sourced": {"file": "track5_control/clamp_activation_stats.csv",
-                            "headline": "0 escapes / 150k steps / 3000 injected (AC-25); tracking <5%"}}

publish/records/kairos/metadata.json

@@ -1,65 +0,0 @@
-{
-  "kname": "KAIROS",
-  "page": "https://kronosfusionenergy.com/kodex/kairos",
-  "title": "KODEX \u2014 KAIROS: CONTROL",
-  "version": "0.2.0",
-  "publication_date": "2026-09-11",
-  "language": "eng",
-  "upload_type": "software",
-  "creators": [
-    {
-      "name": "Ford, P. I.",
-      "orcid": "0000-0003-0395-1752",
-      "affiliation": "Kronos Fusion Energy"
-    }
-  ],
-  "license": {
-    "id": "Apache-2.0"
-  },
-  "keywords": [
-    "fusion energy",
-    "spherical tokamak",
-    "D-3He",
-    "AI/ML surrogate model",
-    "uncertainty quantification",
-    "digital twin",
-    "Kronos Fusion Energy",
-    "CONTROL",
-    "KODEX:KAIROS"
-  ],
-  "related_identifiers": [
-    {
-      "relation": "isDocumentedBy",
-      "identifier": "https://kronosfusionenergy.com/kodex/kairos",
-      "resource_type": "publication-other"
-    },
-    {
-      "relation": "isPartOf",
-      "identifier": "https://kronosfusionenergy.com/kodex",
-      "resource_type": "publication-other"
-    },
-    {
-      "relation": "isSupplementTo",
-      "identifier": "https://github.com/KronosFE/kronos-ml",
-      "resource_type": "software"
-    },
-    {
-      "relation": "references",
-      "identifier": "10.5281/zenodo.22645689",
-      "resource_type": "publication"
-    },
-    {
-      "relation": "isCompiledBy",
-      "identifier": "https://github.com/KronosFE/kronos-toolkit",
-      "resource_type": "software"
-    },
-    {
-      "relation": "references",
-      "identifier": "10.5281/zenodo.21842371",
-      "resource_type": "dataset"
-    }
-  ],
-  "description": "<p><strong>KODEX &mdash; KAIROS</strong> (CONTROL). real-time closed-loop MPC control (analytic finite-horizon QP); supplies the model-free L4 clamp that KGATE enforces</p><p><strong>Benchmark:</strong> MPC tracking 0.0461 (<5%); Exp-B **0 escapes / 150,000**; 96.1 \u00b5s/step</p><p>Part of KODEX, the Kronos Family of Codes &mdash; a benchmarked AI/ML fusion surrogate suite with calibrated uncertainty and an abstention gate (<code>predict(x) &rarr; (y, uncertainty, in_domain)</code>). Provenance: references 10.5281/zenodo.21842371. Home: <a href=\"https://kronosfusionenergy.com/kodex/kairos\">https://kronosfusionenergy.com/kodex/kairos</a> &middot; suite: <a href=\"https://github.com/KronosFE/kronos-ml\">https://github.com/KronosFE/kronos-ml</a>. Licensed under Apache-2.0. Honest card preserved verbatim.</p>",
-  "description_plain": "KODEX \u2014 KAIROS (CONTROL). real-time closed-loop MPC control (analytic finite-horizon QP); supplies the model-free L4 clamp that KGATE enforcesBenchmark: MPC tracking 0.0461 (Part of KODEX, the Kronos Family of Codes \u2014 a benchmarked AI/ML fusion surrogate suite with calibrated uncertainty and an abstention gate (predict(x) \u2192 (y, uncertainty, in_domain)). Provenance: references 10.5281/zenodo.21842371. Home: https://kronosfusionenergy.com/kodex/kairos \u00b7 suite: https://github.com/KronosFE/kronos-ml. Licensed under Apache-2.0. Honest card preserved verbatim.",
-  "notes": "Draft-first per-code deposit. Full package (all 26 codes): https://github.com/KronosFE/kronos-ml. Provenance chain in card.md + MANIFEST.sha256."
-}

publish/records/kbench/CITATION.cff

@@ -1,13 +0,0 @@
-cff-version: 1.2.0
-title: "KODEX — KBENCH: BENCHMARK (Kronos Family of Codes)"
-version: "0.2.0"
-date-released: "2026-09-11"
-license: Apache-2.0
-url: "https://kronosfusionenergy.com/kodex/kbench"
-repository-code: "https://github.com/KronosFE/kronos-ml"
-type: software
-authors:
-  - family-names: Ford
-    given-names: "P. I."
-    orcid: "https://orcid.org/0000-0003-0395-1752"
-    affiliation: "Kronos Fusion Energy"

publish/records/kbench/LICENSE

@@ -1,189 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but not
-      limited to compiled object code, generated documentation, and
-      conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work.
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including the
-      original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or Derivative
-          Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright 2026 Kronos Fusion Energy
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

publish/records/kbench/MANIFEST.sha256

@@ -1,7 +0,0 @@
-# KODEX KBENCH SHA-256 (0.2.0, 2026-09-11)
-cecfe7657f26a4b4af96f4257070e8769c4c9266748d8717f4ceeb3fbba00e83  CITATION.cff
-ae87ebecd1f321a19799e21f6fe25e4a74261f16c91e6cb6cc248e6197dcf838  LICENSE
-1f532ca6a582bc0e639f3490dc421c799f583766a8639863078d00ff3ef66f75  benchmark.json
-65f7c48c499563e291bf9230ac6098dcee186eaf437e97b43b41a640638fa972  card.md
-4d0e21b1012d27a9f9a2bb6cccb937530a8efe1ed02b6b9d5cc569ac8ad42c91  kbench.py
-e62bf7f72ba3ffda7478ade5c404e054bb0e77d9a42be30352ef1952673934a4  metadata.json

publish/records/kbench/benchmark.json

@@ -1,44 +0,0 @@
-{
-  "member": "KBENCH",
-  "live_benchmark_suite": {
-    "n_tasks": 3,
-    "tasks": {
-      "cgyro-turbulence-flux": {
-        "inputs": [
-          "a_LT",
-          "shear"
-        ],
-        "target": "log10 Q_tot (regression) + turbulent/quiet (classification)",
-        "n_samples": 16,
-        "metric": "R2 (regression) / leave-one-out accuracy (classification)",
-        "loader": "kronos_ml.data.cgyro_flux_map_final()",
-        "baseline_code": "KYRO",
-        "baseline_score": "R2 ~0.86, turbulent/quiet 16/16",
-        "note": "real CGYRO A1e saturated-flux (mu=400 representative)"
-      },
-      "mast-disruption": {
-        "inputs": "physics features (Ip family + EFIT + n=1 Mirnov / P_rad)",
-        "target": "disruptive (binary)",
-        "n_samples": 591,
-        "metric": "ROC-AUC (+ independent-precursor AUC)",
-        "loader": "kronos_ml.data.kward_real()",
-        "baseline_code": "KWARD",
-        "baseline_score": "AUC ~0.98, independent-precursor 0.975",
-        "note": "real MAST shots (FAIR-MAST); labels are heuristic Ip-quench"
-      },
-      "cgyro-rom-compressibility": {
-        "inputs": "flux-database matrix (points x [inputs, fluxes])",
-        "target": "rel-L2 reconstruction error vs retained bond dimension",
-        "n_samples": 16,
-        "metric": "rel-L2 vs rank",
-        "loader": "kronos_ml.data.cgyro_flux_map_final()",
-        "baseline_code": "KTENSOR",
-        "baseline_score": "effective rank 2.93/4 (not strongly low-rank)",
-        "note": "honest ROM characterization"
-      }
-    },
-    "how_to_use": "load via each task's loader, use the fixed reproducible split, report the metric, and try to beat the named KODEX baseline_code",
-    "verdict": "3 open, citable fusion-ML tasks (CGYRO turbulence, MAST disruption, flux ROM) with real on-disk data + reproducible KODEX baselines \u2014 a community leaderboard starting point, not a private result"
-  },
-  "caveat": "small by mainstream-ML standards (CGYRO = 16 pts); honest pilot fusion-ML benchmarks"
-}

publish/records/kbench/card.md

@@ -1,13 +0,0 @@
-# KODEX KBENCH — card
-
-- **name:** KBENCH
-- **function:** BENCHMARK
-- **status:** BUILT
-- **phase:** 3
-- **provenance:** n/a
-- **retired_by:** community-standard fusion-ML benchmarks
-- **gates:** []
-- **note:** open, citable ML benchmark suite for fusion — real CGYRO turbulence + MAST disruption tasks with fixed splits, metrics and KODEX baselines to beat. Bring your own model; move the community forward
-- **available:** True
-
-Benchmark headline: open fusion-ML benchmark suite: **3 citable tasks** (CGYRO turbulence, MAST disruption, flux ROM) with real data + KODEX baselines

publish/records/kbench/kbench.py

@@ -1,54 +0,0 @@
-"""KODEX KBENCH — source excerpt (class). Full runnable package: https://github.com/KronosFE/kronos-ml"""
-
-@register
-class KBENCH(Surrogate):
-    name = "KBENCH"; function = "BENCHMARK"; phase = 3; status = "BUILT"
-    provenance = "n/a"
-    retired_by = "community-standard fusion-ML benchmarks"
-    real_codes = ("open ML benchmark suite",)
-    gates = ()
-    note = ("open, citable ML benchmark suite for fusion — real CGYRO turbulence + MAST "
-            "disruption tasks with fixed splits, metrics and KODEX baselines to beat. Bring "
-            "your own model; move the community forward")
-
-    def tasks(self):
-        return {
-            "cgyro-turbulence-flux": {
-                "inputs": ["a_LT", "shear"],
-                "target": "log10 Q_tot (regression) + turbulent/quiet (classification)",
-                "n_samples": 16, "metric": "R2 (regression) / leave-one-out accuracy (classification)",
-                "loader": "kronos_ml.data.cgyro_flux_map_final()",
-                "baseline_code": "KYRO", "baseline_score": "R2 ~0.86, turbulent/quiet 16/16",
-                "note": "real CGYRO A1e saturated-flux (mu=400 representative)"},
-            "mast-disruption": {
-                "inputs": "physics features (Ip family + EFIT + n=1 Mirnov / P_rad)",
-                "target": "disruptive (binary)",
-                "n_samples": 591, "metric": "ROC-AUC (+ independent-precursor AUC)",
-                "loader": "kronos_ml.data.kward_real()",
-                "baseline_code": "KWARD", "baseline_score": "AUC ~0.98, independent-precursor 0.975",
-                "note": "real MAST shots (FAIR-MAST); labels are heuristic Ip-quench"},
-            "cgyro-rom-compressibility": {
-                "inputs": "flux-database matrix (points x [inputs, fluxes])",
-                "target": "rel-L2 reconstruction error vs retained bond dimension",
-                "n_samples": 16, "metric": "rel-L2 vs rank",
-                "loader": "kronos_ml.data.cgyro_flux_map_final()",
-                "baseline_code": "KTENSOR", "baseline_score": "effective rank 2.93/4 (not strongly low-rank)",
-                "note": "honest ROM characterization"},
-        }
-
-    def _predict(self, x):
-        t = self.tasks()
-        key = x if isinstance(x, str) and x in t else next(iter(t))
-        return Prediction(t[key], None, True, note=f"fusion-ML benchmark task spec: {key}")
-
-    def benchmark(self):
-        t = self.tasks()
-        return {"member": self.name,
-                "live_benchmark_suite": {
-                    "n_tasks": len(t), "tasks": t,
-                    "how_to_use": ("load via each task's loader, use the fixed reproducible split, report "
-                                   "the metric, and try to beat the named KODEX baseline_code"),
-                    "verdict": ("3 open, citable fusion-ML tasks (CGYRO turbulence, MAST disruption, flux "
-                                "ROM) with real on-disk data + reproducible KODEX baselines — a community "
-                                "leaderboard starting point, not a private result")},
-                "caveat": "small by mainstream-ML standards (CGYRO = 16 pts); honest pilot fusion-ML benchmarks"}

publish/records/kbench/metadata.json

@@ -1,65 +0,0 @@
-{
-  "kname": "KBENCH",
-  "page": "https://kronosfusionenergy.com/kodex/kbench",
-  "title": "KODEX \u2014 KBENCH: BENCHMARK",
-  "version": "0.2.0",
-  "publication_date": "2026-09-11",
-  "language": "eng",
-  "upload_type": "software",
-  "creators": [
-    {
-      "name": "Ford, P. I.",
-      "orcid": "0000-0003-0395-1752",
-      "affiliation": "Kronos Fusion Energy"
-    }
-  ],
-  "license": {
-    "id": "Apache-2.0"
-  },
-  "keywords": [
-    "fusion energy",
-    "spherical tokamak",
-    "D-3He",
-    "AI/ML surrogate model",
-    "uncertainty quantification",
-    "digital twin",
-    "Kronos Fusion Energy",
-    "BENCHMARK",
-    "KODEX:KBENCH"
-  ],
-  "related_identifiers": [
-    {
-      "relation": "isDocumentedBy",
-      "identifier": "https://kronosfusionenergy.com/kodex/kbench",
-      "resource_type": "publication-other"
-    },
-    {
-      "relation": "isPartOf",
-      "identifier": "https://kronosfusionenergy.com/kodex",
-      "resource_type": "publication-other"
-    },
-    {
-      "relation": "isSupplementTo",
-      "identifier": "https://github.com/KronosFE/kronos-ml",
-      "resource_type": "software"
-    },
-    {
-      "relation": "references",
-      "identifier": "10.5281/zenodo.22645689",
-      "resource_type": "publication"
-    },
-    {
-      "relation": "isCompiledBy",
-      "identifier": "https://github.com/KronosFE/kronos-toolkit",
-      "resource_type": "software"
-    },
-    {
-      "relation": "references",
-      "identifier": "10.5281/zenodo.21842371",
-      "resource_type": "dataset"
-    }
-  ],
-  "description": "<p><strong>KODEX &mdash; KBENCH</strong> (BENCHMARK). open, citable ML benchmark suite for fusion \u2014 real CGYRO turbulence + MAST disruption tasks with fixed splits, metrics and KODEX baselines to beat. Bring your own model; move the community forward</p><p><strong>Benchmark:</strong> open fusion-ML benchmark suite: **3 citable tasks** (CGYRO turbulence, MAST disruption, flux ROM) with real data + KODEX baselines</p><p>Part of KODEX, the Kronos Family of Codes &mdash; a benchmarked AI/ML fusion surrogate suite with calibrated uncertainty and an abstention gate (<code>predict(x) &rarr; (y, uncertainty, in_domain)</code>). Provenance: references 10.5281/zenodo.21842371. Home: <a href=\"https://kronosfusionenergy.com/kodex/kbench\">https://kronosfusionenergy.com/kodex/kbench</a> &middot; suite: <a href=\"https://github.com/KronosFE/kronos-ml\">https://github.com/KronosFE/kronos-ml</a>. Licensed under Apache-2.0. Honest card preserved verbatim.</p>",
-  "description_plain": "KODEX \u2014 KBENCH (BENCHMARK). open, citable ML benchmark suite for fusion \u2014 real CGYRO turbulence + MAST disruption tasks with fixed splits, metrics and KODEX baselines to beat. Bring your own model; move the community forwardBenchmark: open fusion-ML benchmark suite: **3 citable tasks** (CGYRO turbulence, MAST disruption, flux ROM) with real data + KODEX baselinesPart of KODEX, the Kronos Family of Codes \u2014 a benchmarked AI/ML fusion surrogate suite with calibrated uncertainty and an abstention gate (predict(x) \u2192 (y, uncertainty, in_domain)). Provenance: references 10.5281/zenodo.21842371. Home: https://kronosfusionenergy.com/kodex/kbench \u00b7 suite: https://github.com/KronosFE/kronos-ml. Licensed under Apache-2.0. Honest card preserved verbatim.",
-  "notes": "Draft-first per-code deposit. Full package: https://github.com/KronosFE/kronos-ml. Provenance chain in card.md + MANIFEST.sha256."
-}

publish/records/kbreed/CITATION.cff

@@ -1,13 +0,0 @@
-cff-version: 1.2.0
-title: "KODEX — KBREED: breeder (Kronos Family of Codes)"
-version: "0.2.0"
-date-released: "2026-09-11"
-license: Apache-2.0
-url: "https://kronosfusionenergy.com/kodex/kbreed"
-repository-code: "https://github.com/KronosFE/kronos-ml"
-type: software
-authors:
-  - family-names: Ford
-    given-names: "P. I."
-    orcid: "https://orcid.org/0000-0003-0395-1752"
-    affiliation: "Kronos Fusion Energy"