feat(v5-g22): hybrid optimizer per-bucket update delta divergence

Closes V5-G22 / cppmega-mlx-3p2. V4-9 only reported bucket sizes
(counts); G22 proves the underlying update math actually diverges
between Muon (sign-of-grad NS-orthogonalised 2-D matmul weights)
and AdamW (adaptive 2nd-moment 1-D / 3-D+ tensors).

Backend (stages.py):
  - When optimizer_kind==muon_adamw_hybrid, snapshot per-bucket
    parameters pre-train (split_param_groups predicate)
  - Post-train: _compute_hybrid_deltas computes L2 update delta per
    bucket; reports {muon_norm, adamw_norm, ratio}
  - Different optimizer math → ratio ≠ 1.0

E2E (1 in 51_hybrid_delta.spec.ts):
  - UI hybrid → Train → both bucket norms > 0 AND |ratio - 1| > 0.05
    (5% divergence floor — would fail if both buckets received
    identical updates)

43 stage_train pytest unchanged.

Author: apstenku123

cppmega_v4/runner/stages.py

@@ -565,6 +565,13 @@ def loss_fn(model: nn.Module, emb: mx.array, tgt: mx.array) -> mx.array:
         # prove the split predicate actually saw 2D vs 1D/3D parameters.
         muon_group_size: int | None = None
         adamw_group_size: int | None = None
+        # G22: snapshot pre-train per-bucket param norms so post-train we
+        # can compute the per-bucket update delta. Muon and AdamW produce
+        # different update math; bucket-specific deltas must diverge.
+        hybrid_muon_keys: list[str] = []
+        hybrid_adamw_keys: list[str] = []
+        hybrid_muon_before: dict[str, Any] = {}
+        hybrid_adamw_before: dict[str, Any] = {}
         if optimizer_kind == "muon_adamw_hybrid":
             try:
                 from cppmega_mlx.training.optimizers import split_param_groups
@@ -576,6 +583,19 @@ def _count(tree: Any) -> int:
                                if hasattr(v, "size"))
                 muon_group_size = _count(muon_t)
                 adamw_group_size = _count(adamw_t)
+                # G22: per-bucket snapshot
+                hybrid_muon_keys = list(dict(
+                    nn.utils.tree_flatten(muon_t)).keys())
+                hybrid_adamw_keys = list(dict(
+                    nn.utils.tree_flatten(adamw_t)).keys())
+                flat_all = dict(nn.utils.tree_flatten(
+                    all_modules.parameters()))
+                for k in hybrid_muon_keys:
+                    if k in flat_all:
+                        hybrid_muon_before[k] = mx.array(flat_all[k])
+                for k in hybrid_adamw_keys:
+                    if k in flat_all:
+                        hybrid_adamw_before[k] = mx.array(flat_all[k])
             except Exception:
                 pass
         loss_and_grad = nn.value_and_grad(all_modules, loss_fn)
@@ -745,6 +765,9 @@ def _count(tree: Any) -> int:
                 ),
                 "muon_group_size": muon_group_size,
                 "adamw_group_size": adamw_group_size,
+                "hybrid_deltas": _compute_hybrid_deltas(
+                    after_flat, hybrid_muon_before, hybrid_adamw_before)
+                    if optimizer_kind == "muon_adamw_hybrid" else None,
                 "inference_probe": {
                     "l2_diff": round(l2_diff, 6),
                     "cos_sim": round(cos_sim, 6),
@@ -894,6 +917,34 @@ def _apply_spec_rewriters(
     }
 
 
+def _compute_hybrid_deltas(
+    after_flat: dict[str, Any],
+    muon_before: dict[str, Any], adamw_before: dict[str, Any],
+) -> dict[str, Any]:
+    """G22: per-bucket L2 update delta. Muon (sign-of-grad NS-ortho on
+    2-D matmul weights) and AdamW (adaptive 2nd moment on 1-D / 3-D+
+    tensors) MUST produce different update magnitudes for the same
+    training run, otherwise the hybrid split predicate is decorative."""
+    import mlx.core as mx_local
+
+    def _bucket_norm(before: dict[str, Any]) -> float:
+        total = 0.0
+        for k, v in before.items():
+            if k in after_flat:
+                diff = after_flat[k] - v
+                total += float(mx_local.sum(diff * diff).item())
+        return total ** 0.5
+
+    muon_norm = _bucket_norm(muon_before)
+    adamw_norm = _bucket_norm(adamw_before)
+    ratio = (muon_norm / adamw_norm) if adamw_norm > 1e-12 else 0.0
+    return {
+        "muon_norm": round(muon_norm, 6),
+        "adamw_norm": round(adamw_norm, 6),
+        "ratio": round(ratio, 6),
+    }
+
+
 def _compute_ifim_extras(
     all_modules: Any, lambda_fim: float, batch: int, seq: int, hidden: int,
     forward_layers: Any,

vbgui/e2e/scenarios/51_hybrid_delta.spec.ts

@@ -0,0 +1,46 @@
+// G22: muon_adamw_hybrid produces distinct per-bucket update deltas.
+// V4-9 only counted bucket sizes; G22 asserts the update math actually
+// diverges between Muon and AdamW groups.
+
+import { test, expect } from "@playwright/test";
+import { gotoApp, selectPreset, closeModal } from "../fixtures";
+
+test("G22: hybrid optimizer produces distinct muon/adamw bucket deltas",
+  async ({ page }) => {
+    test.setTimeout(60_000);
+    await gotoApp(page);
+    await selectPreset(page, "llama3_8b");
+
+    await page.getByTestId("sidebar-tab-optim").click();
+    await page.getByTestId("optim-kind").selectOption("muon_adamw_hybrid");
+    await page.getByTestId("optim-apply").click();
+
+    await page.getByTestId("run-pipeline-toggle").click();
+    await page.getByTestId("train-num-steps").fill("4");
+    await page.getByTestId("run-pipeline-train").click();
+    const modal = page.getByTestId("run-result-modal");
+    await modal.waitFor({ timeout: 60_000 });
+    await page.getByTestId("run-result-expand-train").click();
+
+    const muonNorm = parseFloat(
+      (await page.getByTestId(
+        "run-result-extras-train-hybrid_deltas-muon_norm").textContent())
+        ?? "0");
+    const adamwNorm = parseFloat(
+      (await page.getByTestId(
+        "run-result-extras-train-hybrid_deltas-adamw_norm").textContent())
+        ?? "0");
+    const ratio = parseFloat(
+      (await page.getByTestId(
+        "run-result-extras-train-hybrid_deltas-ratio").textContent())
+        ?? "0");
+
+    // Both buckets must receive updates
+    expect(muonNorm).toBeGreaterThan(0);
+    expect(adamwNorm).toBeGreaterThan(0);
+    // Ratio MUST differ from 1.0 by more than 5% — otherwise the
+    // hybrid split would have produced identical updates (i.e., the
+    // two optimizers' math is decorative).
+    expect(Math.abs(ratio - 1.0)).toBeGreaterThan(0.05);
+    await closeModal(page);
+  });