Upload 88 files

README.md

@@ -1,13 +1,168 @@
 ---
-title: ModuleMind
-emoji: 🌖
-colorFrom: red
-colorTo: yellow
+title: "Quazim0t0's 🍄 Thousand Token Wood Entry"
+emoji: 🍄
+colorFrom: green
+colorTo: indigo
 sdk: gradio
-sdk_version: 6.16.0
-python_version: '3.13'
+sdk_version: 6.15.2
 app_file: app.py
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# ⚔️ Modular Mind: Boss Fight
+
+A mini **Dark-Souls-style** duel where the boss is controlled by a **Modular Mind** —
+a handful of tiny neural *specialists* that communicate through a **shared latent**
+(a `RecursiveLink` bridge) and a *coordinator* that reads the latent to choose the
+boss's next move. **The brain was trained by self-play reinforcement learning** — its
+tactics emerged from playing thousands of duels, nothing is scripted.
+
+You play the **Fire Knight**. Defeat the **Demon Slime**.
+
+## How the Modular Mind works
+
+This is the [ModularMind-on-V2](https://github.com/your-username/ModularMind) concept at *specialist scale*: instead of one
+monolithic policy, six small networks each handle one concern and talk to each other
+through a latent channel.
+
+```
+ game state ─▶ ┌──────────────┐   each specialist emits a latent
+               │ Aggressor    │──┐  (LatentProjection) and, if it OWNS
+               │ Stalker      │──┤   an action, a "drive" for that action
+               │ Survivor     │──┤
+               │ Baiter       │──┤        ┌───────────────┐      ┌─────────────┐
+               │ Punisher (M) │──┼─ sum ─▶│ RecursiveLink │─────▶│ Coordinator │─▶ action
+               │ Enrage   (M) │──┘        │ ReGLU+residual│ shared│  read-out   │
+               └──────────────┘           └───────────────┘ latent└─────────────┘
+```
+
+- **Four action-owning specialists** push their move's score directly:
+  **Aggressor → CLEAVE**, **Stalker → APPROACH**, **Survivor → RETREAT**, **Baiter → IDLE**.
+- **Two modulators (M)** — **Punisher** ("the player is open!") and **Enrage**
+  ("we're low on HP — go berserk") — **own no action**. Their *only* way to affect the
+  fight is the latent they write into the shared `RecursiveLink`, which the coordinator
+  turns into modulation. So training has to *learn to use the latent channel* — the whole
+  point of the architecture.
+
+The right-hand panel shows all of this live: each specialist's activity, the shared
+latent bridge, and the coordinator's modulation, for every decision the boss makes.
+
+## What emerged from training
+
+Trained on a reward that values *dealing damage* and *pressuring in range* over
+playing it safe (landing a cleave ≫ whiffing, and stalling / staying out of range is
+penalised), the boss learned an **aggressive pressure** style:
+
+- **closes the distance** when you're far or at mid-range,
+- **cleaves on contact** — once you're in range and it's off cooldown it commits to a
+  lunging swing essentially every time (verified: in-range attack-rate ≈ **0.8–1.0**),
+- **retreats only when it can't swing** (mid-cooldown) to reset spacing,
+- **blocks your punish** — a **Defender** specialist raises a guard (negating ~90% of
+  your melee) when you swing at it and it can't cleave back,
+- **punishes your recovery** and gets **even more aggressive at low HP** — the Enrage
+  modulator raises CLEAVE through the shared latent.
+
+It reaches a **~55–65% win rate** against a near-optimal scripted dodger (avg reward
++8, up from −12 before the reward was tuned for aggression). Against a human it's a
+fair, readable fight: **dodge the red telegraph, then punish the recovery.**
+
+> The earlier version of the brain learned a degenerate "space forever, never commit"
+> policy that *technically* won but barely attacked — so the trainer now selects the
+> checkpoint on **win-rate + in-range attack-rate**, and a non-attacking policy can no
+> longer be saved. (`behavior()` in `train.py` measures this directly.)
+
+## It learns from your fights (online finetuning)
+
+The model is tiny, so a gradient step is microseconds — the boss finetunes from real
+play **on the free CPU**. Each HARD-tier fight is logged (state, action, HP per boss
+decision) and POSTed to `/learn`; the server rebuilds per-decision rewards (damage
+dealt − taken, + kill / − death), computes REINFORCE returns, and takes **one Adam
+step** ([`mm_grad.py`](mm_grad.py), numpy backprop verified against PyTorch to ~1e-8).
+A frozen copy of the sim-trained weights anchors the update so it can't drift into
+nonsense; the adapted weights feed straight back into the live boss.
+
+- **On by default, in-memory.** Set `MM_ONLINE=0` to disable.
+- **Persistent across restarts:** add Space secrets `HF_TOKEN` (write) and
+  `MM_DATASET_REPO` (e.g. `you/boss-fight-online`) and the adapted weights are pushed
+  to / pulled from that Dataset. Only HARD-tier fights train (keeps the data on-policy).
+
+## Difficulty = the trained brain's decision-noise
+
+The difficulty selector doesn't change the boss's stats — it runs the **same trained
+Modular Mind at a different *mistake-rate*** (`explore` = probability of a random legal
+action). vs a near-optimal scripted dodger:
+
+| Tier | Mistake-rate | Boss win-rate | Feel |
+|------|------|------|------|
+| **Easy** | 50% | ~0.35 | erratic, leaves big openings — beatable |
+| **Normal** | 22% | ~0.65 | competent pressure, occasional slip |
+| **Hard** | 4% | ~0.95 | closes in, blocks your punish, relentless |
+
+The browser sends the chosen tier with every decision; the server routes it through
+`modular_mind.decide` with that tier's mistake-rate. *(Originally Easy/Normal were
+genuinely-undertrained checkpoints — but once the boss learned to BLOCK it dominates
+the sim almost immediately, so there's no longer a weak checkpoint; decision-noise is
+the controllable, honest dial. `train.py` still snapshots checkpoints if you want them.)*
+
+## Controls
+
+| Key | Action |
+|-----|--------|
+| ← → | Move |
+| Space | Roll / dodge (i-frames, costs stamina) |
+| J | Attack |
+| K (hold) | **Block** — cuts incoming damage to 20% and drains stamina; if stamina hits 0 your guard **breaks** into a stagger |
+| M / 🔊 | Mute / unmute music + SFX |
+
+Background music and combat SFX play during the fight (a random track per fight,
+plus per-action sound effects). Audio is served statically from `audio/`.
+
+You begin each fight with a one-time **Aegis shield** (a cyan bubble + the *Aegis*
+HUD bar): for the first few seconds it absorbs **all** damage so you can learn the
+controls. Once it fades it does **not** come back.
+
+> Click **Enter the Fog**, then click the game once so it has keyboard focus.
+
+## Architecture / files
+
+| File | Role |
+|------|------|
+| `app.py` | Gradio Space: serves the game, exposes the trained brain at `/decide` |
+| `modular_mind.py` | **numpy** inference of the trained Modular Mind (no torch at runtime) |
+| `mm_torch.py` | the trainable Modular Mind (specialists + RecursiveLink + coordinator) |
+| `train.py` | self-play **REINFORCE** trainer → `mm_weights.npz` |
+| `mm_grad.py` | pure-numpy forward+backward (REINFORCE gradient), verified vs torch — the online learner |
+| `online.py` | finetunes the HARD brain from real player fights; optional HF-Dataset persistence |
+| `duel_sim.py` | the headless duel simulator (the RL environment) |
+| `features.py` | shared feature/action definitions (single source of truth) |
+| `web/` | the HTML5 canvas game (60fps render; calls `/decide` at decision points) |
+| `audio/` | background music (`mp3/`) and sound effects (`sfx/`), served statically |
+| `serve_local.py` | run the whole thing locally **without gradio** (stdlib + numpy) |
+
+The model is **tiny** (~4.5k parameters) and inference is pure numpy, so the Space
+needs only `gradio` + `numpy` and starts instantly.
+
+## Run / retrain locally
+
+```bash
+pip install -r requirements.txt          # gradio + numpy (runtime)
+python app.py                            # the Space, locally
+# or, with no gradio at all:
+python serve_local.py                    # http://localhost:7861
+
+# retrain the boss (needs torch):
+pip install torch
+python train.py                          # -> mm_weights.npz  (+ train_log.json)
+```
+
+## Credits
+
+- **Sprites:** *Fire Knight* and *Demon Slime* free asset packs by **LuizMelo**
+  (itch.io). Please check their licenses for your own use.
+- **Audio:** background music tracks (`audio/mp3`) and combat SFX (`audio/sfx`).
+  Check the licenses of your audio packs before publishing.
+- **Brain:** the *Modular Mind* concept (latent-communicating specialists via
+  `RecursiveLink`), trained here at specialist scale by self-play RL.
+
+Built for a HuggingFace hackathon.

agents/modmind/language/checkpoints/model.safetensors

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

agents/modmind/links/language__from__reasoning.safetensors

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

agents/modmind/moe_gradio.py

@@ -53,8 +53,12 @@ KEY_CHARS = string.ascii_letters + string.digits   # must match train_link.py
 
 
 def _latest_ckpt(domain: str):
-    cks = sorted(glob.glob(str(CKPT_ROOT / domain / "checkpoints" / "step_*.pt")))
-    return cks[-1] if cks else None
+    base = CKPT_ROOT / domain / "checkpoints"
+    sft = base / "model.safetensors"
+    if sft.exists():
+        return str(sft)                    # slim fp16 safetensors (preferred)
+    cks = sorted(glob.glob(str(base / "step_*.pt")))
+    return cks[-1] if cks else None        # fall back to a full .pt checkpoint
 
 
 class SpikeWhaleMoE:
@@ -79,11 +83,20 @@ class SpikeWhaleMoE:
                 continue
             cfg = specialist_config(domain)
             m = SpikeWhaleLM(cfg).to(self.device).eval()
-            st = torch.load(ck, map_location=self.device, weights_only=False)
-            m.load_state_dict(st["model_state"])
+            if ck.endswith(".safetensors"):
+                from safetensors.torch import load_file
+                from safetensors import safe_open
+                sd = load_file(ck, device=self.device)
+                sd = {k: (v.float() if v.is_floating_point() else v) for k, v in sd.items()}
+                m.load_state_dict(sd)
+                with safe_open(ck, framework="pt") as f:
+                    step = int((f.metadata() or {}).get("step", 0))
+            else:
+                st = torch.load(ck, map_location=self.device, weights_only=False)
+                m.load_state_dict(st["model_state"]); step = int(st.get("step", 0))
             self.models[slot] = m
             self.toks[slot] = SpikeTokenizer(vocab_file=str(tok_path))
-            self.steps[slot] = int(st.get("step", 0))
+            self.steps[slot] = step
             self._mtime[slot] = mt
         self._load_links()
         return list(self.models)
@@ -91,6 +104,30 @@ class SpikeWhaleMoE:
     def available(self):
         return list(self.models)
 
+    def ensure_device(self, device):
+        """Move all loaded models/links to `device`. On ZeroGPU this is called inside the
+        @spaces.GPU function so CUDA is only touched there, never at import/startup.
+        .to(device) is a no-op when already there, so it's safe to call on every request."""
+        for k in list(self.models):
+            self.models[k] = self.models[k].to(device)
+        if self.link is not None:
+            self.link = self.link.to(device)
+        if self.trained_link is not None:
+            self.trained_link = self.trained_link.to(device)
+        if self.bridge_asker is not None:
+            self.bridge_asker = self.bridge_asker.to(device)
+        cache = getattr(self, "_merge_cache", None)
+        if cache is not None:
+            self._merge_cache = (cache[0], cache[1].to(device))
+        self.device = device
+
+    def to_gpu_if_available(self):
+        try:
+            if torch.cuda.is_available():
+                self.ensure_device("cuda")
+        except Exception:
+            pass
+
     def _load_links(self):
         """Load a TRAINED RecursiveLink bridge (train_link.py output) from
         links/<asker>__from__<consultant>.pt and overlay its bridge-trained injection path
@@ -99,33 +136,47 @@ class SpikeWhaleMoE:
         self.trained_link = None
         self.bridge_asker = None
         self.link_meta = None
+        self._bridge_ali = None
         for asker_domain, consultant_domain in LINKS:
             a, c = DOMAIN2SLOT.get(asker_domain), DOMAIN2SLOT.get(consultant_domain)
             if a not in self.models or c not in self.models:
                 continue
-            lp = CKPT_ROOT / "links" / f"{asker_domain}__from__{consultant_domain}.pt"
-            if not lp.exists():
+            base = CKPT_ROOT / "links" / f"{asker_domain}__from__{consultant_domain}"
+            sft, pt = Path(str(base) + ".safetensors"), Path(str(base) + ".pt")
+            if sft.exists():
+                from safetensors.torch import load_file
+                from safetensors import safe_open
+                t = load_file(str(sft), device=self.device)
+                t = {k: (v.float() if v.is_floating_point() else v) for k, v in t.items()}
+                with safe_open(str(sft), framework="pt") as f:
+                    md = f.metadata() or {}
+                link_sd = {k[5:]: v for k, v in t.items() if k.startswith("link.")}
+                ali_sd = {k[4:]: v for k, v in t.items() if k.startswith("ali.")}
+                asker_sd = {k[6:]: v for k, v in t.items() if k.startswith("asker.")} or None
+                key_len = int(md.get("key_len", 6)); prompt = md.get("prompt", "KEY> ")
+                wl = float(md.get("with_latent", "nan")); nl = float(md.get("without_latent", "nan"))
+            elif pt.exists():
+                st = torch.load(str(pt), map_location=self.device, weights_only=False)
+                link_sd = st["link"]; ali_sd = st["asker_latent_inject"]; asker_sd = st.get("asker_state")
+                key_len = int(st.get("key_len", 6)); prompt = st.get("prompt", "KEY> ")
+                wl = float(st.get("with_latent", float("nan"))); nl = float(st.get("without_latent", float("nan")))
+            else:
                 continue
-            st = torch.load(lp, map_location=self.device, weights_only=False)
             link = RecursiveLink(d_latent=D_LATENT).to(self.device).eval()
-            link.load_state_dict(st["link"])
+            link.load_state_dict(link_sd)
+            self._bridge_ali = ali_sd
             try:
-                self.models[a].model.latent_inject.load_state_dict(st["asker_latent_inject"])
+                self.models[a].model.latent_inject.load_state_dict(ali_sd)
             except Exception:
                 pass
-            # FULL fine-tuned asker, if this bridge was saved with the updated train_link.py.
-            # Without it we can show latent *influence* (consult) but not reproduce key-recall.
-            if "asker_state" in st:
+            # FULL fine-tuned asker (if present) -> lets us reproduce key-recall live.
+            if asker_sd:
                 ba = SpikeWhaleLM(specialist_config(asker_domain)).to(self.device).eval()
-                ba.load_state_dict(st["asker_state"])
+                ba.load_state_dict(asker_sd)
                 self.bridge_asker = ba
             self.trained_link = link
-            self.link_meta = {
-                "asker": a, "consultant": c,
-                "key_len": int(st.get("key_len", 6)), "prompt": st.get("prompt", "KEY> "),
-                "with_latent": float(st.get("with_latent", float("nan"))),
-                "without_latent": float(st.get("without_latent", float("nan"))),
-            }
+            self.link_meta = {"asker": a, "consultant": c, "key_len": key_len, "prompt": prompt,
+                              "with_latent": wl, "without_latent": nl}
             return   # one bridge is enough for the panel demo
 
     def key_recall_available(self):
@@ -326,15 +377,14 @@ class SpikeWhaleMoE:
                 merged[k] = lsd[k].clone()      # integer/bool buffers: copy as-is
         m = SpikeWhaleLM(specialist_config("language")).to(self.device).eval()
         m.load_state_dict(merged)
-        # make it bridge-ready: re-load the bridge-trained injection weights straight from the
-        # link file (self-contained). The injection only fires when we pass inject_latent.
-        try:
-            lp = CKPT_ROOT / "links" / "language__from__reasoning.pt"
-            if lp.exists():
-                st = torch.load(lp, map_location=self.device, weights_only=False)
-                m.model.latent_inject.load_state_dict(st["asker_latent_inject"])
-        except Exception:
-            pass
+        # make it bridge-ready: overlay the bridge-trained injection weights (loaded by
+        # _load_links, format-agnostic). The injection only fires when we pass inject_latent.
+        ali = getattr(self, "_bridge_ali", None)
+        if ali is not None:
+            try:
+                m.model.latent_inject.load_state_dict(ali)
+            except Exception:
+                pass
         self._merge_cache = (alpha, m)
         return m
 

agents/modmind/reasoning/checkpoints/model.safetensors

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

agents/panel.py

@@ -1,292 +1,312 @@
-"""
-panel.py -- the Gradio section for the bottom of the boss app: a live demo of the
-Modular-Mind mixture-of-experts.
-
-For the SpikeWhale backend it leads with the *latent bridge* (the real result) and
-organizes the three demos into tabs. Every handler is a generator that yields an
-instant "loading/generating" message first, so the first run never looks frozen while
-the ~80M models lazy-load. Hot-reloads checkpoints.
-"""
-from __future__ import annotations
-
-import os
-import sys
-
-import gradio as gr
-
-EMOJI = {"language": "📖 Language", "math": "➗ Math", "tool": "🛠️ Tool-use"}
-DEVICE = os.environ.get("MM_AGENTS_DEVICE", "cpu")
-# Self-contained SpikeWhale bundle that ships next to this file (agents/modmind/: the 80M
-# specialists + bridge + inference code). If it's present we default to the SpikeWhale backend
-# so the HuggingFace Space "just works" with no env config. Env vars still override.
-_BUNDLED_MODMIND = os.path.join(os.path.dirname(os.path.abspath(__file__)), "modmind")
-_DEFAULT_BACKEND = "spikewhale" if os.path.isdir(_BUNDLED_MODMIND) else "bytegpt"
-_SPIKEWHALE = os.environ.get("MM_MOE_BACKEND", _DEFAULT_BACKEND).lower() in ("spikewhale", "modmind")
-_WARMED = {"done": False}   # so the "loading the models" notice only shows on the first run
-
-_FOOTER = (
-    "Two ~80M dense specialists — 📖 Language (FineWeb-Edu) and ➗ Math (FineMath) — sharing a "
-    "16k length-max tokenizer. A coordinator routes by bits-per-byte, and a trained RecursiveLink "
-    "lets them communicate in latent space (proven in the Bridge tab). Hot-reloads checkpoints."
-    if _SPIKEWHALE else
-    "Three byte-level ~10M specialists, streamed-trained on FineWeb-Edu / FineMath / "
-    "glaive-function-calling. Tiny + early-trained, so generations are rough — the routing "
-    "(which expert is most confident) is the point. It hot-reloads as training continues."
-)
-
-
-def _get_moe():
-    """Pick the MoE backend. Defaults to the bundled SpikeWhale 80M specialists
-    (agents/modmind/) when present, else the byte-level ByteGPT experts. MM_MOE_BACKEND
-    and MODMIND_DIR override."""
-    backend = os.environ.get("MM_MOE_BACKEND", _DEFAULT_BACKEND).lower()
-    if backend in ("spikewhale", "modmind"):
-        mm_dir = os.environ.get("MODMIND_DIR", _BUNDLED_MODMIND)
-        if mm_dir and mm_dir not in sys.path:
-            sys.path.insert(0, mm_dir)   # front: ModMind's model.py wins over agents/model.py
-        from moe_gradio import get_moe
-        return get_moe
-    from orchestrator import get_moe
-    return get_moe
-
-
-def _loading_notice(action="Generating"):
-    """First-run popup + in-place message so nothing ever looks frozen."""
-    if not _WARMED["done"]:
-        gr.Info("First run — loading the models (~20–40s on CPU). After this, it's quick.")
-        return (f"### ⏳ Loading the models + {action.lower()}…\n"
-                "*First run loads the ~80M specialists into memory — this can take ~20–40s on CPU. "
-                "Every run after this is fast.*")
-    return f"### ⏳ {action}…"
-
-
-def _bar(frac, n=18):
-    f = max(0.0, min(1.0, frac))
-    return "█" * round(f * n) + "·" * (n - round(f * n))
-
-
-def moe_run(query, max_new):
-    yield _loading_notice("Routing & generating")
-    moe = _get_moe()(DEVICE)
-    if not moe.available():
-        if _SPIKEWHALE:
-            yield ("### ⏳ No SpikeWhale experts found\nSet `MODMIND_DIR` to your ModMind folder "
-                   "and make sure `<domain>/checkpoints/step_*.pt` exist (the panel hot-reloads them).")
-        else:
-            yield ("### ⏳ No experts trained yet\nRun `python agents/train.py --expert language` "
-                   "(and `math`, `tool`).")
-        return
-    q = (query or "").strip() or "The"
-    r = moe.run(q, max_new=int(max_new))
-    _WARMED["done"] = True
-    w = r["weights"]; bits = r["bits_per_byte"]; steps = r["steps"]
-    rows = "\n".join(
-        f"| {EMOJI.get(n, n)} | {steps.get(n,0):,} | {bits[n]:.2f} | `{_bar(w[n])}` {w[n]*100:4.1f}% |"
-        + ("  ⬅ **routed**" if n == r["winner"] else "")
-        for n in w
-    )
-    lat = r["shared_latent"][:16]
-    spark = "".join("▁▂▃▄▅▆▇█"[min(7, int((abs(v)) / (max(1e-3, max(abs(x) for x in lat))) * 7))] for v in lat)
-    yield f"""### Routed to {EMOJI.get(r['winner'], r['winner'])}
-The expert with the **lowest bits/byte** (most fluent on your text) wins the route.
-
-| expert | train steps | bits/byte | routing weight |
-|---|---|---|---|
-{rows}
-
-**{EMOJI.get(r['winner'], r['winner'])} continues your prompt:**
-> {q}**{r['generation']}**
-
-**Fused latent** (both experts' output latents combined — a glimpse of the shared bus): `{spark}`
-
-<sub>{_FOOTER}</sub>"""
-
-
-def moe_key_recall(n):
-    """THE PROOF: a random key shown only to the consultant; the asker reproduces it from the
-    latent alone (with) vs ablated (without)."""
-    yield _loading_notice("Running the proof")
-    moe = _get_moe()(DEVICE)
-    if not getattr(moe, "key_recall_available", lambda: False)():
-        yield ("### 🔑 Bridge unavailable\nNeeds the **SpikeWhale** backend and a trained "
-               "`links/<asker>__from__<consultant>.pt` saved with the full asker.")
-        return
-    meta = moe.consult_meta()
-    a = EMOJI.get(meta["asker"], meta["asker"]); c = EMOJI.get(meta["consultant"], meta["consultant"])
-    wr = moe.key_recall(n=int(n), ablate=False)
-    ar = moe.key_recall(n=int(n), ablate=True)
-    _WARMED["done"] = True
-    rows = "\n".join(f"| `{k}` | `{rec}` | {'✅' if ok else '❌'} |" for k, rec, ok in wr["examples"])
-    return_ok = wr['acc'] * 100
-    return_no = ar['acc'] * 100
-    yield f"""### 🔑 {a} read {c}'s mind — {return_ok:.0f}% with the latent, {return_no:.0f}% without
-
-A random key is shown **only to {c}**. {a} never sees it — yet by reading {c}'s latent through the
-trained RecursiveLink, it reproduces the key:
-
-| secret key (only {c} saw it) | {a} recovered it | |
-|---|---|---|
-{rows}
-
-## ✅ With the latent: {return_ok:.0f}%  →  ❌ Cut the latent: {return_no:.0f}%
-
-<sub>That collapse to chance when the latent is removed is the whole point: the information is genuinely
-crossing the latent bridge between two models that were trained **separately, on different data**.
-This is the result — routing and generation are the supporting act.</sub>"""
-
-
-def moe_consult(query, max_new):
-    """Latent-influence demo: inject the consultant's latent into the asker (WITH vs WITHOUT).
-    The bridge was trained on key-recall, so the latent *steers* the output rather than answering."""
-    yield _loading_notice("Injecting latent")
-    moe = _get_moe()(DEVICE)
-    if not getattr(moe, "consult_available", lambda: False)():
-        yield ("### 🔗 Latent bridge unavailable\nNeeds the **SpikeWhale** backend and a trained bridge.")
-        return
-    q = (query or "").strip() or "natural selection"
-    meta = moe.consult_meta()
-    a = EMOJI.get(meta["asker"], meta["asker"]); c = EMOJI.get(meta["consultant"], meta["consultant"])
-    with_gen = moe.consult(q, max_new=int(max_new), ablate=False)
-    abl_gen = moe.consult(q, max_new=int(max_new), ablate=True)
-    _WARMED["done"] = True
-    wl, nl = meta["with_latent"], meta["without_latent"]
-    yield f"""### 🔗 Latent influence — {c}'s latent injected into {a}
-
-**WITH {c}'s latent (through the trained RecursiveLink):**
-> {q}**{with_gen}**
-
-**WITHOUT it (latent ablated to zero):**
-> {q}**{abl_gen}**
-
-<sub>This shows the latent's raw *effect* on generation, not a Q&A answer. The bridge was trained on
-key-recall (ablation with={wl:.3f} vs without={nl:.4f}), so the injected latent pushes the asker toward
-that learned behavior — which is why WITH and WITHOUT differ so sharply. The clean proof the latent
-carries real information is the **Bridge** tab.</sub>"""
-
-
-def moe_combine(query, max_new, blend, consult):
-    """Two blends compared at the same mix ratio: a real WEIGHT-MERGE (one merged model) vs an
-    OUTPUT-BLEND (two models run separately, distributions averaged)."""
-    yield _loading_notice("Building merge + blending")
-    moe = _get_moe()(DEVICE)
-    if not getattr(moe, "merge_available", lambda: False)():
-        yield "### 🧬 Needs both specialists loaded."
-        return
-    q = (query or "").strip() or "The water cycle works by"
-    a = float(blend)
-    merged_gen = moe.merge_generate(q, alpha=a, max_new=int(max_new), consult=bool(consult))
-    blend_gen = moe.combine(q, max_new=int(max_new), blend=a, consult=bool(consult))
-    _WARMED["done"] = True
-    mix = f"{int(round((1-a)*100))}% 📖 Language / {int(round(a*100))}% ➗ Math"
-    extra = "  ·  +Reasoning's latent (consult)" if consult else ""
-    yield f"""### 🧬 MoE Modular Minds — two ways to blend  ·  {mix}{extra}
-
-**① Weight merge** — a *single* model whose weights are `(1-α)·Language + α·Math` — one network, one forward pass:
-> {q}**{merged_gen}**
-
-**② Output blend** — both models run separately, their next-token distributions averaged each step:
-> {q}**{blend_gen}**
-
-<sub>Same mix ratio, two different mechanisms. **Weight merge** fuses the actual parameters into one model
-(only possible because they're the identical dense architecture); **output blend** is an inference-time
-ensemble of two separate models (only possible because they share the 16k tokenizer). Tick *consult* to also
-route Reasoning's latent into each through the trained bridge. Exploratory — generations are rough at this scale.</sub>"""
-
-
-HERO = """# 🧩 Modular Mind — two specialists that talk in latent space
-**Two ~80M models trained completely separately** — 📖 **Language** on FineWeb-Edu, ➗ **Math** on
-FineMath — that never saw each other's data. A coordinator **routes** your query to the right one,
-and a trained **RecursiveLink** lets them **communicate through latent space**: Language can read
-information straight out of Math's "mind." The **🔑 Bridge** tab proves it.
-
-> ℹ️ *These specialists were trained only to demonstrate a **verifiable result** — clean routing and a
-> provable latent-bridge ablation — **not** for production-quality output. The generated text is
-> intentionally rough at this scale; the mechanism is the point.*"""
-
-BRIDGE_INTRO = """### The proof: two independent models, one latent channel
-A random secret key is shown **only to ➗ Math**. 📖 Language never sees it — but by reading Math's
-latent through the trained RecursiveLink, it **reproduces the key**. Zero out the latent and it
-collapses to chance. That gap *is* the result: real information crossing between two models that
-were trained on different data and never met. **Hit the button.**"""
-
-INTRO_BYTE = """## 🧩 Experiment — Modular Mind as a Mixture of Experts
-Three tiny ~10M byte-level specialists (language, math, tool-use), each streamed-trained on its own
-dataset. A coordinator **routes** your query to whichever expert is most fluent (perplexity-based MoE)
-and fuses their latents through a **RecursiveLink**. Try a math problem vs. a sentence."""
-
-
-def _routing_block():
-    with gr.Row():
-        q = gr.Textbox(label="Your prompt", value="Solve for x: 2x + 3 = 11",
-                       scale=4, placeholder="a sentence or a math problem…")
-        n = gr.Slider(40, 300, value=80, step=20, label="generate tokens", scale=1)
-    btn = gr.Button("🧭 Route & generate", variant="primary")
-    out = gr.Markdown()
-    btn.click(moe_run, [q, n], out)
-    gr.Examples(examples=[["The theory of evolution explains", 80],
-                          ["Compute the derivative of x^2 + 3x", 80],
-                          ["The history of the Roman Empire began", 80]],
-                inputs=[q, n])
-
-
-def build_moe_panel():
-    """Create the MoE demo components inside the current gr.Blocks context."""
-    if not _SPIKEWHALE:
-        with gr.Accordion("🧩 Experiment: Modular Mind = Mixture of Experts (3 specialists)", open=False):
-            gr.Markdown(INTRO_BYTE)
-            _routing_block()
-        return
-
-    with gr.Accordion("🧩 Modular Mind — independent specialists communicating in latent space", open=True):
-        gr.Markdown(HERO)
-        with gr.Tabs():
-            # The headline result, FIRST.
-            with gr.Tab("🔑 The latent bridge — the proof"):
-                gr.Markdown(BRIDGE_INTRO)
-                with gr.Row():
-                    kn = gr.Slider(4, 16, value=8, step=1, label="keys to test", scale=3)
-                    kbtn = gr.Button("🔑 Run the proof", variant="primary", scale=1)
-                kout = gr.Markdown()
-                kbtn.click(moe_key_recall, [kn], kout)
-
-            # Routing — the supporting act.
-            with gr.Tab("🧭 Routing & generation"):
-                gr.Markdown("Type a math problem vs. a sentence and watch the **route flip** — each "
-                            "expert is most fluent (lowest bits/byte) on its own domain.")
-                _routing_block()
-
-            # Latent influence — honest "with vs without".
-            with gr.Tab("🔗 Latent influence"):
-                gr.Markdown(
-                    "Inject ➗ Math's latent into 📖 Language through the **trained RecursiveLink** and "
-                    "see generation **with vs without** it. The bridge was trained on key-recall, so the "
-                    "latent *steers* the output (it doesn't answer the question) — the point is how "
-                    "strongly it changes generation. The clean proof is the **Bridge** tab.")
-                with gr.Row():
-                    cq = gr.Textbox(label="Text to encode (Math's latent → injected into Language)",
-                                    value="natural selection", scale=4)
-                    cn = gr.Slider(40, 200, value=80, step=20, label="generate tokens", scale=1)
-                cbtn = gr.Button("🔗 Show latent influence (with vs without)", variant="secondary")
-                cout = gr.Markdown()
-                cbtn.click(moe_consult, [cq, cn], cout)
-
-            # MoE Modular Minds — TWO ways to blend the specialists, compared side by side.
-            with gr.Tab("🧬 MoE Modular Minds"):
-                gr.Markdown(
-                    "**Two ways to blend the two specialists**, shown side by side at the same mix ratio:\n"
-                    "- **① Weight merge** — fuse the *parameters* into one model `(1-α)·Language + α·Math` "
-                    "(works because they're the identical dense architecture).\n"
-                    "- **② Output blend** — run both models separately and average their next-token "
-                    "distributions (works because they share the 16k tokenizer).\n\n"
-                    "Slide the mix, and tick *consult* to also route Reasoning's latent into each through the "
-                    "trained bridge.")
-                with gr.Row():
-                    mq = gr.Textbox(label="Prompt", value="The water cycle works by", scale=4)
-                    mn = gr.Slider(40, 160, value=70, step=10, label="generate tokens", scale=1)
-                with gr.Row():
-                    mblend = gr.Slider(0.0, 1.0, value=0.5, step=0.1,
-                                       label="mix α:  0 = 📖 Language   ⟷   1 = ➗ Math", scale=3)
-                    mconsult = gr.Checkbox(value=False, label="consult (inject Reasoning's latent)", scale=1)
-                mbtn = gr.Button("🧬 Blend both ways (weight-merge vs output-blend)", variant="primary")
-                mout = gr.Markdown()
-                mbtn.click(moe_combine, [mq, mn, mblend, mconsult], mout)
+"""
+panel.py -- the Gradio section for the bottom of the boss app: a live demo of the
+Modular-Mind mixture-of-experts.
+
+For the SpikeWhale backend it leads with the *latent bridge* (the real result) and
+organizes the three demos into tabs. Every handler is a generator that yields an
+instant "loading/generating" message first, so the first run never looks frozen while
+the ~80M models lazy-load. Hot-reloads checkpoints.
+"""
+from __future__ import annotations
+
+import os
+import sys
+
+import gradio as gr
+
+# ZeroGPU: @spaces.GPU allocates a GPU only for the decorated call (CUDA is never touched at
+# import/startup). Falls back to a no-op decorator when `spaces` isn't installed (local / plain CPU).
+try:
+    import spaces
+    _gpu = spaces.GPU
+except Exception:
+    def _gpu(fn=None, **kw):
+        return fn if callable(fn) else (lambda f: f)
+
+
+def _to_gpu(moe):
+    if hasattr(moe, "to_gpu_if_available"):
+        moe.to_gpu_if_available()
+    return moe
+
+
+EMOJI = {"language": "📖 Language", "math": "➗ Math", "tool": "🛠️ Tool-use"}
+DEVICE = os.environ.get("MM_AGENTS_DEVICE", "cpu")
+# Self-contained SpikeWhale bundle that ships next to this file (agents/modmind/: the 80M
+# specialists + bridge + inference code). If it's present we default to the SpikeWhale backend
+# so the HuggingFace Space "just works" with no env config. Env vars still override.
+_BUNDLED_MODMIND = os.path.join(os.path.dirname(os.path.abspath(__file__)), "modmind")
+_DEFAULT_BACKEND = "spikewhale" if os.path.isdir(_BUNDLED_MODMIND) else "bytegpt"
+_SPIKEWHALE = os.environ.get("MM_MOE_BACKEND", _DEFAULT_BACKEND).lower() in ("spikewhale", "modmind")
+_WARMED = {"done": False}   # so the "loading the models" notice only shows on the first run
+
+_FOOTER = (
+    "Two ~80M dense specialists — 📖 Language (FineWeb-Edu) and ➗ Math (FineMath) — sharing a "
+    "16k length-max tokenizer. A coordinator routes by bits-per-byte, and a trained RecursiveLink "
+    "lets them communicate in latent space (proven in the Bridge tab). Hot-reloads checkpoints."
+    if _SPIKEWHALE else
+    "Three byte-level ~10M specialists, streamed-trained on FineWeb-Edu / FineMath / "
+    "glaive-function-calling. Tiny + early-trained, so generations are rough — the routing "
+    "(which expert is most confident) is the point. It hot-reloads as training continues."
+)
+
+
+def _get_moe():
+    """Pick the MoE backend. Defaults to the bundled SpikeWhale 80M specialists
+    (agents/modmind/) when present, else the byte-level ByteGPT experts. MM_MOE_BACKEND
+    and MODMIND_DIR override."""
+    backend = os.environ.get("MM_MOE_BACKEND", _DEFAULT_BACKEND).lower()
+    if backend in ("spikewhale", "modmind"):
+        mm_dir = os.environ.get("MODMIND_DIR", _BUNDLED_MODMIND)
+        if mm_dir and mm_dir not in sys.path:
+            sys.path.insert(0, mm_dir)   # front: ModMind's model.py wins over agents/model.py
+        from moe_gradio import get_moe
+        return get_moe
+    from orchestrator import get_moe
+    return get_moe
+
+
+def _loading_notice(action="Generating"):
+    """First-run popup + in-place message so nothing ever looks frozen."""
+    if not _WARMED["done"]:
+        gr.Info("First run — loading the models (~20–40s on CPU). After this, it's quick.")
+        return (f"### ⏳ Loading the models + {action.lower()}…\n"
+                "*First run loads the ~80M specialists into memory — this can take ~20–40s on CPU. "
+                "Every run after this is fast.*")
+    return f"### ⏳ {action}…"
+
+
+def _bar(frac, n=18):
+    f = max(0.0, min(1.0, frac))
+    return "█" * round(f * n) + "·" * (n - round(f * n))
+
+
+@_gpu(duration=120)
+def moe_run(query, max_new):
+    yield _loading_notice("Routing & generating")
+    moe = _to_gpu(_get_moe()(DEVICE))
+    if not moe.available():
+        if _SPIKEWHALE:
+            yield ("### ⏳ No SpikeWhale experts found\nSet `MODMIND_DIR` to your ModMind folder "
+                   "and make sure `<domain>/checkpoints/step_*.pt` exist (the panel hot-reloads them).")
+        else:
+            yield ("### ⏳ No experts trained yet\nRun `python agents/train.py --expert language` "
+                   "(and `math`, `tool`).")
+        return
+    q = (query or "").strip() or "The"
+    r = moe.run(q, max_new=int(max_new))
+    _WARMED["done"] = True
+    w = r["weights"]; bits = r["bits_per_byte"]; steps = r["steps"]
+    rows = "\n".join(
+        f"| {EMOJI.get(n, n)} | {steps.get(n,0):,} | {bits[n]:.2f} | `{_bar(w[n])}` {w[n]*100:4.1f}% |"
+        + ("  ⬅ **routed**" if n == r["winner"] else "")
+        for n in w
+    )
+    lat = r["shared_latent"][:16]
+    spark = "".join("▁▂▃▄▅▆▇█"[min(7, int((abs(v)) / (max(1e-3, max(abs(x) for x in lat))) * 7))] for v in lat)
+    yield f"""### Routed to {EMOJI.get(r['winner'], r['winner'])}
+The expert with the **lowest bits/byte** (most fluent on your text) wins the route.
+
+| expert | train steps | bits/byte | routing weight |
+|---|---|---|---|
+{rows}
+
+**{EMOJI.get(r['winner'], r['winner'])} continues your prompt:**
+> {q}**{r['generation']}**
+
+**Fused latent** (both experts' output latents combined — a glimpse of the shared bus): `{spark}`
+
+<sub>{_FOOTER}</sub>"""
+
+
+@_gpu(duration=120)
+def moe_key_recall(n):
+    """THE PROOF: a random key shown only to the consultant; the asker reproduces it from the
+    latent alone (with) vs ablated (without)."""
+    yield _loading_notice("Running the proof")
+    moe = _to_gpu(_get_moe()(DEVICE))
+    if not getattr(moe, "key_recall_available", lambda: False)():
+        yield ("### 🔑 Bridge unavailable\nNeeds the **SpikeWhale** backend and a trained "
+               "`links/<asker>__from__<consultant>.pt` saved with the full asker.")
+        return
+    meta = moe.consult_meta()
+    a = EMOJI.get(meta["asker"], meta["asker"]); c = EMOJI.get(meta["consultant"], meta["consultant"])
+    wr = moe.key_recall(n=int(n), ablate=False)
+    ar = moe.key_recall(n=int(n), ablate=True)
+    _WARMED["done"] = True
+    rows = "\n".join(f"| `{k}` | `{rec}` | {'✅' if ok else '❌'} |" for k, rec, ok in wr["examples"])
+    return_ok = wr['acc'] * 100
+    return_no = ar['acc'] * 100
+    yield f"""### 🔑 {a} read {c}'s mind — {return_ok:.0f}% with the latent, {return_no:.0f}% without
+
+A random key is shown **only to {c}**. {a} never sees it — yet by reading {c}'s latent through the
+trained RecursiveLink, it reproduces the key:
+
+| secret key (only {c} saw it) | {a} recovered it | |
+|---|---|---|
+{rows}
+
+## ✅ With the latent: {return_ok:.0f}%  →  ❌ Cut the latent: {return_no:.0f}%
+
+<sub>That collapse to chance when the latent is removed is the whole point: the information is genuinely
+crossing the latent bridge between two models that were trained **separately, on different data**.
+This is the result — routing and generation are the supporting act.</sub>"""
+
+
+@_gpu(duration=120)
+def moe_consult(query, max_new):
+    """Latent-influence demo: inject the consultant's latent into the asker (WITH vs WITHOUT).
+    The bridge was trained on key-recall, so the latent *steers* the output rather than answering."""
+    yield _loading_notice("Injecting latent")
+    moe = _to_gpu(_get_moe()(DEVICE))
+    if not getattr(moe, "consult_available", lambda: False)():
+        yield ("### 🔗 Latent bridge unavailable\nNeeds the **SpikeWhale** backend and a trained bridge.")
+        return
+    q = (query or "").strip() or "natural selection"
+    meta = moe.consult_meta()
+    a = EMOJI.get(meta["asker"], meta["asker"]); c = EMOJI.get(meta["consultant"], meta["consultant"])
+    with_gen = moe.consult(q, max_new=int(max_new), ablate=False)
+    abl_gen = moe.consult(q, max_new=int(max_new), ablate=True)
+    _WARMED["done"] = True
+    wl, nl = meta["with_latent"], meta["without_latent"]
+    yield f"""### 🔗 Latent influence — {c}'s latent injected into {a}
+
+**WITH {c}'s latent (through the trained RecursiveLink):**
+> {q}**{with_gen}**
+
+**WITHOUT it (latent ablated to zero):**
+> {q}**{abl_gen}**
+
+<sub>This shows the latent's raw *effect* on generation, not a Q&A answer. The bridge was trained on
+key-recall (ablation with={wl:.3f} vs without={nl:.4f}), so the injected latent pushes the asker toward
+that learned behavior — which is why WITH and WITHOUT differ so sharply. The clean proof the latent
+carries real information is the **Bridge** tab.</sub>"""
+
+
+@_gpu(duration=120)
+def moe_combine(query, max_new, blend, consult):
+    """Two blends compared at the same mix ratio: a real WEIGHT-MERGE (one merged model) vs an
+    OUTPUT-BLEND (two models run separately, distributions averaged)."""
+    yield _loading_notice("Building merge + blending")
+    moe = _to_gpu(_get_moe()(DEVICE))
+    if not getattr(moe, "merge_available", lambda: False)():
+        yield "### 🧬 Needs both specialists loaded."
+        return
+    q = (query or "").strip() or "The water cycle works by"
+    a = float(blend)
+    merged_gen = moe.merge_generate(q, alpha=a, max_new=int(max_new), consult=bool(consult))
+    blend_gen = moe.combine(q, max_new=int(max_new), blend=a, consult=bool(consult))
+    _WARMED["done"] = True
+    mix = f"{int(round((1-a)*100))}% 📖 Language / {int(round(a*100))}% ➗ Math"
+    extra = "  ·  +Reasoning's latent (consult)" if consult else ""
+    yield f"""### 🧬 MoE Modular Minds — two ways to blend  ·  {mix}{extra}
+
+**① Weight merge** — a *single* model whose weights are `(1-α)·Language + α·Math` — one network, one forward pass:
+> {q}**{merged_gen}**
+
+**② Output blend** — both models run separately, their next-token distributions averaged each step:
+> {q}**{blend_gen}**
+
+<sub>Same mix ratio, two different mechanisms. **Weight merge** fuses the actual parameters into one model
+(only possible because they're the identical dense architecture); **output blend** is an inference-time
+ensemble of two separate models (only possible because they share the 16k tokenizer). Tick *consult* to also
+route Reasoning's latent into each through the trained bridge. Exploratory — generations are rough at this scale.</sub>"""
+
+
+HERO = """# 🧩 Modular Mind — two specialists that talk in latent space
+**Two ~80M models trained completely separately** — 📖 **Language** on FineWeb-Edu, ➗ **Math** on
+FineMath — that never saw each other's data. A coordinator **routes** your query to the right one,
+and a trained **RecursiveLink** lets them **communicate through latent space**: Language can read
+information straight out of Math's "mind." The **🔑 Bridge** tab proves it.
+
+> ℹ️ *These specialists were trained only to demonstrate a **verifiable result** — clean routing and a
+> provable latent-bridge ablation — **not** for production-quality output. The generated text is
+> intentionally rough at this scale; the mechanism is the point.*"""
+
+BRIDGE_INTRO = """### The proof: two independent models, one latent channel
+A random secret key is shown **only to ➗ Math**. 📖 Language never sees it — but by reading Math's
+latent through the trained RecursiveLink, it **reproduces the key**. Zero out the latent and it
+collapses to chance. That gap *is* the result: real information crossing between two models that
+were trained on different data and never met. **Hit the button.**"""
+
+INTRO_BYTE = """## 🧩 Experiment — Modular Mind as a Mixture of Experts
+Three tiny ~10M byte-level specialists (language, math, tool-use), each streamed-trained on its own
+dataset. A coordinator **routes** your query to whichever expert is most fluent (perplexity-based MoE)
+and fuses their latents through a **RecursiveLink**. Try a math problem vs. a sentence."""
+
+
+def _routing_block():
+    with gr.Row():
+        q = gr.Textbox(label="Your prompt", value="Solve for x: 2x + 3 = 11",
+                       scale=4, placeholder="a sentence or a math problem…")
+        n = gr.Slider(40, 300, value=80, step=20, label="generate tokens", scale=1)
+    btn = gr.Button("🧭 Route & generate", variant="primary")
+    out = gr.Markdown()
+    btn.click(moe_run, [q, n], out)
+    gr.Examples(examples=[["The theory of evolution explains", 80],
+                          ["Compute the derivative of x^2 + 3x", 80],
+                          ["The history of the Roman Empire began", 80]],
+                inputs=[q, n])
+
+
+def build_moe_panel():
+    """Create the MoE demo components inside the current gr.Blocks context."""
+    if not _SPIKEWHALE:
+        with gr.Accordion("🧩 Experiment: Modular Mind = Mixture of Experts (3 specialists)", open=False):
+            gr.Markdown(INTRO_BYTE)
+            _routing_block()
+        return
+
+    with gr.Accordion("🧩 Modular Mind — independent specialists communicating in latent space", open=True):
+        gr.Markdown(HERO)
+        with gr.Tabs():
+            # The headline result, FIRST.
+            with gr.Tab("🔑 The latent bridge — the proof"):
+                gr.Markdown(BRIDGE_INTRO)
+                with gr.Row():
+                    kn = gr.Slider(4, 16, value=8, step=1, label="keys to test", scale=3)
+                    kbtn = gr.Button("🔑 Run the proof", variant="primary", scale=1)
+                kout = gr.Markdown()
+                kbtn.click(moe_key_recall, [kn], kout)
+
+            # Routing — the supporting act.
+            with gr.Tab("🧭 Routing & generation"):
+                gr.Markdown("Type a math problem vs. a sentence and watch the **route flip** — each "
+                            "expert is most fluent (lowest bits/byte) on its own domain.")
+                _routing_block()
+
+            # Latent influence — honest "with vs without".
+            with gr.Tab("🔗 Latent influence"):
+                gr.Markdown(
+                    "Inject ➗ Math's latent into 📖 Language through the **trained RecursiveLink** and "
+                    "see generation **with vs without** it. The bridge was trained on key-recall, so the "
+                    "latent *steers* the output (it doesn't answer the question) — the point is how "
+                    "strongly it changes generation. The clean proof is the **Bridge** tab.")
+                with gr.Row():
+                    cq = gr.Textbox(label="Text to encode (Math's latent → injected into Language)",
+                                    value="natural selection", scale=4)
+                    cn = gr.Slider(40, 200, value=80, step=20, label="generate tokens", scale=1)
+                cbtn = gr.Button("🔗 Show latent influence (with vs without)", variant="secondary")
+                cout = gr.Markdown()
+                cbtn.click(moe_consult, [cq, cn], cout)
+
+            # MoE Modular Minds — TWO ways to blend the specialists, compared side by side.
+            with gr.Tab("🧬 MoE Modular Minds"):
+                gr.Markdown(
+                    "**Two ways to blend the two specialists**, shown side by side at the same mix ratio:\n"
+                    "- **① Weight merge** — fuse the *parameters* into one model `(1-α)·Language + α·Math` "
+                    "(works because they're the identical dense architecture).\n"
+                    "- **② Output blend** — run both models separately and average their next-token "
+                    "distributions (works because they share the 16k tokenizer).\n\n"
+                    "Slide the mix, and tick *consult* to also route Reasoning's latent into each through the "
+                    "trained bridge.")
+                with gr.Row():
+                    mq = gr.Textbox(label="Prompt", value="The water cycle works by", scale=4)
+                    mn = gr.Slider(40, 160, value=70, step=10, label="generate tokens", scale=1)
+                with gr.Row():
+                    mblend = gr.Slider(0.0, 1.0, value=0.5, step=0.1,
+                                       label="mix α:  0 = 📖 Language   ⟷   1 = ➗ Math", scale=3)
+                    mconsult = gr.Checkbox(value=False, label="consult (inject Reasoning's latent)", scale=1)
+                mbtn = gr.Button("🧬 Blend both ways (weight-merge vs output-blend)", variant="primary")
+                mout = gr.Markdown()
+                mbtn.click(moe_combine, [mq, mn, mblend, mconsult], mout)

piano/poly_mind.py

@@ -111,12 +111,23 @@ def train_and_save(notes=os.path.join(HERE, "poly_notes.json"),
 
 
 class PolyPlayer:
-    def __init__(self, weights=os.path.join(HERE, "poly_weights.pt")):
-        ck = torch.load(weights, map_location="cpu")
-        self.n, self.K, self.fps = ck["n_tokens"], ck["K"], ck["fps"]
-        self.tok2midi = {int(k): int(v) for k, v in ck["tok2midi"].items()}
-        self.seed = ck["seed"]
-        self.model = PolyMind(self.n); self.model.load_state_dict(ck["state"]); self.model.eval()
+    def __init__(self, weights=None):
+        sft = os.path.join(HERE, "poly_weights.safetensors")
+        if weights is None and os.path.exists(sft):
+            from safetensors.torch import load_file
+            from safetensors import safe_open
+            state = load_file(sft)
+            with safe_open(sft, framework="pt") as f:
+                md = f.metadata() or {}
+            self.n = int(md["n_tokens"]); self.K = int(md["K"]); self.fps = int(md["fps"])
+            self.tok2midi = {int(k): int(v) for k, v in json.loads(md["tok2midi"]).items()}
+            self.seed = json.loads(md["seed"])
+        else:
+            ck = torch.load(weights or os.path.join(HERE, "poly_weights.pt"), map_location="cpu")
+            self.n, self.K, self.fps = ck["n_tokens"], ck["K"], ck["fps"]
+            self.tok2midi = {int(k): int(v) for k, v in ck["tok2midi"].items()}
+            self.seed = ck["seed"]; state = ck["state"]
+        self.model = PolyMind(self.n); self.model.load_state_dict(state); self.model.eval()
 
     @torch.no_grad()
     def next_frame(self, history, thresh=0.45, maxn=4):

piano/poly_weights.safetensors

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

requirements.txt

@@ -1,4 +1,6 @@
-gradio==6.16.0  # must match the version pinned by the HuggingFace Spaces base image; mismatched pin breaks the Space build
+gradio==6.15.2
 numpy>=1.24
-torch>=2.2          # the bottom "Mixture of Experts" experiment (lazy-loaded)
+torch>=2.2          # the bottom "Mixture of Experts" experiment + the piano model
 transformers>=4.40  # SpikeWhale config/model + SpikeTokenizer (agents/modmind/)
+safetensors>=0.4    # all model weights ship as slim fp16 .safetensors
+spaces              # ZeroGPU: @spaces.GPU decorator for the 80M MoE inference