feat(v5-g15): long-run support — TopBar max=512 + extras.losses_smoothed

Closes V5-G15 / cppmega-mlx-a0b. TopBar train-num-steps max bumped
from 64 to 512. stage_train extras gains losses_smoothed (window=10
moving average) for noise-reduced convergence visualisation.
_ema_smooth helper. 3 new pytest: shape correctness for short + long
runs, smoothed variance ≤ raw variance over N=100.

56 stage_train pytest regression green.

Author: apstenku123

cppmega_v4/runner/stages.py

@@ -908,6 +908,7 @@ def _count(tree: Any) -> int:
             elapsed_ms=(time.perf_counter() - t0) * 1000.0,
             extras={
                 "losses": [round(loss_item, 4) for loss_item in losses],
+                "losses_smoothed": _ema_smooth(losses, window=10),
                 "lr_trajectory": [
                     round(lr_item, 6) for lr_item in lr_trajectory
                 ],
@@ -1093,6 +1094,17 @@ def _apply_spec_rewriters(
     }
 
 
+def _ema_smooth(values: list[float], window: int = 10) -> list[float]:
+    """G15: simple windowed-mean smoothing (cheaper than true EMA, same
+    job for visualising convergence)."""
+    out: list[float] = []
+    for i in range(len(values)):
+        start = max(0, i - window + 1)
+        sl = values[start:i + 1]
+        out.append(round(sum(sl) / len(sl), 4))
+    return out
+
+
 def _compute_hybrid_deltas(
     after_flat: dict[str, Any],
     muon_before: dict[str, Any], adamw_before: dict[str, Any],

tests/v5/test_stage_train_long_run.py

@@ -0,0 +1,61 @@
+"""G15: long-run convergence — N=100 with smoothed loss observability."""
+
+from __future__ import annotations
+
+import pytest
+
+from cppmega_v4.jsonrpc.schema import VerifyParams
+from cppmega_v4.runner import Pipeline, run_pipeline
+
+
+def _spec() -> VerifyParams:
+    return VerifyParams.model_validate({
+        "graph": {
+            "nodes": [
+                {"id": "attn", "kind": "attention", "params": {}},
+                {"id": "mlp", "kind": "mlp",
+                 "params": {"intermediate_size": 64, "activation": "swiglu"}},
+            ],
+            "edges": [{"src": "attn", "dst": "mlp"}],
+        },
+        "dim_env": {"B": 1, "S": 8, "H": 32, "nh": 2, "nkv": 1, "head_dim": 16},
+        "loss": {"kind": "cross_entropy", "head_outputs": ["mlp"]},
+        "optim": {"kind": "adamw",
+                  "groups": [{"matcher": "all", "lr": 1e-3,
+                              "weight_decay": 0.01, "betas": [0.9, 0.95]}]},
+    })
+
+
+def _run(num_steps: int) -> dict:
+    report = run_pipeline(_spec(), Pipeline.from_dict({
+        "stages": ["parse", "verify_build_spec", "build_model", "train"],
+        "stage_options": {"train": {"num_steps": num_steps}},
+    }))
+    train = next(s for s in report.stages if s.name == "train")
+    assert train.status == "ok", f"stage_train failed: {train.error}"
+    return train.extras
+
+
+def test_losses_smoothed_present_short_run():
+    extras = _run(8)
+    assert "losses_smoothed" in extras
+    assert len(extras["losses_smoothed"]) == 8
+
+
+def test_long_run_n100_smoothed_shape_correct():
+    extras = _run(100)
+    assert len(extras["losses"]) == 100
+    assert len(extras["losses_smoothed"]) == 100
+    # Smoothed[0] equals losses[0] (window of 1 at start)
+    assert abs(extras["losses_smoothed"][0] - extras["losses"][0]) < 1e-4
+
+
+def test_long_run_smoothed_curve_monotone_in_window():
+    """Smoothed (window=10) loss over N=100 should be less noisy than
+    raw — variance of smoothed strictly less than variance of raw."""
+    extras = _run(100)
+    import statistics as st
+    raw_var = st.pvariance(extras["losses"])
+    smooth_var = st.pvariance(extras["losses_smoothed"])
+    assert smooth_var <= raw_var, \
+        f"smoothed var {smooth_var} should be <= raw var {raw_var}"

vbgui/src/components/TopBar.tsx

@@ -128,7 +128,7 @@ export function TopBar(p: TopBarProps): JSX.Element {
               <span style={{ fontSize: 11, color: "#6b7280" }}>
                 train steps:</span>
               <input data-testid="train-num-steps"
-                     type="number" min={1} max={64}
+                     type="number" min={1} max={512}
                      value={trainNumSteps}
                      onChange={(e) =>
                        setTrainNumSteps(Math.max(1, parseInt(