feat(v3-7): AblationsTab math-divergence assertions

Closes V3-7 / cppmega-mlx-bws. Adds per-row testid ablation-final-{variant}
so e2e tests can read the final-loss column directly. New spec
13_ablation_math.spec.ts replaces v2's vacuous "rows >= 2" check with two
math-divergence assertions:

  1. activation axis (glu, swiglu, gelu, 4 steps): at least one
     pairwise |final_loss_a - final_loss_b| > 1e-3. Different
     activation kernels MUST produce numerically distinct outputs;
     identical losses would prove the axis switch never reached the model.

  2. optimizer axis (adamw, lion, 4 steps): |final_loss_adamw -
     final_loss_lion| > 1e-4. AdamW (adaptive 2nd-moment) and Lion
     (sign-based) are fundamentally different update rules — equal
     losses would indicate B1-style optimizer fallthrough.

2/2 e2e green, 166/166 vitest, testid rename avoided prefix collision
with existing 'ablation-row-' selectors.

Author: apstenku123

vbgui/e2e/scenarios/13_ablation_math.spec.ts

@@ -0,0 +1,93 @@
+// V3-7: AblationsTab axis variants must produce real loss / weight
+// divergence — not just N rows in a table. Closes the "AblationsTab
+// Run produces results table with variants" vacuous gap from v2.
+
+import { test, expect } from "@playwright/test";
+import { gotoApp, selectPreset } from "../fixtures";
+
+async function runAblation(
+  page: import("@playwright/test").Page,
+  axis: "activation" | "optimizer" | "norm" | "schedule",
+  variants: string[],
+  numSteps: number,
+): Promise<void> {
+  await page.getByTestId("sidebar-tab-ablations").click();
+  await page.getByTestId("ablations-tab").waitFor();
+  await page.getByTestId("ablation-axis").selectOption(axis);
+
+  // Tick only the requested variants — uncheck whatever's pre-selected.
+  const allLabels = page.locator("[data-testid^='ablation-variant-']");
+  const count = await allLabels.count();
+  for (let i = 0; i < count; i++) {
+    const label = allLabels.nth(i);
+    const tid = await label.getAttribute("data-testid");
+    const v = tid?.replace("ablation-variant-", "") ?? "";
+    const checkbox = label.locator("input[type='checkbox']");
+    const want = variants.includes(v);
+    const isChecked = await checkbox.isChecked();
+    if (want !== isChecked) await checkbox.click();
+  }
+
+  await page.getByTestId("ablation-num-steps").fill(String(numSteps));
+  await page.getByTestId("ablation-run").click();
+  await page.getByTestId("ablation-results").waitFor({ timeout: 60_000 });
+}
+
+async function rowFinal(
+  page: import("@playwright/test").Page, variant: string,
+): Promise<number> {
+  const text = await page.getByTestId(`ablation-final-${variant}`)
+    .textContent();
+  return parseFloat(text?.trim() ?? "NaN");
+}
+
+// ---------------------------------------------------------------------------
+// Activation axis: different activations should produce DIFFERENT final loss
+// ---------------------------------------------------------------------------
+
+test("activation ablation: glu vs swiglu vs gelu produce different losses",
+  async ({ page }) => {
+    test.setTimeout(120_000);
+    await gotoApp(page);
+    await selectPreset(page, "llama3_8b");
+    await runAblation(page, "activation", ["glu", "swiglu", "gelu"], 4);
+
+    const glu     = await rowFinal(page, "glu");
+    const swiglu  = await rowFinal(page, "swiglu");
+    const gelu    = await rowFinal(page, "gelu");
+
+    expect([glu, swiglu, gelu].every(Number.isFinite)).toBe(true);
+
+    // At least one pair must differ by > 1e-3 in absolute terms — proves
+    // the activation swap actually reached the model. Synthetic data
+    // makes exact ordering noisy but identical results are impossible.
+    const maxDiff = Math.max(
+      Math.abs(glu - swiglu),
+      Math.abs(swiglu - gelu),
+      Math.abs(glu - gelu),
+    );
+    expect(maxDiff).toBeGreaterThan(1e-3);
+  });
+
+// ---------------------------------------------------------------------------
+// Optimizer axis: AdamW vs Lion → different final loss (math divergence)
+// ---------------------------------------------------------------------------
+
+test("optimizer ablation: adamw vs lion final losses differ", async ({
+  page,
+}) => {
+  test.setTimeout(120_000);
+  await gotoApp(page);
+  await selectPreset(page, "llama3_8b");
+  await runAblation(page, "optimizer", ["adamw", "lion"], 4);
+
+  const adamw = await rowFinal(page, "adamw");
+  const lion  = await rowFinal(page, "lion");
+
+  expect(Number.isFinite(adamw) && Number.isFinite(lion)).toBe(true);
+
+  // AdamW and Lion are fundamentally different update rules — sign-only
+  // vs second-moment adaptive. Their final losses after 4 steps must
+  // differ. V2 only counted rows, this is the math-divergence proof.
+  expect(Math.abs(adamw - lion)).toBeGreaterThan(1e-4);
+});

vbgui/src/components/sidebar/AblationsTab.tsx

@@ -216,7 +216,8 @@ export function AblationsTab({
                     )}
                     <code>{r.variant}</code>
                   </td>
-                  <td style={td}>{final?.toFixed(4) ?? "—"}</td>
+                  <td data-testid={`ablation-final-${r.variant}`}
+                      style={td}>{final?.toFixed(4) ?? "—"}</td>
                   <td style={{ ...td,
                                 color: delta == null ? "#9ca3af"
                                        : delta > 0 ? "#dc2626" : "#16a34a" }}>