feat(v5-g21): dry_forward / loss_smoke / optimizer_smoke return rich extras

Closes V5-G21 / cppmega-mlx-aih. Other-than-train pipeline stages
returned barebones results; now report observable fields:
  - dry_forward.{batch, seq_len, hidden, verdict, num_nodes}
  - loss_smoke.{loss_value, loss_finite, seq_len}
  - optimizer_smoke.{optimizer_kind, num_groups}

3/3 pytest + 79/79 broader regression green.

Author: apstenku123

cppmega_v4/runner/stages.py

@@ -253,13 +253,20 @@ def stage_dry_forward(ctx: StageContext) -> StageResult:
         graph = from_block_specs(specs, hidden_size=hidden, instantiate=False)
         result = dry_forward(graph, hidden_size=hidden, seq_len=seq, batch=batch)
         ctx.dry_forward_verdict = result.verdict
+        # G21: rich extras — observable B/S/H + verdict for modal display
+        rich: dict[str, Any] = {
+            "batch": batch, "seq_len": seq, "hidden": hidden,
+            "verdict": result.verdict,
+            "num_nodes": len(graph.nodes),
+        }
         return StageResult(
             name="dry_forward",
             status="ok" if result.verdict == "ok" else "fail",
             elapsed_ms=(time.perf_counter() - t0) * 1000.0,
             error=({"type": result.verdict, "detail": result.detail}
                    if result.verdict != "ok" else None),
             errors=0 if result.verdict == "ok" else 1,
+            extras=rich,
         )
     except Exception as exc:
         return _fail("dry_forward", t0, exc)
@@ -316,22 +323,37 @@ def stage_loss_smoke(ctx: StageContext) -> StageResult:
         logits = mx.random.normal((1, seq, 32))
         loss_value = mx.mean(mx.softmax(logits, axis=-1) * 0.0 + 1.0)
         finite = bool(mx.isfinite(loss_value).item())
+        # G21: rich extras — loss value + finite flag observable
         return StageResult(
             name="loss_smoke",
             status="ok" if finite else "fail",
             elapsed_ms=(time.perf_counter() - t0) * 1000.0,
             errors=0 if finite else 1,
             error=(None if finite
                    else {"type": "NonFiniteLoss", "detail": str(loss_value)}),
+            extras={
+                "loss_value": round(float(loss_value.item()), 6),
+                "loss_finite": finite,
+                "seq_len": seq,
+            },
         )
     except Exception as exc:
         return _fail("loss_smoke", t0, exc)
 
 
 def stage_optimizer_smoke(ctx: StageContext) -> StageResult:
-    """No-op for now — full optimizer.update wired in F-A.3 (training stage)."""
+    """G21: report optim kind + group counts observably."""
     t0 = time.perf_counter()
-    return _ok("optimizer_smoke", t0, note="placeholder until training stage lands")
+    spec_optim = getattr(ctx.spec, "optim", None)
+    kind = "adamw"
+    num_groups = 1
+    if spec_optim is not None:
+        kind = str(getattr(spec_optim, "kind", "adamw"))
+        groups = getattr(spec_optim, "groups", None) or []
+        num_groups = len(groups)
+    return _ok("optimizer_smoke", t0,
+               note="placeholder until training stage lands",
+               optimizer_kind=kind, num_groups=num_groups)
 
 
 def stage_train(ctx: StageContext) -> StageResult:

tests/v5/test_stage_extras_other.py

@@ -0,0 +1,53 @@
+"""G21: dry_forward / loss_smoke / optimizer_smoke return rich extras."""
+
+from __future__ import annotations
+
+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 _stages(stage_names: list[str]) -> dict[str, dict]:
+    r = run_pipeline(_spec(), Pipeline.from_dict({"stages": stage_names}))
+    return {s.name: s.to_dict() for s in r.stages}
+
+
+def test_dry_forward_rich_extras():
+    out = _stages(["parse", "verify_build_spec", "dry_forward"])
+    df = out["dry_forward"]
+    assert df["batch"] == 1
+    assert df["seq_len"] == 8
+    assert df["hidden"] == 32
+    assert df["num_nodes"] >= 1
+
+
+def test_loss_smoke_rich_extras():
+    out = _stages(["parse", "verify_build_spec", "loss_smoke"])
+    ls = out["loss_smoke"]
+    assert ls["loss_finite"] is True
+    assert ls["seq_len"] == 8
+    assert isinstance(ls["loss_value"], float)
+
+
+def test_optimizer_smoke_rich_extras():
+    out = _stages(["parse", "verify_build_spec", "optimizer_smoke"])
+    os_ = out["optimizer_smoke"]
+    assert os_["optimizer_kind"] == "adamw"
+    assert os_["num_groups"] == 1