@@ -2,4 +2,4 @@
 "@hyperdx/hdx-eval": minor
 ---
 
-Add a Parquet-snapshot fast-seed path for the MCP eval suite (Milestone 2 — kill the seed bottleneck). Full-volume seed generation is a CPU-bound JS loop that takes hours; the snapshot path generates the data once, exports each eval table to Parquet, and on later runs loads the Parquet straight into ClickHouse (I/O-bound, ~an order of magnitude faster). New CLI commands: `export-snapshot`, `load-snapshot`, and `seed-logic-hash`. Rollup metadata tables repopulate automatically via the existing materialized views on load (then OPTIMIZE FINAL for deterministic state). In CI the snapshot is stored in an `actions/cache` entry keyed on a hash of the seed-generation source, so it is reused across runs and regenerated only when the seeding logic changes.
+Add a Parquet-snapshot fast-seed path for the MCP eval suite (Milestone 2 — kill the seed bottleneck). Full-volume seed generation is a CPU-bound JS loop that takes hours; the snapshot path generates the data once, exports each eval table to Parquet, and on later runs loads the Parquet straight into ClickHouse (I/O-bound, ~an order of magnitude faster). New CLI commands: `export-snapshot`, `load-snapshot`, and `seed-logic-hash`. The load path drops the rollup materialized views, bulk-inserts the raw Parquet (no per-block MV fan-out), then backfills the rollup tables in one shot using the same SELECTs the MVs run, and recreates the MVs — producing byte-identical rollup content much faster than letting the MVs fan out on the bulk insert. In CI the snapshot is stored in an `actions/cache` entry keyed on a hash of the seed-generation source, so it is reused across runs and regenerated only when the seeding logic changes.
@@ -14,6 +14,9 @@ import {
   writeManifest,
 } from './clickhouse/parquetSnapshot';
 import {
+  backfillRollups,
+  createRollupMaterializedViews,
+  dropRollupMaterializedViews,
   dropScenarioTables,
   ensureScenarioTables,
   scenarioIsSeeded,
@@ -402,6 +405,11 @@ program
         http,
         ensure: () => ensureScenarioTables(client, scenario.name),
         truncate: () => truncateScenarioTables(client, scenario.name),
+        dropMaterializedViews: tables =>
+          dropRollupMaterializedViews(client, tables),
+        backfillRollups: tables => backfillRollups(client, tables),
+        createMaterializedViews: tables =>
+          createRollupMaterializedViews(client, tables),
         scenarioName: scenario.name,
         dir,
       });
 
@@ -150,45 +150,57 @@ export type LoadResult = {
   totalRows: number;
 };
 
-/**
- * SummingMergeTree rollup tables accumulate one row per MV-insert block and
- * only collapse duplicate keys on background merge. Right after a bulk Parquet
- * load the parts are unmerged, so a plain `count()` over a rollup is inflated
- * (though `sum(count)` — how the HyperDX MCP reads them — is already correct).
- * OPTIMIZE FINAL forces the merge so the rollup state is deterministic and
- * matches a settled live seed. Best-effort: failures here don't fail the load.
- */
-async function optimizeRollups(
+/** Stream one Parquet file from disk into an INSERT over the HTTP interface. */
+async function insertParquetFile(
   http: ChHttp,
-  tables: ScenarioTables,
+  table: string,
+  filePath: string,
 ): Promise<void> {
-  const rollups = [
-    tables.tracesKvRollup,
-    tables.tracesKeyRollup,
-    tables.logsKvRollup,
-    tables.logsKeyRollup,
-  ];
-  for (const t of rollups) {
-    try {
-      await chExec(http, `OPTIMIZE TABLE ${EVAL_DATABASE}.${t} FINAL`);
-    } catch {
-      // Rollup may not exist for a scenario with no such data — ignore.
-    }
+  const query = `INSERT INTO ${EVAL_DATABASE}.${table} FORMAT Parquet`;
+  const url = `${http.url}/?query=${encodeURIComponent(query)}`;
+  // Node's fetch accepts a Readable body but requires `duplex: 'half'`; neither
+  // is in the DOM RequestInit type, so build the init as `unknown` and cast.
+  const init = {
+    method: 'POST',
+    headers: {
+      ...authHeaders(http),
+      'Content-Type': 'application/octet-stream',
+    },
+    body: createReadStream(filePath),
+    duplex: 'half',
+  } as unknown as RequestInit;
+  const res = await fetch(url, init);
+  if (!res.ok) {
+    const errText = await res.text().catch(() => '');
+    throw new Error(
+      `Parquet load of ${table} failed (${res.status}): ${errText.slice(0, 500)}`,
+    );
   }
 }
 
 /**
  * Load a previously exported Parquet snapshot for a scenario into ClickHouse.
- * Ensures the scenario tables + rollup MVs exist, truncates them, then inserts
- * each Parquet file. Because the MVs are attached before the insert, the rollup
- * metadata tables are repopulated automatically — no separate rollup snapshot
- * is needed.
+ *
+ * Fast path: rather than let the rollup materialized views fan out on the bulk
+ * insert (aggregating + writing the SummingMergeTree rollups per insert block,
+ * the dominant cost of a large load), we
+ *   1. drop the rollup MVs,
+ *   2. bulk-insert the raw Parquet with no fan-out,
+ *   3. backfill the rollups in one shot (same SELECTs the MVs run), and
+ *   4. recreate the MVs so any later inserts still maintain them.
+ * This produces byte-identical rollup content and is meaningfully faster at
+ * scale. The drop/backfill/recreate steps are supplied by the caller (they
+ * need the @clickhouse/client instance) via the same callback pattern as
+ * ensure/truncate.
  */
 export async function loadScenarioSnapshot(args: {
   http: ChHttp;
-  // The @clickhouse/client instance, used only for DDL (ensure/truncate).
+  // DDL callbacks backed by the @clickhouse/client instance.
   ensure: () => Promise<ScenarioTables>;
   truncate: () => Promise<void>;
+  dropMaterializedViews: (tables: ScenarioTables) => Promise<void>;
+  backfillRollups: (tables: ScenarioTables) => Promise<void>;
+  createMaterializedViews: (tables: ScenarioTables) => Promise<void>;
   scenarioName: string;
   dir: string;
 }): Promise<LoadResult> {
@@ -198,6 +210,10 @@ export async function loadScenarioSnapshot(args: {
   const tables = await args.ensure();
   await args.truncate();
 
+  // Detach the MVs so the raw bulk insert below does not trigger per-block
+  // rollup maintenance.
+  await args.dropMaterializedViews(tables);
+
   const files: LoadResult['files'] = [];
   let totalRows = 0;
 
@@ -206,35 +222,16 @@ export async function loadScenarioSnapshot(args: {
     const filePath = join(args.dir, snapshotFileName(table));
     if (!existsSync(filePath)) continue; // table had zero rows at export time
 
-    const query = `INSERT INTO ${EVAL_DATABASE}.${table} FORMAT Parquet`;
-    const url = `${args.http.url}/?query=${encodeURIComponent(query)}`;
-    // Stream the file from disk into the insert. Node's fetch accepts a
-    // Readable body but requires `duplex: 'half'`; neither is in the DOM
-    // RequestInit type, so build the init as `unknown` and cast.
-    const init = {
-      method: 'POST',
-      headers: {
-        ...authHeaders(args.http),
-        'Content-Type': 'application/octet-stream',
-      },
-      body: createReadStream(filePath),
-      duplex: 'half',
-    } as unknown as RequestInit;
-    const res = await fetch(url, init);
-    if (!res.ok) {
-      const errText = await res.text().catch(() => '');
-      throw new Error(
-        `Parquet load of ${table} failed (${res.status}): ${errText.slice(0, 500)}`,
-      );
-    }
+    await insertParquetFile(args.http, table, filePath);
     const rows = await tableRowCount(args.http, table);
     files.push({ table, rows });
     totalRows += rows;
   }
 
-  // Collapse the SummingMergeTree rollup parts so their state is deterministic
-  // (matches a settled live seed) rather than depending on background merges.
-  await optimizeRollups(args.http, tables);
+  // Rebuild the rollups in one shot from the loaded raw tables, then re-attach
+  // the MVs for consistency with a live-seeded scenario.
+  await args.backfillRollups(tables);
+  await args.createMaterializedViews(tables);
 
   return { files, totalRows };
 }
 
@@ -391,6 +391,90 @@ async function ensureRollupTables(
   });
 }
 
+/**
+ * Drop only the rollup materialized views (not the rollup tables). Used by the
+ * Parquet snapshot load path so a bulk raw insert does NOT trigger the MV
+ * fan-out (which is the dominant cost of a large load — each inserted block is
+ * aggregated and written to the SummingMergeTree rollups per-block, then merged).
+ * After the raw load we backfill the rollups in one shot and recreate the MVs.
+ */
+export async function dropRollupMaterializedViews(
+  client: ClickHouseClient,
+  tables: ScenarioTables,
+): Promise<void> {
+  const db = EVAL_DATABASE;
+  for (const mv of [
+    mvName(tables.tracesKvRollup),
+    keyMvName(tables.tracesKeyRollup),
+    mvName(tables.logsKvRollup),
+    keyMvName(tables.logsKeyRollup),
+  ]) {
+    await client.command({ query: `DROP VIEW IF EXISTS ${db}.${mv}` });
+  }
+}
+
+/** (Re)create just the rollup materialized views for a scenario's tables. */
+export async function createRollupMaterializedViews(
+  client: ClickHouseClient,
+  tables: ScenarioTables,
+): Promise<void> {
+  const db = EVAL_DATABASE;
+  await client.command({
+    query: `CREATE MATERIALIZED VIEW IF NOT EXISTS ${db}.${mvName(tables.tracesKvRollup)} TO ${db}.${tables.tracesKvRollup} AS ${tracesKvMvSelect(db, tables.traces)}`,
+  });
+  await client.command({
+    query: `CREATE MATERIALIZED VIEW IF NOT EXISTS ${db}.${keyMvName(tables.tracesKeyRollup)} TO ${db}.${tables.tracesKeyRollup} AS ${keyRollupMvSelect(db, tables.tracesKvRollup)}`,
+  });
+  await client.command({
+    query: `CREATE MATERIALIZED VIEW IF NOT EXISTS ${db}.${mvName(tables.logsKvRollup)} TO ${db}.${tables.logsKvRollup} AS ${logsKvMvSelect(db, tables.logs)}`,
+  });
+  await client.command({
+    query: `CREATE MATERIALIZED VIEW IF NOT EXISTS ${db}.${keyMvName(tables.logsKeyRollup)} TO ${db}.${tables.logsKeyRollup} AS ${keyRollupMvSelect(db, tables.logsKvRollup)}`,
+  });
+}
+
+/**
+ * One-shot bulk backfill of the rollup tables from already-loaded raw tables,
+ * reusing the exact same SELECTs the materialized views run. This is the fast
+ * alternative to letting the MVs fan out on a bulk Parquet insert: aggregating
+ * the whole table once is far cheaper than maintaining the SummingMergeTree
+ * incrementally per insert block. Produces byte-identical rollup content.
+ *
+ * Only backfills a raw table's rollups when that raw table has rows (so a
+ * traces-only scenario doesn't write empty log rollups).
+ */
+export async function backfillRollups(
+  client: ClickHouseClient,
+  tables: ScenarioTables,
+): Promise<void> {
+  const db = EVAL_DATABASE;
+
+  const hasRows = async (table: string): Promise<boolean> => {
+    const rs = await client.query({
+      query: `SELECT 1 FROM ${db}.${table} LIMIT 1`,
+      format: 'JSONEachRow',
+    });
+    return (await rs.json<unknown>()).length > 0;
+  };
+
+  if (await hasRows(tables.traces)) {
+    await client.command({
+      query: `INSERT INTO ${db}.${tables.tracesKvRollup} ${tracesKvMvSelect(db, tables.traces)}`,
+    });
+    await client.command({
+      query: `INSERT INTO ${db}.${tables.tracesKeyRollup} ${keyRollupMvSelect(db, tables.tracesKvRollup)}`,
+    });
+  }
+  if (await hasRows(tables.logs)) {
+    await client.command({
+      query: `INSERT INTO ${db}.${tables.logsKvRollup} ${logsKvMvSelect(db, tables.logs)}`,
+    });
+    await client.command({
+      query: `INSERT INTO ${db}.${tables.logsKeyRollup} ${keyRollupMvSelect(db, tables.logsKvRollup)}`,
+    });
+  }
+}
+
 async function dropRollupTables(
   client: ClickHouseClient,
   tables: ScenarioTables,