@@ -237,6 +237,8 @@ function filterPlan(
 ): BenchInteractionPlan {
   return {
     focusedRowId: null,
+    collapsedGroupKey: null,
+    collapsedGroupRowCount: 0,
     filters,
     mode,
     probeColumnId: Object.keys(filters)[0] ?? "",
 
@@ -5,6 +5,7 @@ import type {
   ScenarioDataset,
   ScenarioRow,
 } from "@pretable-internal/scenario-data";
+import { createScenarioDataset } from "@pretable-internal/scenario-data";
 
 const pretableAdapterSpy = vi.hoisted(() => vi.fn());
 
@@ -187,6 +188,35 @@ const keystrokeRows = (values: string[]) =>
     (value, index) => ({ id: `row-${index}`, col_0: value }) as ScenarioRow,
   );
 
+describe("the group-expand plan's collapse target", () => {
+  test("names the sorted-first group and its row count", () => {
+    const dataset = createScenarioDataset("S2", { scale: "dev" });
+    const plan = createBenchInteractionPlan(dataset, "group-expand");
+    expect(plan).not.toBeNull();
+    // Sorted-first key of the grouping column, computed independently of the
+    // builder so this test can disagree with it.
+    const groupColumnId = plan!.rowGroups[0]!;
+    const keys = [
+      ...new Set(dataset.rows.map((row) => String(row[groupColumnId] ?? ""))),
+    ].sort();
+    expect(plan!.collapsedGroupKey).toBe(keys[0]);
+    expect(plan!.collapsedGroupRowCount).toBe(
+      dataset.rows.filter((row) => String(row[groupColumnId] ?? "") === keys[0])
+        .length,
+    );
+    // Data that can disprove: an empty collapsed group would make the
+    // toggle measure nothing.
+    expect(plan!.collapsedGroupRowCount).toBeGreaterThan(0);
+  });
+
+  test("every other mode carries no collapse target", () => {
+    const dataset = createScenarioDataset("S2", { scale: "dev" });
+    const groupPlan = createBenchInteractionPlan(dataset, "group");
+    expect(groupPlan!.collapsedGroupKey).toBeNull();
+    expect(groupPlan!.collapsedGroupRowCount).toBe(0);
+  });
+});
+
 describe("createBenchFilterKeystrokePlans", () => {
   // Fixture graded against the FULL needle "Bonjour depuis Pretable token-123"
   // (#509). Counts by hand (case-insensitive contains): "B":6 (all but
 
@@ -5,7 +5,7 @@ import {
   screen,
   waitFor,
 } from "@testing-library/react";
-import { afterEach, describe, expect, test, vi } from "vitest";
+import { afterEach, describe, expect, onTestFinished, test, vi } from "vitest";
 
 import { BENCH_RESULT_KEY } from "../bench-runtime";
 import * as benchRuntime from "../bench-runtime";
@@ -525,6 +525,121 @@ describe("BenchApp", () => {
     expect(groupRowsAtCallTime).toBeGreaterThan(0);
   }, 20_000);
 
+  test("groups the TANSTACK grid BEFORE the group-expand measurement window opens", async () => {
+    // The comparator twin of the pretable test above (#478): the setup wait
+    // is DOM-only and reads the per-profile groupRowSelector, so the same
+    // invariant must hold with tanstack's painted rows.
+    //
+    // jsdom reports zero offsetWidth/offsetHeight and ships no
+    // ResizeObserver, so @tanstack/react-virtual collapses to an empty
+    // viewport and paints nothing — the same shim
+    // tanstack-adapter.test.tsx installs, here scoped to this test so the
+    // pretable paint tests keep jsdom's real (zero) layout.
+    if (!("ResizeObserver" in globalThis)) {
+      class StubResizeObserver {
+        observe() {}
+        unobserve() {}
+        disconnect() {}
+      }
+      (
+        globalThis as unknown as { ResizeObserver: typeof StubResizeObserver }
+      ).ResizeObserver = StubResizeObserver;
+    }
+    const baseOffsetWidth = Object.getOwnPropertyDescriptor(
+      HTMLElement.prototype,
+      "offsetWidth",
+    );
+    const baseOffsetHeight = Object.getOwnPropertyDescriptor(
+      HTMLElement.prototype,
+      "offsetHeight",
+    );
+    Object.defineProperty(HTMLElement.prototype, "offsetWidth", {
+      configurable: true,
+      get(this: HTMLElement) {
+        if (this.hasAttribute?.("data-pretable-bench-tanstack-viewport"))
+          return 720;
+        return (baseOffsetWidth?.get?.call(this) as number | undefined) ?? 0;
+      },
+    });
+    Object.defineProperty(HTMLElement.prototype, "offsetHeight", {
+      configurable: true,
+      get(this: HTMLElement) {
+        if (this.hasAttribute?.("data-pretable-bench-tanstack-viewport"))
+          return 320;
+        return (baseOffsetHeight?.get?.call(this) as number | undefined) ?? 0;
+      },
+    });
+    onTestFinished(() => {
+      if (baseOffsetWidth) {
+        Object.defineProperty(HTMLElement.prototype, "offsetWidth", {
+          ...baseOffsetWidth,
+          configurable: true,
+        });
+      }
+      if (baseOffsetHeight) {
+        Object.defineProperty(HTMLElement.prototype, "offsetHeight", {
+          ...baseOffsetHeight,
+          configurable: true,
+        });
+      }
+    });
+
+    let groupRowsAtCallTime = -1;
+    let modeAtCallTime: string | null = null;
+
+    vi.spyOn(benchRuntime, "measureBenchInteractionRun").mockImplementation(
+      async (_root, _adapterId, mode) => {
+        modeAtCallTime = mode;
+        groupRowsAtCallTime = document.querySelectorAll(
+          "[data-tanstack-group-row]",
+        ).length;
+
+        return {
+          status: "completed",
+          notes: [`interaction mode: ${mode}`],
+          metrics: {
+            interaction_latency_ms: 9,
+            settle_duration_ms: 8,
+            post_interaction_blank_gap_frames: 0,
+            post_interaction_anchor_shift_px: 0,
+            post_interaction_row_height_error_p95_px: 0,
+            post_interaction_row_height_error_measurable_rows: 11,
+            result_row_count: 40,
+            selected_row_preserved: 1,
+            focused_row_preserved: 1,
+            dom_nodes_peak: 400,
+            rendered_rows_peak: 11,
+            rendered_cells_peak: 440,
+          },
+        };
+      },
+    );
+
+    render(
+      <BenchApp
+        search="?adapter=tanstack&scenario=S2&scale=smoke&script=group-expand&autorun=1"
+        browserVersion="123.0"
+      />,
+    );
+
+    await waitFor(
+      () => {
+        expect(window[BENCH_RESULT_KEY]).toMatchObject({
+          status: "completed",
+          adapterId: "tanstack",
+          scenarioId: "S2",
+          scriptName: "group-expand",
+        });
+      },
+      { timeout: 15_000 },
+    );
+
+    expect(modeAtCallTime).toBe("group-expand");
+    // Row virtualization means only the group rows inside the viewport are in
+    // the DOM, so this is "at least one", not "all".
+    expect(groupRowsAtCallTime).toBeGreaterThan(0);
+  }, 20_000);
+
   test("declines to measure group-expand when the grouping never paints", async () => {
     // The CI failure this pins: the row MODEL settles several frames before
     // React commits the paint, so gating the wait on the model alone opened the
 
@@ -22,6 +22,7 @@ import {
   waitForRenderedRowBaseline,
   readBenchGridInstanceId,
   readRenderedFontStack,
+  scrollRuntimeProfiles,
   UNREADABLE_FONT_STACK,
 } from "../bench-runtime";
 import { benchUpdatesExcludedColumnIds } from "../interaction-plan";
@@ -2146,6 +2147,27 @@ function installFrameStub(pending: {
   };
 }
 
+describe("groupRowSelector", () => {
+  test("the group-capable adapters declare the selector their renderer paints", () => {
+    // These literals are the coupling #483 made load-bearing: the selector
+    // decides completed-vs-partial for the grouping scripts. A profile whose
+    // selector doesn't match what its renderer paints produces NO numbers
+    // (partial, every run), which reads as flake rather than a broken
+    // harness — so pin the exact strings.
+    expect(scrollRuntimeProfiles.pretable.groupRowSelector).toBe(
+      "[data-pretable-group-row]",
+    );
+    expect(scrollRuntimeProfiles.tanstack.groupRowSelector).toBe(
+      "[data-tanstack-group-row]",
+    );
+  });
+
+  test("the tier-excluded adapters declare none", () => {
+    expect(scrollRuntimeProfiles["ag-grid"].groupRowSelector).toBeUndefined();
+    expect(scrollRuntimeProfiles.mui.groupRowSelector).toBeUndefined();
+  });
+});
+
 describe("readBenchGridInstanceId", () => {
   function createProbeRoot(markup: string) {
     document.body.innerHTML = `<div data-testid="root">${markup}</div>`;
 
@@ -49,6 +49,8 @@ function filterPlan(
 ): BenchInteractionPlan {
   return {
     focusedRowId: null,
+    collapsedGroupKey: null,
+    collapsedGroupRowCount: 0,
     filters,
     mode,
     probeColumnId: Object.keys(filters)[0] ?? "",
 
@@ -135,6 +135,55 @@ describe("PretableAdapter", () => {
     surfaceSpy.mockRestore();
   });
 
+  test("the collapse handle collapses exactly the group the plan names", async () => {
+    const dataset = createScenarioDataset("S2", { scale: "smoke" });
+    const plan = createBenchInteractionPlan(dataset, "group-expand")!;
+    expect(plan.collapsedGroupKey).not.toBeNull();
+    expect(plan.collapsedGroupRowCount).toBeGreaterThan(0);
+
+    const surfaceSpy = vi.spyOn(pretableReactInternal, "PretableSurface");
+    let collapse: ((groupKey: string) => void) | null = null;
+
+    render(
+      <PretableAdapter
+        dataset={dataset}
+        runKey={1}
+        scriptName="group-expand"
+        interactionPlan={plan}
+        onGroupToggleReady={(fn) => {
+          collapse = fn;
+        }}
+      />,
+    );
+
+    const model = (surfaceSpy.mock.calls.at(-1)?.[0] as unknown as SurfaceProps)
+      .model;
+    expect(model).toBeTruthy();
+    expect(collapse).not.toBeNull();
+
+    // The grouped SETUP settles cooperatively post-#321 — poll the snapshot,
+    // never assert synchronously.
+    const groupedRowCount =
+      dataset.rows.length +
+      new Set(dataset.rows.map((row) => String(row[plan.rowGroups[0]!] ?? "")))
+        .size;
+    await waitFor(() => {
+      expect(model!.getState().snapshot.visibleRowCount).toBe(groupedRowCount);
+    });
+
+    act(() => collapse!(plan.collapsedGroupKey!));
+
+    // Every group row survives; the collapsed group's data rows do not — a
+    // wrong-group collapse changes this delta.
+    await waitFor(() => {
+      expect(model!.getState().snapshot.visibleRowCount).toBe(
+        groupedRowCount - plan.collapsedGroupRowCount,
+      );
+    });
+
+    surfaceSpy.mockRestore();
+  });
+
   test("installs the internal diagnostics controller only for explicit diagnostic runs and removes it on unmount", async () => {
     const dataset = createScenarioDataset("S5", { scale: "smoke" });
     const { unmount } = render(