feat(h07): DimensionsTab Apply dispatches brick params mutation

Closes V5-G19 from the App.tsx side: the DimensionsTab Apply button
previously fired a callback that the parent ignored, so the inferred
dimension never made it back into the spec — the table just kept
showing the same auto-row forever.

Now:
  - Sidebar exposes `onDimensionsApply` and threads it into DimensionsTab.
  - App's handler writes `entry.value` into the matching brick's
    `node.data.params[entry.param]`.
  - The verify debouncer's nodesKey now includes a JSON-serialised
    params hash, so the spec mutation re-triggers verify and the
    Dimensions table re-renders the row with source="user".

Tests:
- vbgui vitest Sidebar.test.tsx: new "H07: Sidebar forwards
  onDimensionsApply to DimensionsTab" — 27/27 Sidebar tests passing.
- vbgui vitest full suite: 201/201 passing.
- vbgui e2e 61_dimensions_feedback.spec.ts: load llama3_8b → open
  Dimensions → click first auto-Apply → assert source badge flips to
  "user" (or row drops entirely when the inferred value coincides with
  a user-set default), 1/1 passing.
- vbgui e2e V6 suite (55–61) + canvas smoke regression: 15/15 passing
  — no regression in verify-after-mutation flow.

Author: apstenku123

vbgui/e2e/scenarios/61_dimensions_feedback.spec.ts

@@ -0,0 +1,56 @@
+// H07: DimensionsTab Apply dispatches a brick params mutation, and the
+// next verify cycle re-classifies the affected entry from
+// source="auto" → source="user" (closing the feedback loop).
+//
+// Closes V5-G19 from the UI side: previously the Apply button only
+// fired the callback locally; App.tsx ignored it. Now App writes the
+// inferred value back into the matching node.data.params, the verify
+// debouncer fires, and the row's source badge flips.
+
+import { test, expect } from "@playwright/test";
+import { gotoApp, selectPreset } from "../fixtures";
+
+test("H07: Apply on an auto-row flips its source badge to user",
+  async ({ page }) => {
+    test.setTimeout(60_000);
+    await gotoApp(page);
+    await selectPreset(page, "llama3_8b");
+
+    // Open Dimensions tab and wait for at least one auto row to appear
+    // (mlp bricks have intermediate_size + activation auto-inferred).
+    await page.getByTestId("sidebar-tab-dimensions").click();
+    await page.getByTestId("dimensions-tab").waitFor();
+
+    // Pick the first auto Apply button on the page.
+    const applyBtn = page.locator(
+      "[data-testid^='dim-row-'][data-testid$='-apply']").first();
+    await applyBtn.waitFor({ timeout: 8_000 });
+
+    // The button's testid encodes brick + param: dim-row-<brick>-<param>-apply.
+    const tid = await applyBtn.getAttribute("data-testid");
+    expect(tid).toBeTruthy();
+    const match = tid!.match(/^dim-row-(.+)-(.+)-apply$/);
+    expect(match).not.toBeNull();
+    const [, brick, param] = match!;
+
+    // Pre-state: source badge for this row is "auto".
+    const sourceBadge = page.getByTestId(`dim-source-${brick}-${param}`);
+    expect((await sourceBadge.textContent())?.trim().toLowerCase())
+      .toBe("auto");
+
+    // Click Apply — App writes the value into node.data.params and
+    // verify-after-mutation re-renders the table.
+    await applyBtn.click();
+
+    // Wait for the badge text to flip to "user" (verify debounce + render).
+    await expect.poll(
+      async () => {
+        const b = page.getByTestId(`dim-source-${brick}-${param}`);
+        const cnt = await b.count();
+        if (cnt === 0) return "missing";
+        const t = await b.textContent();
+        return (t ?? "").trim().toLowerCase();
+      },
+      { timeout: 8_000 },
+    ).toMatch(/^(user|missing)$/);
+  });

vbgui/src/App.tsx

@@ -187,8 +187,14 @@ export function App(): JSX.Element {
   // Trigger verify only on inputs that the user controls. The verify
   // response writes back into spec AND edge severity — depending on
   // either of those in the effect would loop. Use structural keys.
-  const nodesKey = nodes.map((n) => `${n.id}:${(n.data as { kind?: string })
-                                                   ?.kind ?? ""}`).join("|");
+  // H07: include params hash so the verify debouncer re-fires when the
+  // user mutates brick.data.params via DimensionsTab Apply or
+  // BrickContextPanel. Without this, the inferred-dimensions feedback
+  // loop never closed because the table reflected stale verify state.
+  const nodesKey = nodes.map((n) => {
+    const d = n.data as { kind?: string; params?: Record<string, unknown> };
+    return `${n.id}:${d.kind ?? ""}:${JSON.stringify(d.params ?? {})}`;
+  }).join("|");
   const edgesKey = edges.map((e) => `${e.source}>${e.target}`).join("|");
   const lossKey = `${spec.loss.kind}::${spec.loss.head_outputs.join(",")}`;
   const optimKey = `${spec.optim.kind}::${spec.optim.groups.length}`;
@@ -532,6 +538,23 @@ export function App(): JSX.Element {
                 onShardingChange={(s) =>
                   dispatch({ type: "sharding.set", sharding: s })}
                 onShardingAccept={handleShardingAccept}
+                onDimensionsApply={(entry) => {
+                  // H07: write the auto-suggested value into the matched
+                  // brick's params. Re-verify will then re-render the
+                  // entry as source="user" (or drop it entirely if the
+                  // inference no longer fires), closing the feedback loop.
+                  setNodes((prev) => prev.map((n) => {
+                    if (n.id !== entry.brick) return n;
+                    const d = (n.data ?? {}) as {
+                      kind?: string; params?: Record<string, unknown>;
+                    };
+                    return { ...n, data: {
+                      ...d,
+                      params: { ...(d.params ?? {}),
+                                [entry.param]: entry.value },
+                    } as never };
+                  }));
+                }}
               />
             </>
           )}

vbgui/src/components/Sidebar.tsx

@@ -47,6 +47,9 @@ export interface SidebarProps {
   /** E7-2: inferred dimensions populated from verify response. */
   inferenceLog?: InferenceEntryClient[];
   onHighlightBrick?: (brick: string) => void;
+  /** H07: parent dispatches the per-brick params mutation when the
+   *  user clicks Apply on an auto-inferred row in DimensionsTab. */
+  onDimensionsApply?: (entry: InferenceEntryClient) => void;
 }
 
 const TAB_LABELS: { key: SidebarTab; label: string }[] = [
@@ -121,7 +124,8 @@ export function Sidebar(p: SidebarProps): JSX.Element {
         )}
         {active === "dimensions" && (
           <DimensionsTab log={p.inferenceLog ?? []}
-                          onHighlight={p.onHighlightBrick} />
+                          onHighlight={p.onHighlightBrick}
+                          onApply={p.onDimensionsApply} />
         )}
         {active === "ablations" && (
           <AblationsTab rpc={p.rpc ?? null}

vbgui/tests/Sidebar.test.tsx

@@ -312,4 +312,16 @@ describe("Sidebar", () => {
     fireEvent.click(screen.getByTestId("sidebar-tab-gotchas"));
     expect(screen.getByTestId("gotchas-tab")).toBeTruthy();
   });
+
+  it("H07: Sidebar forwards onDimensionsApply to DimensionsTab", () => {
+    const onDimensionsApply = vi.fn();
+    const entry = { brick: "attn0", param: "head_dim", value: 64,
+                    source: "auto" as const, reason: "inferred from H/nh" };
+    render(<Sidebar {...stubs}
+            inferenceLog={[entry]}
+            onDimensionsApply={onDimensionsApply} />);
+    fireEvent.click(screen.getByTestId("sidebar-tab-dimensions"));
+    fireEvent.click(screen.getByTestId("dim-row-attn0-head_dim-apply"));
+    expect(onDimensionsApply).toHaveBeenCalledWith(entry);
+  });
 });