diff --git a/.agents/skills/neon-postgres/SKILL.md b/.agents/skills/neon-postgres/SKILL.md
new file mode 100644
index 00000000..bac7910c
--- /dev/null
+++ b/.agents/skills/neon-postgres/SKILL.md
@@ -0,0 +1,376 @@
+---
+name: neon-postgres
+description: >-
+  Guides and best practices for working with Neon Serverless Postgres.
+  Covers setup, connection methods, branching, autoscaling, scale-to-zero,
+  read replicas, connection pooling, Neon Auth, and the Neon CLI, MCP server,
+  REST API, TypeScript SDK, and Python SDK.
+  Use when users ask about "Neon setup", "connect to Neon", "Neon project",
+  "DATABASE_URL", "serverless Postgres", "Neon CLI", "neon", "Neon MCP",
+  "Neon Auth", "@neondatabase/serverless", "@neondatabase/neon-js",
+  "scale to zero", "Neon autoscaling", "Neon read replica", or
+  "Neon connection pooling".
+---
+
+# Neon Serverless Postgres
+
+Guide the user through any Neon-related task: setup, connections, branching, and advanced features. Deliver a working Neon connection, a completed feature configuration, or a specific answer from the official Neon docs.
+
+Neon is a serverless Postgres platform that separates compute and storage to offer autoscaling, branching, instant restore, and scale-to-zero. It's fully compatible with Postgres and works with any language, framework, or ORM that supports Postgres.
+
+## Neon Documentation
+
+The Neon documentation is the source of truth for all Neon-related information. Always verify claims against the official docs before responding. Neon features and APIs evolve, so prefer fetching current docs over relying on training data.
+
+### Fetching Docs as Markdown
+
+Any Neon doc page can be fetched as markdown in two ways:
+
+1. **Append `.md` to the URL** (simplest): https://neon.com/docs/introduction/branching.md
+2. **Request `text/markdown`** on the standard URL: `curl -H "Accept: text/markdown" https://neon.com/docs/introduction/branching`
+
+Both return the same markdown content. Use whichever method your tools support.
+
+### Finding the Right Page
+
+The docs index lists every available page with its URL and a short description:
+
+```
+https://neon.com/docs/llms.txt
+```
+
+Common doc URLs are organized in the topic links below. If you need a page not listed here, search the docs index: https://neon.com/docs/llms.txt. Don't guess URLs.
+
+## What Is Neon
+
+Use this for architecture explanations and terminology (organizations, projects, branches, endpoints) before giving implementation advice.
+
+Link: https://neon.com/docs/introduction/architecture-overview.md
+
+## Getting Started
+
+Use this section when guiding a user through first-time Neon setup.
+
+### Check Status Quo
+
+Before starting setup, inspect the user's codebase and environment:
+
+- Existing database connection code
+- Existing Neon MCP server or Neon CLI configuration
+- Existence of a `.env` file and `DATABASE_URL` environment variable
+- Existing ORM (Prisma, Drizzle, TypeORM) configuration
+
+### Self-Driving Setup With Neon's CLI or MCP Server
+
+Offer to inspect existing connected Neon projects or create new ones using the Neon CLI or MCP server. If neither is set up yet, run init with the `--agent` flag. Use `npx -y` to skip the package install prompt. Auth is handled automatically. If the user is not logged in, it opens their browser for OAuth and waits for completion before proceeding.
+
+```bash
+npx -y neon@latest init --agent <agent-name>
+```
+
+Supported `--agent` values: `cursor`, `copilot`, `claude`, `claude-desktop`, `codex`, `opencode`, `cline`, `gemini-cli`, `goose`, `zed`.
+
+This installs the Neon extension (for Cursor/VS Code) or MCP server (for other agents), creates an API key, and adds the `neon-postgres` agent skill to the project.
+
+If `init` is not suitable, the individual steps can be run non-interactively:
+
+- **Extension:** `cursor --install-extension databricks.neon-local-connect`
+- **MCP server:** `npx -y add-mcp https://mcp.neon.tech/mcp -g -n Neon -y -a <agent-name>`
+- **Agent skill:** `npx skills add neondatabase/agent-skills --skill neon-postgres --agent <agent-name> -y`
+
+For full CLI installation options, see https://neon.com/docs/cli/install.md
+
+### Setup Flow
+
+**1. Select Organization and Project**
+
+Use MCP server or CLI to list organizations and projects. Let the user select an existing project or create a new one.
+
+**2. Get Connection String**
+
+Use MCP server or CLI to get the connection string. Store it in `.env` as `DATABASE_URL`. Read the file first before modifying to avoid overwriting existing values.
+
+**3. Pick Connection Method & Driver**
+
+Refer to the connection methods guide to pick the correct driver based on deployment platform: https://neon.com/docs/connect/choose-connection.md
+
+**4. User Authentication with Neon Auth (if needed)**
+
+Skip for CLI tools, scripts, or apps without user accounts. If the app needs auth: use MCP server `provision_neon_auth` tool, then see the auth overview (https://neon.com/docs/auth/overview.md) for setup. For auth + database queries, see the JavaScript SDK reference (https://neon.com/docs/reference/javascript-sdk.md).
+
+**5. ORM Setup (optional)**
+
+Check for existing ORM (Prisma, Drizzle, TypeORM). If none, ask if they want one. For Drizzle integration, see https://neon.com/docs/guides/drizzle.md.
+
+**6. Schema Setup**
+
+- Check for existing migration files or ORM schemas
+- If none: offer to create an example schema or design one together
+
+### Resume Support
+
+If resuming setup, check what's already configured (MCP connection, `.env` with `DATABASE_URL`, dependencies, schema) and continue from the next incomplete step.
+
+### Security Reminders
+
+Remind users to use environment variables for credentials, never commit connection strings, and use least-privilege database roles.
+
+## Connection Methods & Drivers
+
+Use this when you need to pick the correct transport and driver based on runtime constraints (TCP, HTTP, WebSocket, edge, serverless, long-running).
+
+Link: https://neon.com/docs/connect/choose-connection.md
+
+### Recommended: Drizzle + the right driver for your runtime
+
+Always pair Neon with an ORM such as **Drizzle** for easy schema management and migrations. Pick the driver based on how the runtime treats your code:
+
+- **Long-running or shared-runtime environments → node-postgres (`pg`).** Neon Functions, and any host where the function runtime is shared across requests / runs on fluid compute (e.g. **Vercel** with Fluid compute), keep a module-scope process alive across many requests. Open a `pg` pool **once at module scope** and reuse it across requests.
+- **Fully isolated serverless (Lambda-style) → Neon's serverless driver (`@neondatabase/serverless`).** Hosts like **Netlify** spin up a fresh, isolated instance per request, so a persistent TCP pool can't be reused; the serverless driver queries over HTTP and is built for this.
+
+**Neon Functions / Vercel / fluid compute — Drizzle + node-postgres:**
+
+```typescript
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { Pool } from 'pg';
+import * as schema from './schema';
+
+// Created once at module scope; reused by every request the instance handles.
+const pool = new Pool({ connectionString: process.env.DATABASE_URL, max: 5 });
+const db = drizzle({ client: pool, schema });
+```
+
+On **Vercel** (Fluid compute) also attach the pool with `attachDatabasePool` from `@vercel/functions`, so the function runtime drains idle connections before an instance suspends:
+
+```typescript
+import { drizzle } from 'drizzle-orm/node-postgres';
+import { Pool } from 'pg';
+import { attachDatabasePool } from '@vercel/functions';
+import * as schema from './schema';
+
+const pool = new Pool({ connectionString: process.env.DATABASE_URL });
+attachDatabasePool(pool); // let the Vercel runtime manage the pooled connections
+const db = drizzle({ client: pool, schema });
+```
+
+**Netlify and other fully-isolated serverless — Drizzle + Neon serverless driver:**
+
+```typescript
+import { drizzle } from 'drizzle-orm/neon-http';
+import { neon } from '@neondatabase/serverless';
+
+const sql = neon(process.env.DATABASE_URL!);
+const db = drizzle({ client: sql });
+```
+
+### Serverless Driver
+
+Use this for `@neondatabase/serverless` patterns, including HTTP queries, WebSocket transactions, and runtime-specific optimizations.
+
+Link: https://neon.com/docs/serverless/serverless-driver.md
+
+### Neon JS SDK
+
+Use this for combined Neon Auth + Data API workflows with PostgREST-style querying and typed client setup.
+
+Link: https://neon.com/docs/reference/javascript-sdk.md
+
+## Developer Tools
+
+Use this for local development enablement with `npx -y neon@latest init --agent <agent-name>`, VSCode extension setup, and Neon MCP server configuration.
+
+| Tool             | URL                                             |
+| ---------------- | ----------------------------------------------- |
+| CLI Init Command | https://neon.com/docs/cli/init.md               |
+| VSCode Extension | https://neon.com/docs/local/vscode-extension.md |
+| MCP Server       | https://neon.com/docs/ai/neon-mcp-server.md     |
+| Neon CLI         | https://neon.com/docs/cli.md                    |
+
+### Neon CLI
+
+Use this for terminal-first workflows, scripts, and CI/CD automation with `neon`.
+
+Link: https://neon.com/docs/cli.md
+
+## Neon Admin API
+
+The Neon Admin API can be used to manage Neon resources programmatically. It is used behind the scenes by the Neon CLI and MCP server, but can also be used directly for more complex automation workflows or when embedding Neon in other applications.
+
+### Neon REST API
+
+Use this for direct HTTP automation, endpoint-level control, API key auth, rate-limit handling, and operation polling.
+
+Link: https://neon.com/docs/reference/api-reference.md
+
+### Neon TypeScript SDK
+
+Use this when implementing typed programmatic control of Neon resources in TypeScript via `@neon/sdk` (the fetch-based, zero-dependency successor to `@neondatabase/api-client`). For the full API surface — client config, the `{ data, error }` result model, typed errors, readiness/workflow helpers (`createAndConnect`, `createWithCompute`), pagination, every resource namespace, and the raw layer — see [references/neon-sdk.md](https://neon.com/docs/ai/skills/neon-postgres/references/neon-sdk.md).
+
+Link: https://neon.com/docs/reference/typescript-sdk.md
+
+### Neon Python SDK
+
+Use this when implementing programmatic Neon management in Python with the `neon-api` package.
+
+Link: https://neon.com/docs/reference/python-sdk.md
+
+## Neon Auth
+
+Use this for managed user authentication setup, UI components, auth methods, and Neon Auth integration pitfalls in Next.js and React apps.
+
+Link: https://neon.com/docs/auth/overview.md
+
+Neon Auth is also embedded in the Neon JS SDK. Depending on your use case, you may want to use the Neon JS SDK instead of Neon Auth alone. See https://neon.com/docs/connect/choose-connection.md for more details.
+
+## Neon Infrastructure as Code (`neon.ts`)
+
+`neon.ts` is Neon's branch config and infrastructure-as-code file: declare which services your branches have, get type-safe env vars, and program per-branch compute — all in TypeScript (see the `neon` skill for the full reference). Postgres always exists on every branch, so you never declare the database itself; what you codify here is the Postgres-adjacent surface — Neon Auth, the Data API, and per-branch compute settings (autoscaling and scale-to-zero).
+
+Add it with `@neon/config`:
+
+```bash
+npm i @neon/config
+```
+
+```typescript
+// neon.ts
+import { defineConfig } from '@neon/config/v1';
+
+export default defineConfig({
+  auth: true, // Neon Auth (adds NEON_AUTH_* env vars)
+  dataApi: true, // Data API (adds NEON_DATA_API_URL); requires auth: true (or an external IdP)
+  // Postgres exists on every branch; tune its compute per branch:
+  branch: (branch) => {
+    if (branch.exists) return {}; // leave existing branches untouched
+    if (branch.isDefault) return { protected: true }; // prod keeps default compute
+    return {
+      ttl: '7d', // non-prod branches auto-expire (max 30d)
+      postgres: {
+        computeSettings: {
+          autoscalingLimitMinCu: 0.25, // scale to zero
+          autoscalingLimitMaxCu: 1, // keep dev/preview cheap
+          suspendTimeout: '5m',
+        },
+      },
+    };
+  },
+});
+```
+
+Reconcile the declaration from the CLI — the Neon equivalent of `terraform plan` / `apply`:
+
+```bash
+neon config status   # print the branch's live config
+neon config plan     # dry-run diff of what apply would change
+neon config apply    # provision the declared services / settings
+neon deploy          # alias for `neon config apply`
+```
+
+Because `neon checkout` applies the policy as it **creates** a branch, a fresh branch comes up with these compute settings (and Auth / Data API) already in place. Checking out an _existing_ branch never reconciles it — run `neon deploy` to apply changes.
+
+Since `neon.ts` is TypeScript, invalid combinations fail to compile with an actionable message: the Data API verifies requests with Neon Auth by default, so `dataApi: true` without `auth: true` is a type error (the fix — `auth: true`, or `authProvider: 'external'` with a `jwksUrl` — is in the message). See the `neon` skill's type-safe config note.
+
+Read the resulting env back, typed and validated against the policy, with `parseEnv` from `@neon/env`:
+
+```typescript
+import { parseEnv } from '@neon/env';
+import config from './neon';
+
+const env = parseEnv(config);
+env.postgres.databaseUrl; // typed; enabling auth / dataApi above surfaces env.auth / env.dataApi
+```
+
+## Branching
+
+Use this when the user is planning isolated environments, schema migration testing, preview deployments, or branch lifecycle automation.
+
+Key points:
+
+- Branches are instant, copy-on-write clones (no full data copy).
+- Each branch has its own compute endpoint.
+- Use the neon CLI or MCP server to create, inspect, and compare branches.
+
+Link: https://neon.com/docs/introduction/branching.md
+
+For detailed branch creation workflows (normal vs schema-only branches, reset-from-parent, CLI/MCP selection), use the `neon-postgres-branches` skill if available
+
+Or fetch the full branching skill from the following URL:
+
+https://neon.com/docs/ai/skills/neon-postgres-branches/SKILL.md
+
+If this skill is not installed you can use the following command to install it:
+
+```bash
+npx skills add neondatabase/agent-skills --skill neon-postgres-branches
+```
+
+## Autoscaling
+
+Use this when the user needs compute to scale automatically with workload and wants guidance on CU sizing and runtime behavior.
+
+Link: https://neon.com/docs/introduction/autoscaling.md
+
+## Scale to Zero
+
+Use this when optimizing idle costs and discussing suspend/resume behavior, including cold-start trade-offs.
+
+Key points:
+
+- Idle computes suspend automatically (default 5 minutes, configurable) (unless disabled - launch & scale plan only)
+- First query after suspend typically has a cold-start penalty (around hundreds of ms)
+- Storage remains active while compute is suspended.
+
+Link: https://neon.com/docs/introduction/scale-to-zero.md
+
+## Instant Restore
+
+Use this when the user needs point-in-time recovery or wants to restore data state without traditional backup restore workflows.
+
+Key points:
+
+- History windows for instant restore depend on plan limits.
+- Users can create branches from historical points-in-time.
+- Time Travel queries can be used for historical inspection workflows.
+
+Link: https://neon.com/docs/introduction/branch-restore.md
+
+## Read Replicas
+
+Use this for read-heavy workloads where the user needs dedicated read-only compute without duplicating storage.
+
+Key points:
+
+- Replicas are read-only compute endpoints sharing the same storage.
+- Creation is fast and scaling is independent from primary compute.
+- Typical use cases: analytics, reporting, and read-heavy APIs.
+
+Link: https://neon.com/docs/introduction/read-replicas.md
+
+## Connection Pooling
+
+Use this when the user is in serverless or high-concurrency environments and needs safe, scalable Postgres connection management.
+
+Key points:
+
+- Neon pooling uses PgBouncer.
+- Add `-pooler` to endpoint hostnames to use pooled connections.
+- Pooling is especially important in serverless runtimes with bursty concurrency.
+
+Link: https://neon.com/docs/connect/connection-pooling.md
+
+## IP Allow Lists
+
+Use this when the user needs to restrict database access by trusted networks, IPs, or CIDR ranges.
+
+Link: https://neon.com/docs/introduction/ip-allow.md
+
+## Logical Replication
+
+Use this when integrating CDC pipelines, external Postgres sync, or replication-based data movement.
+
+Key points:
+
+- Neon supports native logical replication workflows.
+- Useful for replicating to/from external Postgres systems.
+
+Link: https://neon.com/docs/guides/logical-replication-guide.md
diff --git a/.agents/skills/neon-postgres/references/neon-sdk.md b/.agents/skills/neon-postgres/references/neon-sdk.md
new file mode 100644
index 00000000..65f4bc12
--- /dev/null
+++ b/.agents/skills/neon-postgres/references/neon-sdk.md
@@ -0,0 +1,265 @@
+# `@neon/sdk` — the TypeScript client for the Neon API
+
+`@neon/sdk` is the official TypeScript client for the [Neon API](https://neon.com/docs/reference/api-reference): **Fetch-based, zero-dependency, ESM-only**, generated from Neon's [OpenAPI spec](https://neon.com/api_spec/release/v2.json) with an ergonomic layer on top. It is the successor to [`@neondatabase/api-client`](https://www.npmjs.com/package/@neondatabase/api-client) (axios-based, generated-only). The old client is **not deprecated** and is safe to keep using, but new code should prefer `@neon/sdk`.
+
+Use this reference when writing typed, programmatic control of Neon resources in TypeScript — provisioning projects, managing branches/databases/endpoints, transferring projects across orgs, snapshots/restore, consumption metrics, and the beta services (Object Storage, Functions, AI Gateway, scoped credentials).
+
+## When to reach for it (vs MCP / CLI)
+
+- **Neon MCP server and CLI** are for **local development** — a coding agent in your editor or terminal.
+- **`@neon/sdk`** is for **programmatic integration**: CI/CD pipelines where the CLI isn't enough, non-trivial dev scripts, and full platforms that provision and manage fleets of Neon databases (the same open API behind Replit, Netlify DB, Laravel Cloud, and Vercel's Neon marketplace integration). All it needs is a Neon API key.
+
+## Install
+
+```bash
+npm install @neon/sdk
+```
+
+Requires Node.js ≥ 20.19, or any runtime with a global `fetch` (Bun, Deno, edge, browser).
+
+## Two layers, one package
+
+```ts
+import { createNeonClient, raw } from '@neon/sdk';
+```
+
+- **`createNeonClient`** — the high-level ergonomic client: auth once, `{ data, error }` results, typed errors, retries, readiness polling, auto-pagination, and multi-step workflows, organized into resource namespaces (`neon.projects`, `neon.branches`, `neon.postgres`, …).
+- **`raw`** — the full generated 1:1 surface: every endpoint as a standalone, tree-shakeable function (also at the `@neon/sdk/raw` subpath). Speaks the **same** `{ data, error }` / `throwOnError` contract as the ergonomic client.
+
+## Quick start
+
+```ts
+import { createNeonClient } from '@neon/sdk';
+
+const neon = createNeonClient({ apiKey: process.env.NEON_API_KEY! });
+
+// Create a project and get a ready-to-use connection string in one call.
+const { data, error } = await neon.projects.createAndConnect({ name: 'my-app' });
+if (error) throw error;
+const { project, connectionString } = data;
+```
+
+## Client configuration
+
+`createNeonClient(config)`:
+
+| Option             | Type                                          | Default                            | Description                                                                                                                                           |
+| ------------------ | --------------------------------------------- | ---------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `apiKey`           | `string \| (() => string \| Promise<string>)` | — (required)                       | Neon API key, or a function returning it. Sent as a Bearer token.                                                                                     |
+| `throwOnError`     | `boolean`                                     | `false`                            | `true` → methods return the resource directly and **throw** on error. `false` → return `{ data, error }`. **Narrows return types** at the type level. |
+| `waitForReadiness` | `boolean`                                     | `false`                            | `true` → mutations block until their provisioning `operations` finish, so the returned resource is ready.                                             |
+| `wait`             | `{ pollIntervalMs?; timeoutMs? }`             | `1000` / `300000`                  | Readiness poller tuning.                                                                                                                              |
+| `retries`          | `number`                                      | `2`                                | Automatic retries on always-safe statuses (`423`, `429`, `503`) with backoff.                                                                         |
+| `orgId`            | `string`                                      | —                                  | Default org for project create/list and as the transfer source org. Overridable per call.                                                             |
+| `baseUrl`          | `string`                                      | `https://console.neon.tech/api/v2` | Override the API base URL.                                                                                                                            |
+| `fetch`            | `typeof fetch`                                | global `fetch`                     | Custom fetch (proxies, tests, non-global runtimes).                                                                                                   |
+
+Every option except `apiKey` is also accepted **per call** via the trailing `options` arg (`{ throwOnError?, waitForReadiness?, signal? }`), overriding the client default.
+
+## The result model
+
+By default every method resolves to a discriminated `{ data, error }` envelope — no `try/catch`:
+
+```ts
+const { data, error } = await neon.projects.get('late-frost-12345');
+if (error) return; // error is a typed NeonError union
+data; // narrowed to Project
+```
+
+Set `throwOnError` (on the client or per call) to get the bare resource and throw instead — the return type narrows accordingly:
+
+```ts
+const neon = createNeonClient({ apiKey, throwOnError: true });
+const project = await neon.projects.get('…'); // Project (throws)
+const res = await neon.projects.get('…', { throwOnError: false }); // { data, error }
+```
+
+## Errors
+
+The `error` channel carries a typed hierarchy (all `Error` subclasses with a `kind` discriminant); the same value is thrown when `throwOnError` is set.
+
+| Class                | `kind`         | Notable fields                                               |
+| -------------------- | -------------- | ------------------------------------------------------------ |
+| `NeonError`          | (base)         | `message`, `kind`                                            |
+| `NeonApiError`       | `"api"`        | `status`, `code`, `requestId`, `response`, `body`            |
+| `NeonNotFoundError`  | `"not_found"`  | 404 — extends `NeonApiError`                                 |
+| `NeonAuthError`      | `"auth"`       | 401/403                                                      |
+| `NeonRateLimitError` | `"rate_limit"` | 429 (after retries)                                          |
+| `NeonOperationError` | `"operation"`  | `operationId`, `status` — an awaited operation failed        |
+| `NeonTimeoutError`   | `"timeout"`    | readiness/wait deadline exceeded                             |
+| `NeonNetworkError`   | `"network"`    | transport failure (no response)                              |
+| `NeonError`          | `"client"`     | SDK-side errors (e.g. ambiguous connection-string selection) |
+
+```ts
+const { error } = await neon.branches.get(pid, 'nope');
+if (error?.kind === 'not_found') {
+  /* … */
+}
+```
+
+## Pagination
+
+Cursor-paginated `list()` methods return a lazy `Paginated<T>`:
+
+```ts
+const { data: all }  = await neon.projects.list().all();   // every page → { data, error }
+const { data: page } = await neon.projects.list().page();  // one page
+for await (const project of neon.projects.list()) { … }    // stream; throws on a page error
+```
+
+## Readiness & workflows
+
+Neon mutations are asynchronous — they return `operations`. `waitForReadiness` blocks until they settle; the **workflow** methods (`createAndConnect`, `createWithCompute`) default it on and hand back a connection string in one call. The underlying primitive is `neon.operations.waitFor(operations)`.
+
+## API surface (ergonomic client)
+
+Legend: **[P]** returns `Paginated<T>` · **[W]** workflow (multi-step) · **→void** resolves to `void`.
+
+### `neon.projects`
+
+| Method                                          | Returns                                 | Notes                                                                                                          |
+| ----------------------------------------------- | --------------------------------------- | -------------------------------------------------------------------------------------------------------------- |
+| `list(query?)`                                  | **[P]** `ProjectListItem`               | `{ search?, org_id?, limit? }`                                                                                 |
+| `get(id)`                                       | `Project`                               |                                                                                                                |
+| `create(input?)`                                | `Project`                               | `{ name?, region_id?, pg_version?, org_id?, autoscaling_limit_min_cu?, autoscaling_limit_max_cu?, settings? }` |
+| `createAndConnect(input?, { pooled? })`         | **[W]** `{ project, connectionString }` | one call + readiness; `pooled` default `true`                                                                  |
+| `update(id, input)`                             | `Project`                               | `{ name?, settings? }`                                                                                         |
+| `delete(id)`                                    | `Project`                               |                                                                                                                |
+| `transfer({ fromOrgId?, toOrgId, projectIds })` | **→void**                               | `fromOrgId` defaults to client `orgId`                                                                         |
+| `transferFromUser({ toOrgId, projectIds })`     | **→void**                               | personal account → org                                                                                         |
+| `recover(id)`                                   | `Project`                               | beta — recover a soft-deleted project                                                                          |
+| `permissions.list / grant / revoke`             | `ProjectPermission`(`[]`)               | share a project by email                                                                                       |
+
+```ts
+// Provision a project and get a pooled connection string in one call
+const { data } = await neon.projects.createAndConnect(
+  { name: 'tenant-42', region_id: 'aws-us-east-1' },
+  { pooled: true },
+); // data: { project, connectionString }
+
+// Upgrade path: move projects from a sponsored (free) org to the paid org
+await neon.projects.transfer({
+  fromOrgId: sponsoredOrgId, // defaults to the client's `orgId`
+  toOrgId: paidOrgId,
+  projectIds: ['late-frost-12345'],
+});
+```
+
+### `neon.branches`
+
+| Method                                                      | Returns                                          | Notes                                                                                 |
+| ----------------------------------------------------------- | ------------------------------------------------ | ------------------------------------------------------------------------------------- |
+| `list(projectId, query?)`                                   | **[P]** `Branch`                                 | `{ search?, sort_by?, sort_order?, include_deleted? }`                                |
+| `get(projectId, branchId)`                                  | `Branch`                                         |                                                                                       |
+| `create(projectId, input?)`                                 | `Branch`                                         | `{ name?, parent_id?, parent_lsn?, parent_timestamp?, protected? }`                   |
+| `update(projectId, branchId, input)`                        | `Branch`                                         | `{ name?, protected?, expires_at? }`                                                  |
+| `delete(projectId, branchId)`                               | **→void**                                        |                                                                                       |
+| `createWithCompute(projectId, input, { pooled? })`          | **[W]** `{ branch, endpoint, connectionString }` | `input`: `{ name?, parentId?, compute?: { minCu?, maxCu?, suspendTimeoutSeconds? } }` |
+| `getDefault(projectId)` / `setDefault(projectId, branchId)` | `Branch`                                         | resolve/set the default branch                                                        |
+| `recover(projectId, branchId)`                              | `Branch`                                         | beta — recover within the 7-day window                                                |
+| `finalizeRestore(projectId, branchId, { name? }?)`          | **→void**                                        | commit a restore previewed with `snapshots.restore`                                   |
+
+```ts
+// Branch off the default branch with its own compute — returns a ready connection string
+const { data: prod } = await neon.branches.getDefault(projectId);
+const { data } = await neon.branches.createWithCompute(projectId, {
+  name: 'preview/pr-123',
+  parentId: prod?.id,
+  compute: { minCu: 0.25, maxCu: 2 },
+}); // data: { branch, endpoint, connectionString }
+```
+
+### `neon.postgres`
+
+The Postgres data plane of a branch. `neon.postgres.connectionString(params, options?)` resolves a URI, **auto-selecting** the default branch and the sole role/database when omitted:
+
+```ts
+const { data: uri } = await neon.postgres.connectionString({
+  projectId, // branchId?, endpointId?, databaseName?, roleName?, pooled? all optional; pooled default true
+});
+```
+
+Nested namespaces:
+
+- **`neon.postgres.endpoints`** — `list / get / create / update / delete`, plus `start` / `suspend` / `restart` and `listByBranch(projectId, branchId)`.
+- **`neon.postgres.roles`** — `list / get / create / delete`, plus `password(...)` (reveals) and `resetPassword(...)` (rotates; result carries the new password).
+- **`neon.postgres.databases`** — `list / get / create / update / delete`.
+- **`neon.postgres.dataApi`** — `get / create / update / delete` the branch's Data API.
+
+### Beta services
+
+- **`neon.storage`** — branch object storage. `get(projectId, branchId)` → `BranchStorage`; nested `buckets` (`list / create / delete`) and `objects` (`list / get / delete / deleteByPrefix / presign`). Use `presign(..., { operation: "upload" | "download" })` for direct S3-style transfers.
+- **`neon.functions`** — branch Neon Functions. `list` **[P]** `/ get / update / delete`, and `deploy(projectId, branchId, slug, { zip?, runtime?, environment? })` (multipart; poll `get` until `current_deployment.status === "completed"`).
+- **`neon.credentials`** — branch scoped credentials. `list / create / revoke`; secrets (`api_token`, `s3_secret_access_key`) are returned **once** on `create`. Scopes: `storage:read`, `storage:write`, `ai_gateway:invoke`, `functions:invoke`.
+- **`neon.aiGateway`** — `get(projectId, branchId)` → `BranchAiGateway` (404 when the gateway is not enabled on the branch). See the `neon-ai-gateway` skill for calling the gateway itself.
+
+### `neon.snapshots`
+
+| Method                                                | Returns                      | Notes                                                      |
+| ----------------------------------------------------- | ---------------------------- | ---------------------------------------------------------- |
+| `list(projectId)`                                     | `Snapshot[]`                 |                                                            |
+| `create(projectId, branchId, input?)`                 | `Snapshot`                   | `{ name?, timestamp?, lsn?, expiresAt? }` (point-in-time)  |
+| `update(projectId, snapshotId, input)`                | `Snapshot`                   | `{ name?, expiresAt? }` — `expiresAt: null` clears the TTL |
+| `delete(projectId, snapshotId)`                       | **→void**                    |                                                            |
+| `restore(projectId, snapshotId, input?)`              | `Branch`                     | see below                                                  |
+| `getSchedule` / `setSchedule(projectId, branchId, …)` | `BackupSchedule` / **→void** |                                                            |
+
+`restore` input: `{ name?, targetBranchId?, finalize?, preview?, keepOnAbort? }`.
+
+- Restoring **as a new branch** (no `targetBranchId`) finalizes by default → ready to use.
+- Restoring **onto an existing branch** doesn't finalize by default, so you can preview first.
+- **Transaction-style** `preview`: restores un-finalized, runs your callback, then **finalizes (commit)** on `true` or **deletes the preview branch (abort)** on `false` (unless `keepOnAbort`):
+
+```ts
+await neon.snapshots.restore(projectId, snapshotId, {
+  targetBranchId,
+  preview: async (branch) => (await checks(branch)) === 'ok', // true → commit · false → abort
+});
+```
+
+### `neon.operations` / `neon.consumption` / `neon.apiKeys` / `neon.regions` / `neon.user` / `neon.auth`
+
+- **`operations`** — `list` **[P]** `/ get`, and `waitFor(operations, { pollIntervalMs?, timeoutMs?, signal? })` (the readiness primitive).
+- **`consumption`** — cursor-paginated billing metrics: `perProject`, `perProjectV2`, `perBranchV2` (each takes `{ from, to, granularity, project_ids?, org_id? }`; `perBranchV2` requires `project_ids`). Consumption requires a Scale plan or above.
+- **`apiKeys`** — `list / create(keyName) / revoke`; the created `key` token is shown **once**.
+- **`regions.list()`**, **`user.me()` / `user.organizations()`**.
+- **`auth`** — branch-scoped Neon Auth: `get / create / disable / updateConfig`, plus `oauthProviders`, `trustedDomains`, and `users` sub-resources.
+
+## Drop down to the raw client
+
+The ergonomic namespaces don't wrap every endpoint. For anything else, `raw` exposes every endpoint 1:1 — pass `neon.client` so the call reuses the client's auth:
+
+```ts
+import { raw } from '@neon/sdk';
+// or, for guaranteed tree-shaking: import { getProjectBranchSchema } from "@neon/sdk/raw";
+
+const { data, error } = await raw.getProjectBranchSchema({
+  client: neon.client,
+  path: { project_id, branch_id },
+  query: { db_name: 'neondb' }, // db_name is required
+});
+```
+
+The raw layer speaks the same result contract: `{ data, error }` by default, or pass `throwOnError: true` for the bare resource. All request/response/error **types** are re-exported flat from `@neon/sdk` for `import type { Project, Branch, … }`.
+
+Wait on operations from a raw mutation with the readiness primitive:
+
+```ts
+const { data } = await raw.createProjectBranch({
+  client: neon.client,
+  path: { project_id: projectId },
+  body: { branch: { name: 'wip' } },
+});
+const { error } = await neon.operations.waitFor(data!.operations, { timeoutMs: 120_000 });
+```
+
+## Migrating from `@neondatabase/api-client`
+
+There's no rush — `@neondatabase/api-client` is not being deprecated. When you do move: swap axios-style `try/catch` for the `{ data, error }` envelope (or set `throwOnError: true` to keep throwing), and replace hand-rolled operation polling with `waitForReadiness` / the workflow methods (`createAndConnect`, `createWithCompute`).
+
+## Further reading
+
+- npm: https://www.npmjs.com/package/@neon/sdk
+- Neon TypeScript SDK docs: https://neon.com/docs/reference/typescript-sdk.md
+- Neon API reference: https://neon.com/docs/reference/api-reference
+- Building a platform on Neon: the `neon-for-agent-platforms` skill (`npx skills add neondatabase/neon-for-agent-platforms`) ships runnable `@neon/sdk` scripts for provisioning, branching, snapshots, project transfer, and consumption metrics.
diff --git a/.agents/skills/neon/SKILL.md b/.agents/skills/neon/SKILL.md
new file mode 100644
index 00000000..d473be14
--- /dev/null
+++ b/.agents/skills/neon/SKILL.md
@@ -0,0 +1,350 @@
+---
+name: neon
+description: >-
+  Overview of the Neon platform for apps and agents, spanning Postgres, Auth,
+  the Data API, and the new services: Object Storage, Compute Functions, and AI
+  Gateway. Use when "Neon" is mentioned, or when any of its individual
+  capabilities are the trigger: "object storage" or "S3", "buckets", "serverless
+  functions", "AI gateway", "call an LLM", "postgres", "database", or "backend".
+---
+
+# Neon
+
+Important: Neon is no longer just a Serverless Postgres provider. Neon is the backend for apps and agents with Serverless Postgres, Auth, Functions, Object Storage, and an AI Gateway: instant, branchable, serverless.
+
+Use this skill as the starting point for anything Neon: get an overview of its capabilities, find your way around the Neon agent skills and documentation, and follow best practices for getting started and for branch-first development workflows.
+
+## Platform Services
+
+Neon bundles several backend primitives for building apps and agents that all branch together with your project:
+
+- **Postgres** — Serverless Postgres that scales and branches with your app. _Generally available._
+- **Auth** — Managed authentication with users and sessions stored in Postgres. _Generally available._
+- **Object Storage** — S3-compatible object storage that branches with your projects. _Public beta._
+- **Functions** — Long-running serverless functions - Neon's compute offering - running close to your database — for WebSocket servers, long agent HTTP streams, APIs, and server-sent event servers. _Public beta._
+- **AI Gateway** — One API for all frontier and open-source models, with routing, logging, and cost controls, powered by Databricks. _Public beta._
+
+### Public Beta Service Availability
+
+Object Storage, Functions, and AI Gateway are in public beta.
+
+Beta access features are only available on net-new projects created in the `us-east-2` region; they cannot be enabled on existing projects for now. Before guiding a user through any of these services, confirm they are working with a new project in `us-east-2`. If not, they will need to create a new project in that region.
+
+## Architecture: how Neon fits
+
+Neon is **not** a place to host your full-stack app — it's backend primitives (Postgres, Auth, Object Storage, Functions, AI Gateway) that **compose with** the application platform you already use. Host the app on **Vercel** (or Netlify, or another frontend/app host); Neon is the backend it talks to.
+
+A typical setup:
+
+- **Full-stack app on Vercel** (or Netlify) — e.g. Next.js or TanStack Start. It owns your UI and auth (e.g. **Neon Auth**) and talks directly to your **Neon Postgres** database and **Neon Object Storage**.
+- **Reach for Neon Functions when you outgrow the host's limits** — a WebSocket or SSE server, or long-running agents that risk timing out on short, lambda-style serverless. Run that one piece on a Neon Function, next to your data.
+
+You can also move your **whole backend control plane** onto Neon Functions. This is especially useful when the frontend is **client-only** rather than full-stack — TanStack Router, React Router in client mode, and similar SPAs hosted on Vercel or Netlify. The client talks **directly to Neon Functions**, where you build REST APIs and request/response agents, host **MCP servers**, and run anything stateful or that should live close to Postgres and Object Storage. Secure these functions like any standalone REST API — verify a JWT or API key at the top of each handler (see the `neon-functions` skill).
+
+Because Functions are just your backend, they compose with a full-stack app too: if you already have a backend (Next.js route handlers, etc.), Neon Functions sit alongside it, and you can **move pieces between the two** — e.g. relocate a long-running agent or a stateful WebSocket server off your host onto a Function when it needs more runtime.
+
+## Neon Documentation
+
+The Neon documentation is the source of truth for all Neon-related information. Always verify claims against the official docs before responding. Neon features and APIs evolve, so prefer fetching current docs over relying on training data.
+
+### Fetching Docs as Markdown
+
+Any Neon doc page can be fetched as markdown in two ways:
+
+1. **Append `.md` to the URL** (simplest): https://neon.com/docs/introduction/branching.md
+2. **Request `text/markdown`** on the standard URL: `curl -H "Accept: text/markdown" https://neon.com/docs/introduction/branching`
+
+Both return the same markdown content. Use whichever method your tools support.
+
+### Finding the Right Page
+
+The docs index lists every available page with its URL and a short description:
+
+```
+https://neon.com/docs/llms.txt
+```
+
+Common doc URLs are organized in the topic links below. If you need a page not listed here, search the docs index: https://neon.com/docs/llms.txt. Don't guess URLs.
+
+## Choosing the Right Skill
+
+- Working with the database, connections, schema, queries, autoscaling, or the CLI/MCP/API → `neon-postgres`.
+- Choosing or creating the right branch type for dev, preview, test, or CI workflows → `neon-postgres-branches`.
+- Storing and serving files (uploads, images, blobs) that branch with the database → `neon-object-storage`.
+- Deploying long-running or streaming serverless functions — APIs, agents, SSE/WebSocket servers — next to the database → `neon-functions`.
+- Calling an LLM or routing across model providers with one credential — including discovering the branch's servable models at runtime via the OpenAI-compatible `/v1/models` endpoint → `neon-ai-gateway`.
+- Provisioning instant, claimable temporary Postgres databases (for example, one per end user or demo) → `claimable-postgres`.
+- Diagnosing or fixing excessive Postgres egress (network data-transfer) costs in a codebase → `neon-postgres-egress-optimizer`.
+
+### Installing the Right Skill
+
+First check whether the target skill is already installed and accessible (for example, it appears in the available skills list or its `SKILL.md` is present). If it is, use it directly. If it is not installed, install it via the `skills` CLI with `npx`/`bunx`:
+
+```bash
+npx skills add neondatabase/agent-skills -s <skill-name>
+```
+
+Replace `<skill-name>` with the skill you need (for example, `neon-object-storage`, `neon-functions`, or `neon-ai-gateway`). Useful flags:
+
+- `-g` — install globally instead of into the current project.
+- `-y` — non-interactive mode (skip prompts).
+- `-a <agent-name>` — pick the target agent(s) for non-interactive mode.
+
+For example, to install the object storage skill globally for a specific agent without prompts:
+
+```bash
+npx skills add neondatabase/agent-skills -s neon-object-storage -g -y -a <agent-name>
+```
+
+You should also make sure the skills are up to date. You can run the same command or replace `add` with `update` to update all Neon skills.
+
+## Getting Started with Neon
+
+Use this section when guiding a user through first-time Neon setup, or when adding a new Neon service (Auth, object storage, functions, and so on) to a project that is already onboarded (for example, one already using Neon Postgres).
+
+### Check Status Quo
+
+Before starting setup, inspect the user's codebase and environment:
+
+- Existing database connection code
+- Existing `.neon` or `neon.ts` files in the workspace
+- Existing Neon MCP server or Neon CLI configuration
+- Existence of a `.env` file and `DATABASE_URL` environment variable
+- Existing ORM (Prisma, Drizzle, TypeORM) configuration
+
+### Self-Driving Setup With Neon's CLI or MCP Server
+
+Offer to inspect existing connected Neon projects or create new ones using the Neon CLI or MCP server. If neither is set up yet, run `npx -y neon init`. Use `npx -y` to skip the package install prompt. Auth is handled automatically. If the user is not logged in, it opens their browser for OAuth and waits for completion before proceeding.
+
+```bash
+npx -y neon@latest init
+```
+
+This installs the Neon CLI and MCP server globally, installs the VSCode extension (for Cursor/VS Code), and adds the `neon` and `neon-postgres` agent skills to the project.
+
+If `init` is not suitable, the individual steps can be run non-interactively, using the user's preferred package manager (npm, bun, pnpm):
+
+- **CLI:** `npm i -g neon`
+- **Extension:** `cursor --install-extension databricks.neon-local-connect`
+- **MCP server:** `npx -y add-mcp https://mcp.neon.tech/mcp -g -n Neon -y -a <agent-name>`
+- **Agent skill:** `npx skills add neondatabase/agent-skills --skill neon-postgres --skill neon --agent <agent-name> -y`
+
+Prefer the CLI over the MCP server unless the user instructs otherwise, since it provides more capabilities, including deploying Neon Functions. For full CLI installation options, see https://neon.com/docs/cli/install.md
+
+### Setup Flow
+
+Once the CLI, MCP server, and agent skills are installed, ensure the local workspace is linked to a Neon project through the `neon init` flow. If it isn't, run `npx -y neon link` to let the user interactively link a project. This produces a `.neon` file pointing to the organization, project, and branch the user wants to work with.
+
+For each Neon service, consult that component's agent skill for service-specific setup instructions (Functions, Postgres, Object Storage, Gateway, and so on).
+
+### Resume Support
+
+If resuming setup, check what's already configured (MCP connection, `.env` with `DATABASE_URL`, dependencies, schema) and continue from the next incomplete step.
+
+### Security Reminders
+
+Remind users to use environment variables for credentials, never commit connection strings, and use least-privilege database roles.
+
+## Branch-First Dev Flow
+
+Default to a branch-first loop that mirrors `git`: one isolated Neon branch per feature, so nothing leaks between features and there are no shared connection strings to copy around. Two commands drive it — `link` once per project, then `checkout` per feature — and a third, `env pull`, runs automatically under the hood so the branch you pin is immediately usable:
+
+- `neon link` — Interactively links the workspace to a Neon org, project, and branch, writing the IDs to a git-ignored `.neon` file. Run once per project. Once linked, project- and branch-scoped commands no longer need `--project-id` or `--branch` (for example, `neon branch list`).
+- `neon checkout <branch-name>` — Creates the branch if it doesn't exist, or checks out the existing one, by updating only the branch pointer in `.neon`. Run without a name for an interactive picker. It does not touch code or local Postgres.
+- `neon env pull` — Fetches the current branch's Neon environment variables (`DATABASE_URL`, …) into your existing `.env`, or `.env.local` if you don't have one (override the target with `--file`). No branch ID needed; it reads `.neon`. **`link` and `checkout` run this for you by default**, so you rarely call it directly.
+
+Run `link` once when starting on a project, then `checkout` per feature:
+
+```bash
+neon link                     # once; also pulls the linked branch's env
+neon checkout dev-add-search  # per feature; also pulls the branch's env
+```
+
+Because `link` and `checkout` pull env by default, the branch's `DATABASE_URL` lands in your local `.env` automatically — build against it, then `checkout` the next branch and repeat. As the agent, drive this loop yourself: run `checkout` between tasks to get a fresh, isolated database per feature with no shared state to corrupt.
+
+### Updating `.neon` without interactive prompts
+
+Plain `neon link` / `neon checkout` prompt interactively, which an agent can't answer. Use one of these non-interactive paths instead:
+
+- **`neon link --agent`** — a JSON state machine for agents. Each call returns a single JSON object with a `status` (`needs_org` → `needs_project` → `needs_project_details` → `linked`, or `error`), the available `options`, and the exact `next_command_template` to run next. Drive it step by step until `status: "linked"`. (Errors also come back as JSON with exit code 1, so you can always parse the result.)
+- **`neon set-context --project-id <id> --org-id <id> --branch-id <id>`** — when you already know the IDs, write all three into `.neon` in one shot. This is a **destructive write**: it replaces the file's contents entirely with exactly these fields, so it's the most direct way to point `.neon` at a specific org / project / branch.
+
+Both avoid prompts entirely; reach for `set-context` when you have the IDs and `link --agent` when you need to discover them.
+
+### Opting out of local env vars
+
+If env vars are injected at runtime instead of written to disk — or you simply don't want secrets in the working tree — pass `--no-env-pull` to `link` / `checkout` and supply the env another way:
+
+- `neon-env run -- <your dev command>` (from `@neon/env`) fetches the branch's vars from your `neon.ts` and injects them into the child process at runtime — no `.env` file needed. This is the runtime counterpart to the on-disk `env pull`.
+- `neon-env export` (from `@neon/env`) prints the branch's env to stdout as dotenv lines or, with `--format json`, JSON — for piping into another env manager rather than running a command. For example, [varlock](https://varlock.dev) can bulk-load it from a `.env.schema` with `@setValuesBulk(exec("neon-env export --format json"), format=json)`.
+- `fetchEnv` from `@neon/env` is the programmatic version of the same thing: resolve the branch's env in code at runtime instead of shelling out to `neon-env run`.
+- `neon dev` injects the same vars into your local dev server — it's part of Neon Functions local development (a public beta feature).
+
+When an agent should not write a local `.env`, instruct it (for example in your `AGENTS.md`) to run `neon checkout <branch> --no-env-pull` and rely on runtime injection.
+
+For reading env you _already_ have on disk (typed and validated against your `neon.ts`), use `parseEnv` — see [Neon Infrastructure as Code](#neon-infrastructure-as-code) below.
+
+## Neon Infrastructure as Code
+
+`neon.ts` is Neon's branch config and infrastructure-as-code file: declare which Neon services your project's branches should have, get type-safe env vars, and program branch settings — all in TypeScript. It's the config layer for Neon as a platform, and it composes with the branch-first loop above. Add it with `@neon/config`:
+
+```bash
+npm i @neon/config
+```
+
+```typescript
+// neon.ts
+import { defineConfig } from '@neon/config/v1';
+
+export default defineConfig({
+  auth: true,
+  dataApi: true,
+});
+```
+
+### Provision services with neon config
+
+Every project ships with serverless Postgres; `neon.ts` lets you also declare Neon Auth and the Data API today, with Functions, buckets, and the AI Gateway under a `preview` block — every service for the branch composes in one file:
+
+```typescript
+// neon.ts
+export default defineConfig({
+  auth: true,
+  dataApi: true,
+  preview: {
+    functions: {
+      /* ... */
+    }, // see the neon-functions skill
+    buckets: {
+      /* ... */
+    }, // see the neon-object-storage skill
+    aiGateway: true, // see the neon-ai-gateway skill
+  },
+});
+```
+
+Reconcile the declaration from the CLI — the Neon equivalent of `terraform status` / `plan` / `apply`:
+
+```bash
+neon config status   # print the branch's live config (read-only)
+neon config plan     # dry-run diff of what apply would change (read-only)
+neon config apply    # provision the declared services
+neon deploy          # alias for `neon config apply`
+```
+
+`config status` and `config plan` only read state. `apply` / `deploy` — like `link` and `checkout` — provision the declared services **and then pull the branch's env into your local `.env.local`** (e.g. `Pulled 5 Neon variables into .env.local: DATABASE_URL, …`), so your local env always matches what's deployed.
+
+### Type-safe env vars with parseEnv
+
+`@neon/env`'s `parseEnv` takes your `neon.ts` config object and returns a parsed, typed env object, validated against the services you declared. The shape of `env` follows your config — enable `auth` and you get `env.auth`, enable `dataApi` and you get `env.dataApi` — and missing variables are flagged with clear errors (for you and your agents). Use it to read env you already have (typically pulled into `.env` by `checkout` / `env pull`); for fetching env at runtime without a file, reach for `fetchEnv` / `neon-env run` instead.
+
+```bash
+npm i @neon/env
+```
+
+```typescript
+import { parseEnv } from '@neon/env';
+import config from './neon';
+
+const env = parseEnv(config);
+
+console.log(env.postgres.databaseUrl);
+console.log(env.auth.baseUrl);
+```
+
+By default `parseEnv` requires _every_ variable your config implies. When a process only uses a subset — a common case in frameworks like Next.js, where you might read `DATABASE_URL` but never the unpooled URL — pass an array of env-var keys to require and return only those. The keys are typesafe: autocomplete only offers variables your config enables, and the returned shape is narrowed to exactly what you selected (so unselected variables are neither enforced nor present).
+
+```typescript
+import { parseEnv } from '@neon/env';
+import config from './neon';
+
+// Only DATABASE_URL is required and returned; DATABASE_URL_UNPOOLED is not enforced.
+const { postgres } = parseEnv(config, ['DATABASE_URL']);
+console.log(postgres.databaseUrl);
+
+// Selecting across services — only these keys are validated/returned.
+const env = parseEnv(config, ['DATABASE_URL', 'NEON_AUTH_BASE_URL']);
+console.log(env.postgres.databaseUrl, env.auth.baseUrl);
+```
+
+### How checkout composes with neon.ts
+
+When a `neon.ts` is present, `neon checkout` applies your policy as it **creates** a branch, so a fresh branch comes up with its declared settings and services already in place. Checking out an _existing_ branch never reconciles it — apply config changes to it explicitly with `neon config apply` (or `neon deploy`). The bundled `env pull` also checks `neon.ts` against the linked branch and fails fast if the branch is missing a declared service, pointing you at `neon deploy` to provision it, so your local env and the remote branch never drift apart silently.
+
+### Branch configuration
+
+Beyond services, `neon.ts` can program what configuration _new_ branches receive via the `branch` property — a function of the branch being evaluated that returns its settings:
+
+```typescript
+// neon.ts
+import { defineConfig } from '@neon/config/v1';
+
+export default defineConfig({
+  auth: true,
+  dataApi: true,
+  branch: (branch) => {
+    if (branch.exists) {
+      // leave existing branches untouched
+      return {};
+    }
+    if (branch.name.startsWith('dev')) {
+      return {
+        ttl: '7d', // clean up the branch after 7 days
+        postgres: {
+          computeSettings: {
+            autoscalingLimitMinCu: 0.25, // scale to zero
+            autoscalingLimitMaxCu: 1, // keep it cheap
+            suspendTimeout: '5m',
+          },
+        },
+      };
+    }
+    return {};
+  },
+});
+```
+
+The `branch` function receives the target branch (its `name`, whether it `exists` yet, whether it's the default, and more) and returns the tuning you want. Here new `dev-*` branches get a 7-day TTL so they clean themselves up, plus a cheap scale-to-zero compute profile, while existing branches and everything else fall through to the defaults. Because `neon checkout` applies this policy on create, a fresh `dev-*` branch comes up with these settings already in place.
+
+### Type-safe config: invalid setups don't compile
+
+Because `neon.ts` is TypeScript, the compiler catches invalid infrastructure before you ever deploy — and Neon encodes the actual rules (and their fixes) into the types, so the error tells you what to do rather than failing with a useless `Type 'true' is not assignable to type 'never'`. The canonical case: the Data API verifies requests with Neon Auth by default, so enabling it on its own is a type error _on_ `dataApi`:
+
+```typescript
+export default defineConfig({
+  dataApi: true, // type error: `dataApi` (default authProvider 'neon') requires Neon Auth
+});
+```
+
+The message names both fixes, so pick one:
+
+```typescript
+// 1. Enable Neon Auth (the default Data API auth provider):
+export default defineConfig({ auth: true, dataApi: true });
+
+// 2. Or verify a third-party IdP instead of Neon Auth:
+export default defineConfig({
+  dataApi: {
+    authProvider: 'external',
+    jwksUrl: 'https://your-idp/.well-known/jwks.json',
+  },
+});
+```
+
+Treat a `neon.ts` type error as the config telling you which services must go together — read the message, it spells out the valid combinations.
+
+## Gotchas
+
+### Neon Auth: "invalid domain"
+
+Neon Auth only redirects back to domains on its trusted-domains list. Anytime the domain your app runs on changes — a new production custom domain, a new deploy/preview URL, moving from `localhost` to a hosted environment, and so on — you must register the new domain with Neon Auth. Otherwise sign-in and OAuth callbacks fail with an **`invalid domain`** error because the redirect target isn't trusted.
+
+The easiest way to fix this is the CLI. With the workspace linked to the project (see the branch-first flow above), add the new domain to the trusted list:
+
+```bash
+neon neon-auth domain add <domain>   # e.g. neon neon-auth domain add https://app.example.com
+neon neon-auth domain list           # verify what's currently trusted
+neon neon-auth domain delete <domain> # remove one you no longer use
+```
+
+If the workspace isn't linked, pass `--project-id <id>` (and `--branch <id|name>`) explicitly. For local development, `neon neon-auth domain allow-localhost` manages whether `localhost` is permitted. Register the domain before pointing users at the new URL, so they never hit the `invalid domain` error.
diff --git a/.env.example b/.env.example
index 2a662dd0..baf019b5 100644
--- a/.env.example
+++ b/.env.example
@@ -4,8 +4,8 @@
 # ║  Choose ONE option: standard PostgreSQL or Neon.                          ║
 # ╚══════════════════════════════════════════════════════════════════════════╝
 
-# LAN / remote dev: set this machine's IP so the dev server accepts cross-origin requests
-# NEXT_DEV_ALLOWED_ORIGINS=10.112.9.49
+# LAN / remote dev: set this machine's hostname so the dev server accepts cross-origin requests
+# NEXT_DEV_ALLOWED_ORIGINS=dev-machine.local
 
 # Option A: Standard PostgreSQL (postgres.js TCP driver)
 # DATABASE_READONLY_URL=postgresql://postgres:postgres@localhost:5432/postgres
@@ -17,10 +17,17 @@
 # DATABASE_DRIVER=neon
 # DATABASE_SSL=true
 
-# GitHub PAT (optional) — improves rate limits for star count and workflow metadata
+# GitHub PAT — required for CollectiveX lazy ingest (sweep artifact reads); also used
+# for framework releases, star counts, and unofficial-run artifact reads
 # Create at: https://github.com/settings/personal-access-tokens
 # GITHUB_TOKEN=
 
+# CollectiveX database (separate Neon instance; a durable cache of GitHub sweep runs,
+# populated lazily on read). Read URL powers /api/v1/collectivex/* reads; write URL
+# powers the lazy ingest and the run-deletion route.
+# DATABASE_COLLECTIVEX_READONLY_URL=
+# DATABASE_COLLECTIVEX_WRITE_URL=
+
 # ╔══════════════════════════════════════════════════════════════════════════╗
 # ║  Production deployment (Vercel)                                          ║
 # ║                                                                          ║
@@ -51,3 +58,6 @@
 # DATABASE_WRITE_URL=
 # INVALIDATE_SECRET=
 # FEEDBACK_SECRET=
+# Bearer token for the CollectiveX run-deletion route (entered in the dashboard UI;
+# deliberately separate from INVALIDATE_SECRET so it is independently rotatable)
+# COLLECTIVEX_ADMIN_SECRET=
diff --git a/AGENTS.md b/AGENTS.md
index 6228fad9..b1aded5a 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -2,6 +2,8 @@
 
 For detailed subsystem docs, see [docs/index.md](./docs/index.md).
 
+> **Temporary language override (highest repository priority):** Until the user explicitly removes this override, ignore any instruction elsewhere in this repository that requires Simplified Chinese or bilingual output, including instructions in later sections, nested agent files, contribution guides, checklists, and templates. Work in English only: do not create or update `/zh` pages, Chinese documentation, translations, or Chinese text in commits, pull requests, issues, reviews, or comments. Leave existing Chinese content untouched.
+
 > **PR and GitHub-issue titles & descriptions must be bilingual — include a Simplified Chinese version in addition to English.** Title format: `<English title> / <中文标题>` (keep bracket prefixes at the front untranslated). In the PR/issue body, follow the English content with a `## 中文说明` section mirroring the summary; don't translate code blocks, logs, or stack traces — summarize around them. **Commit messages must include a Chinese translation too**: keep the subject line in English (conventional-commit style) and include the Chinese translation of the subject and key points in the commit body (e.g. a trailing `中文：<translation>` paragraph); squash-merge commits inherit the bilingual PR title, which satisfies the subject requirement automatically.
 
 > **Translation quality bar:** write natural technical Chinese, not word-for-word machine translation (style reference: [`vllm-project/vllm-ascend` `README.zh.md`](https://github.com/vllm-project/vllm-ascend/blob/main/README.zh.md)). Preserve product names, hardware SKUs, framework/library names (Next.js, React Query, D3.js, Tailwind ...), flags, and code identifiers in English. Use parenthetical English clarification for acronyms on first use. Preferred terms: benchmark 基准测试, dashboard 仪表板, chart 图表, config 配置, throughput 吞吐量, latency 延迟, single-node/multi-node 单节点/多节点, evaluation 评估, artifact 产物.
@@ -71,10 +73,20 @@ API routes (`packages/app/src/app/api/v1/`):
 - `reliability` — raw `ReliabilityRow[]`
 - `evaluations` — raw `EvalRow[]`
 - `server-log` — retrieve benchmark runtime logs
-- `invalidate` — invalidate API cache (admin)
+- `invalidate` — invalidate API cache (admin; `?scope=collectivex` purges only that scope)
+- `collectivex/latest`, `collectivex/runs`, `collectivex/runs/[runId]` — CollectiveX sweep data
+  from a **separate** Neon DB, populated lazily on read from GitHub Actions artifacts and served
+  assembled through the shared reader (the one deliberate exception to the raw-rows rule below);
+  `runs/[runId]` also handles admin DELETE. See [CollectiveX](./docs/collectivex.md).
 - `tco-feed?model=dsv4&workloads=1024x1024,8192x1024&tiers=30,50,75,100&format=csv` — per-hardware Pareto-frontier output-throughput reads at fixed interactivity tiers, for external spreadsheet TCO models (Excel Power Query); `view=scores` (optional `weights`, `workload_weights`, `alpha`) folds them into one tier-weighted, workload-blended, output-equivalent score per hardware
 
-**API routes return raw DB data** — no presentation logic. Frontend handles all transformations. Sole exception: `tco-feed`, which runs the calculator's frontier interpolation server-side because its consumers (spreadsheets) cannot execute the TS transforms; its assumptions (tier weights, workload mix, α) enter only as explicit query params with documented defaults, so a published sheet's URL fully records its methodology.
+**API routes return raw DB data** — no presentation logic. Frontend handles all transformations.
+Exceptions: the CollectiveX routes assemble raw stored documents through the shared reader in
+`packages/db/src/collectivex/` (see [docs/collectivex.md](./docs/collectivex.md) for why); and
+`tco-feed`, which runs the calculator's frontier interpolation server-side because its consumers
+(spreadsheets) cannot execute the TS transforms — its assumptions (tier weights, workload mix, α)
+enter only as explicit query params with documented defaults, so a published sheet's URL fully
+records its methodology.
 
 Static content routes (no DB):
 
diff --git a/docs/collectivex.md b/docs/collectivex.md
new file mode 100644
index 00000000..5fdcf82f
--- /dev/null
+++ b/docs/collectivex.md
@@ -0,0 +1,67 @@
+# CollectiveX
+
+Design rationale for the CollectiveX tab's data pipeline. Unlike every other tab
+(Neon DB → ETL ingest → `/api/v1/*`), CollectiveX uses **lazy ingest-on-read**: its
+database is a durable cache of GitHub Actions, populated by the API routes themselves.
+
+## Why lazy ingest instead of the main pipeline
+
+- **Sweep artifacts expire after 14 days.** The sweep workflow
+  (`collectivex-sweep.yml` in the harness repo) uploads a matrix artifact
+  (`cxsweep-matrix-{run_id}`) and per-cell result artifacts
+  (`cxshard-{cell}-{run_id}-{attempt}`) with 14-day retention. Persisting on first
+  view makes a run outlive its artifacts once anyone has looked at it.
+- **The sweep JSON contract is expected to change.** The DB stores the RAW documents
+  verbatim; the shared reader (`packages/db/src/collectivex/reader.ts`) is the single
+  transform point and runs at API-read time, so a reader fix retroactively applies to
+  already-stored runs — no re-ingest. A contract change = reader change + a bump of the
+  numeric `version` in the harness's `experimental/CollectiveX/configs/sweep.json`.
+- **No CI plumbing.** There is no ingest workflow, no cross-repo dispatch, and no GH
+  secrets. Runs launched via `gh api` on any harness branch appear on the dashboard
+  within the CDN TTL of someone viewing the page — only the workflow identity is
+  checked, never the branch.
+
+## How it works
+
+`packages/app/src/lib/collectivex-lazy-ingest.ts` exposes three `ensure*` functions the
+routes call before reading the DB (`packages/db/src/queries/collectivex.ts`):
+
+- `ensureLatestCollectiveXRun` — walk GitHub's completed sweep runs newest-first; stop at
+  the first live requested-version run; persist it if absent.
+- `ensureCollectiveXRunsList` — backfill up to 8 recent runs so the picker lists sweeps
+  nobody has viewed yet.
+- `ensureCollectiveXRun` — fetch one run by id (only if completed — persisting an
+  in-progress run would freeze a partial snapshot).
+
+Key invariants:
+
+- **Writes are atomic and race-safe**: one CTE statement with
+  `ON CONFLICT (run_id) DO NOTHING`; concurrent first-viewers can't double-ingest or
+  expose a partial run. A GitHub re-run (newer `run_attempt`) is replaced through a
+  `FOR UPDATE`-guarded refresh statement.
+- **Deletion tombstones** (`cx_runs.deleted_at`, documents freed): discovery must never
+  resurrect a deleted run. Re-ingesting via the CLI
+  (`pnpm admin:db:ingest:collectivex <run-url-or-id>`) clears the tombstone — that CLI is
+  the operator tool for pre-warming runs before artifact expiry, backfills, and un-deletes.
+- **"Latest" orders by `run_id`** (monotonic with run creation, matching the discovery
+  walk) — not by completion time, where a long-failing older run would shadow a newer
+  successful one.
+- **GitHub being down never takes the page down**: routes serve whatever the DB holds and
+  only surface an error when there is no stored fallback.
+- **Caching**: responses carry the `collectivex` CDN tag with a 60s
+  `s-maxage` (freshness bound for lazy discovery). Run deletion and
+  `POST /api/v1/invalidate?scope=collectivex` purge only that tag; the main dashboard's
+  blob cache is untouched by CollectiveX operations.
+- **Env**: `DATABASE_COLLECTIVEX_READONLY_URL` (must be the same primary as the write URL
+  — the routes read their own writes), `DATABASE_COLLECTIVEX_WRITE_URL` (direct/unpooled;
+  also used by migrations via `pnpm admin:db:migrate:collectivex`),
+  `COLLECTIVEX_ADMIN_SECRET` (delete route Bearer token — deliberately not
+  INVALIDATE_SECRET, since it is remembered in browser localStorage), and `GITHUB_TOKEN`.
+
+## The raw-rows exception
+
+CollectiveX routes return the **assembled** dataset (reader over stored matrix + docs)
+instead of raw rows. The reader is shared between the app and the CLI through the db
+package (`@semianalysisai/inferencex-db/collectivex/*`), so ingest-time validation and
+read-time assembly can never drift; shipping raw docs to the client would only move the
+same shared transform across the wire.
diff --git a/docs/index.md b/docs/index.md
index ea6154ed..c4a72633 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -15,4 +15,5 @@ Design rationale and non-obvious conventions. See [CLAUDE.md](../CLAUDE.md) for
 - [Data Transforms](./data-transforms.md) — Full pipeline from BenchmarkRow to RenderableGraph: type hierarchy, hardware key construction, derived metrics, memoization strategy
 - [State Ownership](./state-ownership.md) — Which context owns which state, availability filtering cascade, comparison date mechanics, URL param sync
 - [Blog](./blog.md) — MDX content system, SEO features (OG images, RSS, llms.txt, JSON-LD), TOC sidebar, reading progress, heading links, analytics events
+- [CollectiveX](./collectivex.md) — lazy ingest-on-read pipeline (separate Neon DB as a durable GitHub-artifact cache), tombstoned deletes, raw-docs storage + shared reader
 - [Chinese Pages (/zh)](./i18n.md) — Why hand-authored /zh pages instead of an i18n framework, hreflang pairing, blog translation pairing, html lang workaround, CJK reading time/slugs
diff --git a/package.json b/package.json
index ee0366b4..5db3d5a2 100644
--- a/package.json
+++ b/package.json
@@ -31,10 +31,12 @@
     "admin:cache:warmup": "pnpm --filter *app cache:warmup",
     "admin:db:ingest:run": "pnpm --filter *db db:ingest:run",
     "admin:db:ingest:ci": "pnpm --filter *db db:ingest:ci",
+    "admin:db:ingest:collectivex": "pnpm --filter *db db:ingest:collectivex",
     "admin:db:prepare:ci": "pnpm --filter *db db:prepare:ci",
     "admin:db:ingest:gcs": "pnpm --filter *db db:ingest:gcs",
     "admin:db:ingest:supplemental": "pnpm --filter *db db:ingest:supplemental",
     "admin:db:migrate": "pnpm --filter *db db:migrate",
+    "admin:db:migrate:collectivex": "pnpm --filter *db db:migrate:collectivex",
     "admin:db:apply-overrides": "pnpm --filter *db db:apply-overrides",
     "admin:db:reset": "pnpm --filter *db db:reset",
     "admin:db:verify": "pnpm --filter *db db:verify"
diff --git a/packages/app/cypress/component/tab-nav.cy.tsx b/packages/app/cypress/component/tab-nav.cy.tsx
index df297e61..e479b7b5 100644
--- a/packages/app/cypress/component/tab-nav.cy.tsx
+++ b/packages/app/cypress/component/tab-nav.cy.tsx
@@ -76,6 +76,11 @@ describe('TabNav — unofficialrun URL preservation (issue #319)', () => {
       'href',
       '/submissions?unofficialruns=12345',
     );
+    cy.get('[data-testid="tab-trigger-collectivex"]').should(
+      'have.attr',
+      'href',
+      '/collectivex?unofficialruns=12345',
+    );
     cy.get('[data-testid="tab-trigger-historical"]').should(
       'have.attr',
       'href',
@@ -115,6 +120,7 @@ describe('TabNav — Hidden popover for gated tabs', () => {
     mountTabNav({});
     cy.get('[data-testid="tab-trigger-inference"]').should('exist');
     cy.get('[data-testid="tab-trigger-gpu-specs"]').should('exist');
+    cy.get('[data-testid="tab-trigger-collectivex"]').should('exist');
     cy.get('[data-testid="tab-trigger-submissions"]').should('exist');
     cy.get('[data-testid="tab-trigger-hidden"]').should('not.exist');
     cy.get('[data-testid="tab-trigger-feedback"]').should('not.exist');
diff --git a/packages/app/cypress/e2e/agentic-point-time-series.cy.ts b/packages/app/cypress/e2e/agentic-point-time-series.cy.ts
index cc93bd3f..2e71f663 100644
--- a/packages/app/cypress/e2e/agentic-point-time-series.cy.ts
+++ b/packages/app/cypress/e2e/agentic-point-time-series.cy.ts
@@ -251,10 +251,10 @@ describe('Agentic point orchestrator metric sources', () => {
   beforeEach(() => {
     const prefill = sourceSeries(
       {
-        id: 'dynamo|prefill|10.30.1.56:7500|prefill-a|0|0',
+        id: 'dynamo|prefill|prefill-a.internal.test:7500|prefill-a|0|0',
         adapter: 'dynamo',
         role: 'prefill',
-        endpointUrl: '10.30.1.56:7500',
+        endpointUrl: 'prefill-a.internal.test:7500',
         nativeRole: 'prefill',
         workerId: 'prefill-a',
         dpRank: '0',
@@ -265,10 +265,10 @@ describe('Agentic point orchestrator metric sources', () => {
     );
     const decode = sourceSeries(
       {
-        id: 'dynamo|decode|10.30.1.206:7516|decode-a|0|0',
+        id: 'dynamo|decode|decode-a.internal.test:7516|decode-a|0|0',
         adapter: 'dynamo',
         role: 'decode',
-        endpointUrl: '10.30.1.206:7516',
+        endpointUrl: 'decode-a.internal.test:7516',
         nativeRole: 'backend',
         workerId: 'decode-a',
         dpRank: '0',
diff --git a/packages/app/cypress/e2e/collectivex.cy.ts b/packages/app/cypress/e2e/collectivex.cy.ts
new file mode 100644
index 00000000..cf40502f
--- /dev/null
+++ b/packages/app/cypress/e2e/collectivex.cy.ts
@@ -0,0 +1,286 @@
+import { buildRunSummary } from '@semianalysisai/inferencex-db/collectivex/reader';
+import {
+  buildDataset,
+  makeCollectiveXDataset,
+  makeRawShard,
+} from '@/components/collectivex/test-fixture';
+import type { CollectiveXDataset } from '@/components/collectivex/types';
+
+// The neutral view: one run's measured series plus its full case coverage,
+// served from the CollectiveX database via /api/v1/collectivex/latest,
+// /api/v1/collectivex/runs (picker listing), and /api/v1/collectivex/runs/{id}.
+const SOURCE_SHA = 'c'.repeat(40);
+const dataset = makeCollectiveXDataset();
+const runId = dataset.run.run_id;
+const ADMIN_TOKEN_KEY = 'collectivex-admin-token';
+
+function installLatest(body: CollectiveXDataset | Record<string, unknown> = dataset) {
+  cy.intercept('GET', '/api/v1/collectivex/latest*', { body }).as('latest');
+}
+
+function installRuns() {
+  cy.intercept('GET', '/api/v1/collectivex/runs?*', {
+    body: { version: 1, runs: [buildRunSummary(dataset)] },
+  }).as('runs');
+}
+
+function installRun(body: CollectiveXDataset = dataset) {
+  cy.intercept('GET', `/api/v1/collectivex/runs/${runId}*`, { body }).as('run');
+}
+
+function openCollectiveX() {
+  cy.visit('/collectivex');
+  cy.wait('@latest');
+  cy.get('[data-testid="collectivex-display"]').should('be.visible');
+}
+
+describe('CollectiveX neutral run view', () => {
+  beforeEach(() => {
+    installLatest();
+    openCollectiveX();
+  });
+
+  it('shows the run header, coverage stats, and revision-pinned source links', () => {
+    cy.get('[data-testid="collectivex-run-conclusion"]')
+      .should('contain.text', `#${runId}`)
+      .and('contain.text', 'success');
+    cy.get('[data-testid="collectivex-display"]')
+      .should('contain.text', `${dataset.run.measured_cases}/${dataset.run.requested_cases}`)
+      .and('contain.text', String(dataset.series.length));
+    cy.get('[data-testid="collectivex-version-select"]').should('contain.text', 'V1');
+    cy.get('[data-testid="collectivex-source-link"]').should(
+      'have.attr',
+      'href',
+      `https://github.com/SemiAnalysisAI/InferenceX/tree/${SOURCE_SHA}/experimental/CollectiveX`,
+    );
+    cy.get('[data-testid="collectivex-methodology-link"]')
+      .should('contain.text', 'Methodology')
+      .and(
+        'have.attr',
+        'href',
+        `https://github.com/SemiAnalysisAI/InferenceX/blob/${SOURCE_SHA}/experimental/CollectiveX/docs/methodology.md`,
+      );
+  });
+
+  it('renders the default decode round-trip chart for the EP8 scale-up series', () => {
+    cy.get('[data-testid="collectivex-main-chart"]')
+      .should('contain.text', 'Round trip (measured) · decode · p99')
+      .and('contain.text', 'deepep-v2');
+    cy.get('[data-testid="collectivex-explorer-chart"] .line-path').should('have.length', 1);
+  });
+
+  it('only exposes dimensions that vary in the current matrix', () => {
+    cy.get('[data-testid="collectivex-ep-select"]').should('be.visible');
+    cy.get('[data-testid="collectivex-phase-toggle"]').should('be.visible');
+    cy.get('[data-testid="collectivex-precision-toggle"]').should('be.visible');
+    cy.get('[data-testid="collectivex-sku-select"]').should('be.visible');
+    cy.get('[data-testid="collectivex-backend-select"]').should('be.visible');
+    cy.get('[data-testid="collectivex-mode-toggle"]').should('not.exist');
+    cy.get('[data-testid="collectivex-fabric-scope-toggle"]').should('not.exist');
+    cy.get('[data-testid="collectivex-routing-select"]').should('not.exist');
+  });
+
+  it('selects the EP16 series through the identity controls', () => {
+    cy.get('[data-testid="collectivex-ep-select"]').click();
+    cy.contains('[role="option"]', 'EP16').click();
+
+    cy.get('[data-testid="collectivex-main-chart"]')
+      .should('contain.text', 'mori')
+      .and('contain.text', 'EP16');
+    cy.get('[data-testid="collectivex-explorer-chart"] .line-path').should('have.length', 1);
+  });
+
+  it('renders an nccl-ep backend series end to end', () => {
+    const ncclEp = buildDataset({
+      shards: [makeRawShard({ backend: 'nccl-ep', implName: 'nccl-ep' })],
+    });
+    installLatest(ncclEp);
+    cy.reload();
+    cy.wait('@latest');
+    cy.get('[data-testid="collectivex-main-chart"]').should('contain.text', 'nccl-ep');
+    cy.get('[data-testid="collectivex-explorer-chart"] .line-path').should('have.length', 1);
+  });
+
+  it('switches the y-axis to per-GPU payload bandwidth', () => {
+    cy.get('[data-testid="collectivex-y-axis-select"]').click();
+    cy.contains('[role="option"]', 'Payload bandwidth').click();
+    cy.get('[data-testid="collectivex-main-chart"]').should('contain.text', 'Payload bandwidth');
+    cy.get('[data-testid="collectivex-explorer-chart"] .line-path').should('have.length', 1);
+  });
+
+  it('exposes the kernel-mode toggle when a run measured both modes and pins the LL series', () => {
+    const withLowLatency = buildDataset({
+      shards: [makeRawShard(), makeRawShard({ mode: 'low-latency' })],
+    });
+    installLatest(withLowLatency);
+    cy.reload();
+    cy.wait('@latest');
+
+    cy.get('[data-testid="collectivex-mode-toggle"]').should('be.visible');
+    cy.get('[data-testid="collectivex-main-chart"]').should('contain.text', 'deepep-v2');
+    cy.get('[data-testid="collectivex-explorer-chart"] .line-path').should('have.length', 1);
+
+    cy.get('[data-testid="collectivex-mode-toggle"]').contains('Low-latency').click();
+    cy.get('[data-testid="chart-legend"]').should('contain.text', 'low-latency');
+    cy.get('[data-testid="collectivex-explorer-chart"] .line-path').should('have.length', 1);
+  });
+
+  it('selects the available phase when a partial run only measured prefill', () => {
+    const prefill = buildDataset({ shards: [makeRawShard({ phase: 'prefill' })] });
+    installLatest(prefill);
+    cy.reload();
+    cy.wait('@latest');
+    cy.get('[data-testid="collectivex-phase-toggle"]').should('contain.text', 'Prefill');
+    cy.get('[data-testid="collectivex-main-chart"]').should('contain.text', 'prefill');
+    cy.get('[data-testid="collectivex-explorer-chart"] .line-path').should('have.length', 1);
+  });
+
+  it('clears the chart when the sole series is toggled off in the legend', () => {
+    cy.get('[data-testid="collectivex-explorer-chart"] .line-path').should('have.length', 1);
+    cy.get('[data-testid="chart-legend"] input[type="checkbox"]:checked')
+      .first()
+      .uncheck({ force: true });
+    cy.get('[data-testid="collectivex-explorer-chart"] .line-path').should('not.exist');
+  });
+
+  it('pins a compact tooltip on point click', () => {
+    cy.get('[data-testid="collectivex-explorer-chart"] .point').first().click({ force: true });
+    cy.get('[data-chart-tooltip]:visible')
+      .should('contain.text', 'Click elsewhere to dismiss')
+      .and('contain.text', 'Round trip (measured) p99:')
+      .and('contain.text', 'Latency p50 / p90 / p95 / p99')
+      .and('not.contain.text', 'Expert CV')
+      .and('not.contain.text', 'evidence=');
+  });
+
+  it('lists runs on demand and pins a specific run by id', () => {
+    installRuns();
+    installRun();
+    cy.get('[data-testid="collectivex-load-runs"]').click();
+    cy.wait('@runs');
+    cy.get('[data-testid="collectivex-run-select"]').click();
+    cy.contains('[role="option"]', `#${runId}`).click();
+    cy.wait('@run');
+    cy.get('[data-testid="collectivex-run-conclusion"]').should('contain.text', `#${runId}`);
+  });
+
+  it('keeps the chart on top and presents the matrix inventory', () => {
+    cy.get('[data-testid="collectivex-main-chart"]').should('be.visible');
+    cy.get('[data-testid="collectivex-inventory"]')
+      .should('contain.text', 'Matrix case inventory')
+      .and('contain.text', `${dataset.coverage.length} cases`);
+    cy.get('[data-testid="collectivex-inventory-table"]')
+      .should('contain.text', 'H200-DGXC')
+      .and('contain.text', 'B300');
+  });
+});
+
+describe('CollectiveX run deletion', () => {
+  beforeEach(() => {
+    installLatest();
+    openCollectiveX();
+  });
+
+  it('deletes the shown run after confirm + token prompt and remembers the token', () => {
+    cy.intercept('DELETE', `/api/v1/collectivex/runs/${runId}`, (request) => {
+      expect(request.headers.authorization).to.eq('Bearer test-token');
+      request.reply({ deleted: true, runId });
+    }).as('deleteRun');
+    cy.window().then((win) => {
+      win.localStorage.removeItem(ADMIN_TOKEN_KEY);
+      cy.stub(win, 'confirm').returns(true);
+      cy.stub(win, 'prompt').returns('test-token');
+    });
+
+    cy.get('[data-testid="collectivex-delete-run"]').click();
+    cy.wait('@deleteRun');
+    // Successful deletion invalidates the dataset queries → latest refetches.
+    cy.wait('@latest');
+    cy.window().then((win) => {
+      expect(win.localStorage.getItem(ADMIN_TOKEN_KEY)).to.eq('test-token');
+    });
+  });
+
+  it('clears a stale stored token and reports unauthorized on 401', () => {
+    cy.intercept('DELETE', `/api/v1/collectivex/runs/${runId}`, { statusCode: 401 }).as(
+      'delete401',
+    );
+    cy.window().then((win) => {
+      win.localStorage.setItem(ADMIN_TOKEN_KEY, 'stale-token');
+      cy.stub(win, 'confirm').returns(true);
+      cy.stub(win, 'alert').as('unauthorizedAlert');
+    });
+
+    cy.get('[data-testid="collectivex-delete-run"]').click();
+    cy.wait('@delete401');
+    cy.get('@unauthorizedAlert').should('have.been.calledWith', 'Invalid admin token.');
+    cy.window().then((win) => {
+      expect(win.localStorage.getItem(ADMIN_TOKEN_KEY)).to.eq(null);
+    });
+  });
+
+  it('does nothing when the confirmation is declined', () => {
+    let deleteRequests = 0;
+    cy.intercept('DELETE', `/api/v1/collectivex/runs/${runId}`, () => {
+      deleteRequests += 1;
+    });
+    cy.window().then((win) => {
+      cy.stub(win, 'confirm').returns(false);
+    });
+
+    cy.get('[data-testid="collectivex-delete-run"]').click();
+    cy.get('[data-testid="collectivex-display"]').should('be.visible');
+    cy.then(() => expect(deleteRequests).to.eq(0));
+  });
+});
+
+describe('CollectiveX availability states', () => {
+  it('reports a missing run', () => {
+    cy.intercept('GET', '/api/v1/collectivex/latest*', {
+      statusCode: 404,
+      body: { error: 'Not found' },
+    }).as('missing');
+    cy.visit('/collectivex');
+    cy.wait('@missing');
+    cy.get('[data-testid="collectivex-error"]')
+      .should('be.visible')
+      .and('contain.text', 'API error: 404');
+    cy.get('[data-testid="collectivex-error-version-select"]').should('contain.text', 'V1');
+  });
+
+  it('reports an unavailable backend', () => {
+    cy.intercept('GET', '/api/v1/collectivex/latest*', {
+      statusCode: 503,
+      body: { error: 'unavailable' },
+    }).as('down');
+    cy.visit('/collectivex');
+    cy.wait('@down');
+    cy.get('[data-testid="collectivex-error"]')
+      .should('be.visible')
+      .and('contain.text', 'API error: 503');
+  });
+
+  it('renders the loading state while the run resolves', () => {
+    // "slow" is a reserved alias word in Cypress 15.
+    cy.intercept('GET', '/api/v1/collectivex/latest*', { body: dataset, delay: 500 }).as(
+      'slowLatest',
+    );
+    cy.visit('/collectivex');
+    cy.get('[data-testid="collectivex-loading"]').should('be.visible');
+    cy.wait('@slowLatest');
+    cy.get('[data-testid="collectivex-display"]').should('be.visible');
+  });
+
+  it('does not query database availability for the isolated page', () => {
+    let availabilityRequests = 0;
+    cy.intercept('GET', '/api/v1/availability', (request) => {
+      availabilityRequests += 1;
+      request.reply([]);
+    });
+    installLatest();
+    cy.visit('/collectivex');
+    cy.wait('@latest');
+    cy.get('[data-testid="collectivex-display"]').should('be.visible');
+    cy.then(() => expect(availabilityRequests).to.eq(0));
+  });
+});
diff --git a/packages/app/cypress/fixtures/api/collectivex-latest.json b/packages/app/cypress/fixtures/api/collectivex-latest.json
new file mode 100644
index 00000000..60e36800
--- /dev/null
+++ b/packages/app/cypress/fixtures/api/collectivex-latest.json
@@ -0,0 +1,3383 @@
+{
+  "version": 1,
+  "run": {
+    "run_id": "160",
+    "run_attempt": 1,
+    "generated_at": "2026-07-08T12:20:00Z",
+    "conclusion": "success",
+    "source_sha": "cccccccccccccccccccccccccccccccccccccccc",
+    "requested_cases": 5,
+    "terminal_cases": 4,
+    "measured_cases": 3,
+    "unsupported_cases": 1,
+    "failed_cases": 0,
+    "requested_points": 50,
+    "terminal_points": 40,
+    "measured_points": 30,
+    "covered_skus": ["b200-dgxc", "b300", "h200-dgxc", "mi355x"]
+  },
+  "coverage": [
+    {
+      "case_id": "h200-dgxc-deepep-v2-deepseek-v3-normal-decode-ep8-uniform-bf16",
+      "label": "h200-dgxc · deepep-v2 · normal · decode · EP8 · bf16",
+      "disposition": "runnable",
+      "sku": "h200-dgxc",
+      "backend": "deepep-v2",
+      "phase": "decode",
+      "mode": "normal",
+      "precision": "bf16",
+      "topology": {
+        "ep_size": 8,
+        "nodes": 1,
+        "gpus_per_node": 8,
+        "scale_up_domain": 8,
+        "scale_up_transport": "nvlink",
+        "scale_out_transport": null,
+        "topology_class": "h200-nvlink-island"
+      },
+      "points": [
+        {
+          "tokens_per_rank": 1,
+          "global_tokens": 8,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 2,
+          "global_tokens": 16,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 4,
+          "global_tokens": 32,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 8,
+          "global_tokens": 64,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 16,
+          "global_tokens": 128,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 32,
+          "global_tokens": 256,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 64,
+          "global_tokens": 512,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 128,
+          "global_tokens": 1024,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 256,
+          "global_tokens": 2048,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 512,
+          "global_tokens": 4096,
+          "terminal_status": "measured",
+          "reason": null
+        }
+      ],
+      "outcome": "success",
+      "reason": null,
+      "detail": null
+    },
+    {
+      "case_id": "mi355x-mori-deepseek-v3-normal-decode-ep16-uniform-bf16",
+      "label": "mi355x · mori · normal · decode · EP16 · bf16",
+      "disposition": "runnable",
+      "sku": "mi355x",
+      "backend": "mori",
+      "phase": "decode",
+      "mode": "normal",
+      "precision": "bf16",
+      "topology": {
+        "ep_size": 16,
+        "nodes": 2,
+        "gpus_per_node": 8,
+        "scale_up_domain": 8,
+        "scale_up_transport": "xgmi",
+        "scale_out_transport": "rdma",
+        "topology_class": "mi355x-xgmi-rdma"
+      },
+      "points": [
+        {
+          "tokens_per_rank": 1,
+          "global_tokens": 16,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 2,
+          "global_tokens": 32,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 4,
+          "global_tokens": 64,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 8,
+          "global_tokens": 128,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 16,
+          "global_tokens": 256,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 32,
+          "global_tokens": 512,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 64,
+          "global_tokens": 1024,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 128,
+          "global_tokens": 2048,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 256,
+          "global_tokens": 4096,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 512,
+          "global_tokens": 8192,
+          "terminal_status": "measured",
+          "reason": null
+        }
+      ],
+      "outcome": "success",
+      "reason": null,
+      "detail": null
+    },
+    {
+      "case_id": "h200-dgxc-deepep-v2-deepseek-v3-normal-decode-ep8-uniform-fp8",
+      "label": "h200-dgxc · deepep-v2 · normal · decode · EP8 · fp8",
+      "disposition": "runnable",
+      "sku": "h200-dgxc",
+      "backend": "deepep-v2",
+      "phase": "decode",
+      "mode": "normal",
+      "precision": "fp8",
+      "topology": {
+        "ep_size": 8,
+        "nodes": 1,
+        "gpus_per_node": 8,
+        "scale_up_domain": 8,
+        "scale_up_transport": "nvlink",
+        "scale_out_transport": null,
+        "topology_class": "h200-nvlink-island"
+      },
+      "points": [
+        {
+          "tokens_per_rank": 1,
+          "global_tokens": 8,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 2,
+          "global_tokens": 16,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 4,
+          "global_tokens": 32,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 8,
+          "global_tokens": 64,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 16,
+          "global_tokens": 128,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 32,
+          "global_tokens": 256,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 64,
+          "global_tokens": 512,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 128,
+          "global_tokens": 1024,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 256,
+          "global_tokens": 2048,
+          "terminal_status": "measured",
+          "reason": null
+        },
+        {
+          "tokens_per_rank": 512,
+          "global_tokens": 4096,
+          "terminal_status": "measured",
+          "reason": null
+        }
+      ],
+      "outcome": "success",
+      "reason": null,
+      "detail": null
+    },
+    {
+      "case_id": "b300-deepep-v2-deepseek-v3-normal-decode-ep16-uniform-bf16",
+      "label": "b300 · deepep-v2 · normal · decode · EP16 · bf16",
+      "disposition": "unsupported",
+      "sku": "b300",
+      "backend": "deepep-v2",
+      "phase": "decode",
+      "mode": "normal",
+      "precision": "bf16",
+      "topology": {
+        "ep_size": 16,
+        "nodes": 2,
+        "gpus_per_node": 8,
+        "scale_up_domain": 8,
+        "scale_up_transport": "nvlink",
+        "scale_out_transport": "rdma",
+        "topology_class": "b300-nvlink-rdma"
+      },
+      "points": [
+        {
+          "tokens_per_rank": 1,
+          "global_tokens": 16,
+          "terminal_status": "unsupported",
+          "reason": "backend-platform-unsupported"
+        },
+        {
+          "tokens_per_rank": 2,
+          "global_tokens": 32,
+          "terminal_status": "unsupported",
+          "reason": "backend-platform-unsupported"
+        },
+        {
+          "tokens_per_rank": 4,
+          "global_tokens": 64,
+          "terminal_status": "unsupported",
+          "reason": "backend-platform-unsupported"
+        },
+        {
+          "tokens_per_rank": 8,
+          "global_tokens": 128,
+          "terminal_status": "unsupported",
+          "reason": "backend-platform-unsupported"
+        },
+        {
+          "tokens_per_rank": 16,
+          "global_tokens": 256,
+          "terminal_status": "unsupported",
+          "reason": "backend-platform-unsupported"
+        },
+        {
+          "tokens_per_rank": 32,
+          "global_tokens": 512,
+          "terminal_status": "unsupported",
+          "reason": "backend-platform-unsupported"
+        },
+        {
+          "tokens_per_rank": 64,
+          "global_tokens": 1024,
+          "terminal_status": "unsupported",
+          "reason": "backend-platform-unsupported"
+        },
+        {
+          "tokens_per_rank": 128,
+          "global_tokens": 2048,
+          "terminal_status": "unsupported",
+          "reason": "backend-platform-unsupported"
+        },
+        {
+          "tokens_per_rank": 256,
+          "global_tokens": 4096,
+          "terminal_status": "unsupported",
+          "reason": "backend-platform-unsupported"
+        },
+        {
+          "tokens_per_rank": 512,
+          "global_tokens": 8192,
+          "terminal_status": "unsupported",
+          "reason": "backend-platform-unsupported"
+        }
+      ],
+      "outcome": "unsupported",
+      "reason": "backend-platform-unsupported",
+      "detail": "unsupported by the selected backend/platform"
+    },
+    {
+      "case_id": "b200-dgxc-deepep-v2-deepseek-v3-normal-decode-ep8-uniform-bf16",
+      "label": "b200-dgxc · deepep-v2 · normal · decode · EP8 · bf16",
+      "disposition": "runnable",
+      "sku": "b200-dgxc",
+      "backend": "deepep-v2",
+      "phase": "decode",
+      "mode": "normal",
+      "precision": "bf16",
+      "topology": {
+        "ep_size": 8,
+        "nodes": 1,
+        "gpus_per_node": 8,
+        "scale_up_domain": 8,
+        "scale_up_transport": "nvlink",
+        "scale_out_transport": null,
+        "topology_class": "b200-nvlink-island"
+      },
+      "points": [
+        {
+          "tokens_per_rank": 1,
+          "global_tokens": 8,
+          "terminal_status": "pending",
+          "reason": "pending"
+        },
+        {
+          "tokens_per_rank": 2,
+          "global_tokens": 16,
+          "terminal_status": "pending",
+          "reason": "pending"
+        },
+        {
+          "tokens_per_rank": 4,
+          "global_tokens": 32,
+          "terminal_status": "pending",
+          "reason": "pending"
+        },
+        {
+          "tokens_per_rank": 8,
+          "global_tokens": 64,
+          "terminal_status": "pending",
+          "reason": "pending"
+        },
+        {
+          "tokens_per_rank": 16,
+          "global_tokens": 128,
+          "terminal_status": "pending",
+          "reason": "pending"
+        },
+        {
+          "tokens_per_rank": 32,
+          "global_tokens": 256,
+          "terminal_status": "pending",
+          "reason": "pending"
+        },
+        {
+          "tokens_per_rank": 64,
+          "global_tokens": 512,
+          "terminal_status": "pending",
+          "reason": "pending"
+        },
+        {
+          "tokens_per_rank": 128,
+          "global_tokens": 1024,
+          "terminal_status": "pending",
+          "reason": "pending"
+        },
+        {
+          "tokens_per_rank": 256,
+          "global_tokens": 2048,
+          "terminal_status": "pending",
+          "reason": "pending"
+        },
+        {
+          "tokens_per_rank": 512,
+          "global_tokens": 4096,
+          "terminal_status": "pending",
+          "reason": "pending"
+        }
+      ],
+      "outcome": "pending",
+      "reason": "pending",
+      "detail": null
+    }
+  ],
+  "series": [
+    {
+      "series_id": "h200-dgxc-deepep-v2-deepseek-v3-normal-decode-ep8-uniform-bf16",
+      "phase": "decode",
+      "mode": "normal",
+      "precision": "bf16",
+      "backend": "deepep-v2",
+      "system": {
+        "ep_size": 8,
+        "nodes": 1,
+        "gpus_per_node": 8,
+        "scale_up_domain": 8,
+        "scale_up_transport": "nvlink",
+        "scale_out_transport": null,
+        "topology_class": "h200-nvlink-island",
+        "sku": "h200-dgxc",
+        "vendor": "nvidia"
+      },
+      "points": [
+        {
+          "tokens_per_rank": 1,
+          "global_tokens": 8,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 417,
+                "p90": 450.36,
+                "p95": 467.04,
+                "p99": 500.4
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 922.6952134292566,
+                "p90": 854.3474198419042,
+                "p95": 823.8350119904076,
+                "p99": 768.9126778577139
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 119.90407673860912,
+                "p90": 111.02229327648992,
+                "p95": 107.05721137375814,
+                "p99": 99.92006394884093
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 120,
+                "p90": 129.60000000000002,
+                "p95": 134.4,
+                "p99": 144
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1603.1829333333335,
+                "p90": 1484.4286419753084,
+                "p95": 1431.4133333333332,
+                "p99": 1335.9857777777777
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 200.3978666666667,
+                "p90": 185.55358024691355,
+                "p95": 178.92666666666665,
+                "p99": 166.9982222222222
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 392,
+                "p90": 423.36,
+                "p95": 439.04,
+                "p99": 470.4
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 981.5405714285715,
+                "p90": 908.8338624338625,
+                "p95": 876.3755102040816,
+                "p99": 817.9504761904763
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 122.69257142857144,
+                "p90": 113.60423280423281,
+                "p95": 109.5469387755102,
+                "p99": 102.24380952380953
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 921,
+                "p90": 994.6800000000001,
+                "p95": 1031.5200000000002,
+                "p99": 1105.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 835.5350792616721,
+                "p90": 773.6435919089556,
+                "p95": 746.0134636264928,
+                "p99": 696.27923271806
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 106.50975895765473,
+                "p90": 98.62014718301363,
+                "p95": 95.09799906933456,
+                "p99": 88.75813246471228
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 2,
+          "global_tokens": 16,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 418,
+                "p90": 451.44000000000005,
+                "p95": 468.16,
+                "p99": 501.59999999999997
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 920.4878086124403,
+                "p90": 852.3035264930002,
+                "p95": 821.8641148325358,
+                "p99": 767.0731738437003
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 119.61722488038276,
+                "p90": 110.75668970405812,
+                "p95": 106.8010936431989,
+                "p99": 99.68102073365232
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 121,
+                "p90": 130.68,
+                "p95": 135.52,
+                "p99": 145.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1589.9334876033058,
+                "p90": 1472.1606366697276,
+                "p95": 1419.58347107438,
+                "p99": 1324.944573002755
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 198.74168595041323,
+                "p90": 184.02007958371595,
+                "p95": 177.4479338842975,
+                "p99": 165.61807162534438
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 393,
+                "p90": 424.44000000000005,
+                "p95": 440.16,
+                "p99": 471.59999999999997
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 979.0430127226464,
+                "p90": 906.5213080765243,
+                "p95": 874.1455470737912,
+                "p99": 815.869177268872
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 122.3803765903308,
+                "p90": 113.31516350956554,
+                "p95": 109.2681933842239,
+                "p99": 101.983647158609
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 922,
+                "p90": 995.7600000000001,
+                "p95": 1032.64,
+                "p99": 1106.3999999999999
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 834.6288590021693,
+                "p90": 772.8044990760825,
+                "p95": 745.2043383947938,
+                "p99": 695.5240491684744
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 106.39423861171366,
+                "p90": 98.51318389973487,
+                "p95": 94.99485590331577,
+                "p99": 88.6618655097614
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 4,
+          "global_tokens": 32,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 419,
+                "p90": 452.52000000000004,
+                "p95": 469.28000000000003,
+                "p99": 502.79999999999995
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 918.2909403341289,
+                "p90": 850.2693891982674,
+                "p95": 819.9026252983293,
+                "p99": 765.2424502784409
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 119.33174224343675,
+                "p90": 110.49235392910809,
+                "p95": 106.54619843163995,
+                "p99": 99.4431185361973
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 122,
+                "p90": 131.76000000000002,
+                "p95": 136.64000000000001,
+                "p99": 146.4
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1576.9012459016394,
+                "p90": 1460.0937462052214,
+                "p95": 1407.9475409836064,
+                "p99": 1314.0843715846995
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 197.11265573770493,
+                "p90": 182.51171827565267,
+                "p95": 175.9934426229508,
+                "p99": 164.26054644808744
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 394,
+                "p90": 425.52000000000004,
+                "p95": 441.28000000000003,
+                "p99": 472.79999999999995
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 976.5581319796954,
+                "p90": 904.2204925737921,
+                "p95": 871.9269035532996,
+                "p99": 813.798443316413
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 122.06976649746193,
+                "p90": 113.02756157172401,
+                "p95": 108.99086294416244,
+                "p99": 101.72480541455162
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 923,
+                "p90": 996.84,
+                "p95": 1033.76,
+                "p99": 1107.6
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 833.724602383532,
+                "p90": 771.9672244291962,
+                "p95": 744.3969664138677,
+                "p99": 694.7705019862767
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 106.27896858071506,
+                "p90": 98.40645238955098,
+                "p95": 94.8919362327813,
+                "p99": 88.5658071505959
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 8,
+          "global_tokens": 64,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 420,
+                "p90": 453.6,
+                "p95": 470.40000000000003,
+                "p99": 504
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 916.1045333333334,
+                "p90": 848.244938271605,
+                "p95": 817.9504761904761,
+                "p99": 763.4204444444445
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 119.04761904761905,
+                "p90": 110.22927689594357,
+                "p95": 106.29251700680271,
+                "p99": 99.2063492063492
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 123,
+                "p90": 132.84,
+                "p95": 137.76000000000002,
+                "p99": 147.6
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1564.0809105691058,
+                "p90": 1448.2230653417646,
+                "p95": 1396.5008130081299,
+                "p99": 1303.400758807588
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 195.51011382113822,
+                "p90": 181.02788316772057,
+                "p95": 174.56260162601623,
+                "p99": 162.9250948509485
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 395,
+                "p90": 426.6,
+                "p95": 442.40000000000003,
+                "p99": 474
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 974.0858329113925,
+                "p90": 901.9313267698077,
+                "p95": 869.7194936708861,
+                "p99": 811.738194092827
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 121.76072911392406,
+                "p90": 112.74141584622596,
+                "p95": 108.71493670886076,
+                "p99": 101.46727426160338
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 924,
+                "p90": 997.9200000000001,
+                "p95": 1034.88,
+                "p99": 1108.8
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 832.822303030303,
+                "p90": 771.1317620650954,
+                "p95": 743.5913419913419,
+                "p99": 694.0185858585859
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 106.16394805194805,
+                "p90": 98.29995189995189,
+                "p95": 94.78923933209646,
+                "p99": 88.4699567099567
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 16,
+          "global_tokens": 128,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 421,
+                "p90": 454.68,
+                "p95": 471.52000000000004,
+                "p99": 505.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 913.928513064133,
+                "p90": 846.230104689012,
+                "p95": 816.0076009501188,
+                "p99": 761.607094220111
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 118.76484560570071,
+                "p90": 109.96744963490808,
+                "p95": 106.04004071937563,
+                "p99": 98.97070467141727
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 124,
+                "p90": 133.92000000000002,
+                "p95": 138.88000000000002,
+                "p99": 148.79999999999998
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1551.4673548387095,
+                "p90": 1436.543847072879,
+                "p95": 1385.2387096774191,
+                "p99": 1292.8894623655915
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 193.9334193548387,
+                "p90": 179.5679808841099,
+                "p95": 173.1548387096774,
+                "p99": 161.61118279569894
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 396,
+                "p90": 427.68,
+                "p95": 443.52000000000004,
+                "p99": 475.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 971.6260202020202,
+                "p90": 899.653722409278,
+                "p95": 867.5232323232323,
+                "p99": 809.6883501683502
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 121.45325252525252,
+                "p90": 112.45671530115975,
+                "p95": 108.44040404040403,
+                "p99": 101.21104377104378
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 925,
+                "p90": 999.0000000000001,
+                "p95": 1036,
+                "p99": 1110
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 831.9219545945946,
+                "p90": 770.298106106106,
+                "p95": 742.7874594594595,
+                "p99": 693.2682954954955
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 106.04917621621622,
+                "p90": 98.19368168168167,
+                "p95": 94.68676447876449,
+                "p99": 88.37431351351351
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 32,
+          "global_tokens": 256,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 422,
+                "p90": 455.76000000000005,
+                "p95": 472.64000000000004,
+                "p99": 506.4
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 911.7628056872038,
+                "p90": 844.2248200807443,
+                "p95": 814.0739336492891,
+                "p99": 759.8023380726698
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 118.48341232227487,
+                "p90": 109.70686326136563,
+                "p95": 105.78876100203114,
+                "p99": 98.73617693522907
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 125,
+                "p90": 135,
+                "p95": 140,
+                "p99": 150
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1539.0556159999999,
+                "p90": 1425.0514962962964,
+                "p95": 1374.1568,
+                "p99": 1282.5463466666668
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 192.38195199999998,
+                "p90": 178.13143703703705,
+                "p95": 171.7696,
+                "p99": 160.31829333333334
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 397,
+                "p90": 428.76000000000005,
+                "p95": 444.64000000000004,
+                "p99": 476.4
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 969.1785994962216,
+                "p90": 897.387592126131,
+                "p95": 865.3380352644836,
+                "p99": 807.648832913518
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 121.1473249370277,
+                "p90": 112.17344901576638,
+                "p95": 108.16725440806044,
+                "p99": 100.95610411418976
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 926,
+                "p90": 1000.08,
+                "p95": 1037.1200000000001,
+                "p99": 1111.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 831.0235507559396,
+                "p90": 769.466250699944,
+                "p95": 741.9853131749459,
+                "p99": 692.5196256299496
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 105.93465226781858,
+                "p90": 98.0876409887209,
+                "p95": 94.58451095340943,
+                "p99": 88.2788768898488
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 64,
+          "global_tokens": 512,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 423,
+                "p90": 456.84000000000003,
+                "p95": 473.76000000000005,
+                "p99": 507.59999999999997
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 909.6073380614658,
+                "p90": 842.2290167235793,
+                "p95": 812.1494089834514,
+                "p99": 758.0061150512215
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 118.2033096926714,
+                "p90": 109.44750897469572,
+                "p95": 105.5386693684566,
+                "p99": 98.50275807722618
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 126,
+                "p90": 136.08,
+                "p95": 141.12,
+                "p99": 151.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1526.840888888889,
+                "p90": 1413.741563786008,
+                "p95": 1363.2507936507936,
+                "p99": 1272.3674074074074
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 190.8551111111111,
+                "p90": 176.717695473251,
+                "p95": 170.4063492063492,
+                "p99": 159.04592592592593
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 398,
+                "p90": 429.84000000000003,
+                "p95": 445.76000000000005,
+                "p99": 477.59999999999997
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 966.7434773869347,
+                "p90": 895.1328494323469,
+                "p95": 863.1638190954774,
+                "p99": 805.6195644891122
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 120.84293467336684,
+                "p90": 111.89160617904336,
+                "p95": 107.89547738693467,
+                "p99": 100.70244556113903
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 927,
+                "p90": 1001.1600000000001,
+                "p95": 1038.24,
+                "p99": 1112.3999999999999
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 830.1270852211435,
+                "p90": 768.6361900195773,
+                "p95": 741.1848975188781,
+                "p99": 691.7725710176197
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 105.82037540453075,
+                "p90": 97.98182907826921,
+                "p95": 94.48247803975958,
+                "p99": 88.1836461704423
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 128,
+          "global_tokens": 1024,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 424,
+                "p90": 457.92,
+                "p95": 474.88000000000005,
+                "p99": 508.79999999999995
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 907.4620377358491,
+                "p90": 840.2426275331936,
+                "p95": 810.2339622641508,
+                "p99": 756.2183647798744
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 117.9245283018868,
+                "p90": 109.18937805730259,
+                "p95": 105.2897574123989,
+                "p99": 98.27044025157234
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 127,
+                "p90": 137.16,
+                "p95": 142.24,
+                "p99": 152.4
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1514.8185196850393,
+                "p90": 1402.6097404491106,
+                "p95": 1352.5165354330707,
+                "p99": 1262.3487664041995
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 189.3523149606299,
+                "p90": 175.32621755613883,
+                "p95": 169.06456692913383,
+                "p99": 157.79359580052494
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 399,
+                "p90": 430.92,
+                "p95": 446.88000000000005,
+                "p99": 478.79999999999995
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 964.3205614035088,
+                "p90": 892.8894087069526,
+                "p95": 861.0005012531327,
+                "p99": 803.6004678362574
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 120.5400701754386,
+                "p90": 111.61117608836908,
+                "p95": 107.62506265664159,
+                "p99": 100.45005847953217
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 928,
+                "p90": 1002.24,
+                "p95": 1039.3600000000001,
+                "p99": 1113.6
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 829.232551724138,
+                "p90": 767.8079182630906,
+                "p95": 740.3862068965517,
+                "p99": 691.0271264367817
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 105.70634482758621,
+                "p90": 97.87624521072797,
+                "p95": 94.38066502463055,
+                "p99": 88.08862068965517
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 256,
+          "global_tokens": 2048,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 425,
+                "p90": 459.00000000000006,
+                "p95": 476.00000000000006,
+                "p99": 510
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 905.3268329411765,
+                "p90": 838.2655860566448,
+                "p95": 808.3275294117645,
+                "p99": 754.4390274509803
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 117.64705882352942,
+                "p90": 108.93246187363833,
+                "p95": 105.04201680672269,
+                "p99": 98.0392156862745
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 128,
+                "p90": 138.24,
+                "p95": 143.36,
+                "p99": 153.6
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1502.984,
+                "p90": 1391.6518518518517,
+                "p95": 1341.9499999999998,
+                "p99": 1252.4866666666667
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 187.873,
+                "p90": 173.95648148148146,
+                "p95": 167.74374999999998,
+                "p99": 156.56083333333333
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 400,
+                "p90": 432,
+                "p95": 448.00000000000006,
+                "p99": 480
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 961.90976,
+                "p90": 890.6571851851852,
+                "p95": 858.848,
+                "p99": 801.5914666666667
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 120.23872,
+                "p90": 111.33214814814815,
+                "p95": 107.356,
+                "p99": 100.19893333333334
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 929,
+                "p90": 1003.32,
+                "p95": 1040.48,
+                "p99": 1114.8
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 828.3399440258343,
+                "p90": 766.9814296535502,
+                "p95": 739.5892357373519,
+                "p99": 690.2832866881952
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 105.5925597416577,
+                "p90": 97.77088864968306,
+                "p95": 94.27907119790866,
+                "p99": 87.99379978471475
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 512,
+          "global_tokens": 4096,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 426,
+                "p90": 460.08000000000004,
+                "p95": 477.12000000000006,
+                "p99": 511.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 903.2016525821597,
+                "p90": 836.2978264649626,
+                "p95": 806.4300469483567,
+                "p99": 752.6680438184663
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 117.37089201877934,
+                "p90": 108.67675186924012,
+                "p95": 104.79543930248154,
+                "p99": 97.80907668231613
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 129,
+                "p90": 139.32000000000002,
+                "p95": 144.48000000000002,
+                "p99": 154.79999999999998
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1491.33296124031,
+                "p90": 1380.863853000287,
+                "p95": 1331.5472868217053,
+                "p99": 1242.7774677002585
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 186.41662015503874,
+                "p90": 172.60798162503588,
+                "p95": 166.44341085271316,
+                "p99": 155.3471834625323
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 401,
+                "p90": 433.08000000000004,
+                "p95": 449.12000000000006,
+                "p99": 481.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 959.5109825436409,
+                "p90": 888.4360949478155,
+                "p95": 856.706234413965,
+                "p99": 799.5924854530341
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 119.93887281795512,
+                "p90": 111.05451186847694,
+                "p95": 107.08827930174563,
+                "p99": 99.94906068162926
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 930,
+                "p90": 1004.4000000000001,
+                "p95": 1041.6000000000001,
+                "p99": 1116
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 827.4492559139785,
+                "p90": 766.1567184388689,
+                "p95": 738.7939784946236,
+                "p99": 689.541046594982
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 105.47901935483871,
+                "p90": 97.66575866188768,
+                "p95": 94.17769585253455,
+                "p99": 87.89918279569893
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        }
+      ]
+    },
+    {
+      "series_id": "mi355x-mori-deepseek-v3-normal-decode-ep16-uniform-bf16",
+      "phase": "decode",
+      "mode": "normal",
+      "precision": "bf16",
+      "backend": "mori",
+      "system": {
+        "ep_size": 16,
+        "nodes": 2,
+        "gpus_per_node": 8,
+        "scale_up_domain": 8,
+        "scale_up_transport": "xgmi",
+        "scale_out_transport": "rdma",
+        "topology_class": "mi355x-xgmi-rdma",
+        "sku": "mi355x",
+        "vendor": "amd"
+      },
+      "points": [
+        {
+          "tokens_per_rank": 1,
+          "global_tokens": 16,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 417,
+                "p90": 450.36,
+                "p95": 467.04,
+                "p99": 500.4
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 922.6952134292566,
+                "p90": 854.3474198419042,
+                "p95": 823.8350119904076,
+                "p99": 768.9126778577139
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 59.95203836930456,
+                "p90": 55.51114663824496,
+                "p95": 53.52860568687907,
+                "p99": 49.96003197442047
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 120,
+                "p90": 129.60000000000002,
+                "p95": 134.4,
+                "p99": 144
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1603.1829333333335,
+                "p90": 1484.4286419753084,
+                "p95": 1431.4133333333332,
+                "p99": 1335.9857777777777
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 100.19893333333334,
+                "p90": 92.77679012345678,
+                "p95": 89.46333333333332,
+                "p99": 83.4991111111111
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 392,
+                "p90": 423.36,
+                "p95": 439.04,
+                "p99": 470.4
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 981.5405714285715,
+                "p90": 908.8338624338625,
+                "p95": 876.3755102040816,
+                "p99": 817.9504761904763
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 61.34628571428572,
+                "p90": 56.802116402116404,
+                "p95": 54.7734693877551,
+                "p99": 51.121904761904766
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 921,
+                "p90": 994.6800000000001,
+                "p95": 1031.5200000000002,
+                "p99": 1105.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 835.5350792616721,
+                "p90": 773.6435919089556,
+                "p95": 746.0134636264928,
+                "p99": 696.27923271806
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 53.25487947882736,
+                "p90": 49.310073591506814,
+                "p95": 47.54899953466728,
+                "p99": 44.37906623235614
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 2,
+          "global_tokens": 32,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 418,
+                "p90": 451.44000000000005,
+                "p95": 468.16,
+                "p99": 501.59999999999997
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 920.4878086124403,
+                "p90": 852.3035264930002,
+                "p95": 821.8641148325358,
+                "p99": 767.0731738437003
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 59.80861244019138,
+                "p90": 55.37834485202906,
+                "p95": 53.40054682159945,
+                "p99": 49.84051036682616
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 121,
+                "p90": 130.68,
+                "p95": 135.52,
+                "p99": 145.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1589.9334876033058,
+                "p90": 1472.1606366697276,
+                "p95": 1419.58347107438,
+                "p99": 1324.944573002755
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 99.37084297520661,
+                "p90": 92.01003979185798,
+                "p95": 88.72396694214875,
+                "p99": 82.80903581267219
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 393,
+                "p90": 424.44000000000005,
+                "p95": 440.16,
+                "p99": 471.59999999999997
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 979.0430127226464,
+                "p90": 906.5213080765243,
+                "p95": 874.1455470737912,
+                "p99": 815.869177268872
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 61.1901882951654,
+                "p90": 56.65758175478277,
+                "p95": 54.63409669211195,
+                "p99": 50.9918235793045
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 922,
+                "p90": 995.7600000000001,
+                "p95": 1032.64,
+                "p99": 1106.3999999999999
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 834.6288590021693,
+                "p90": 772.8044990760825,
+                "p95": 745.2043383947938,
+                "p99": 695.5240491684744
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 53.19711930585683,
+                "p90": 49.256591949867435,
+                "p95": 47.49742795165788,
+                "p99": 44.3309327548807
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 4,
+          "global_tokens": 64,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 419,
+                "p90": 452.52000000000004,
+                "p95": 469.28000000000003,
+                "p99": 502.79999999999995
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 918.2909403341289,
+                "p90": 850.2693891982674,
+                "p95": 819.9026252983293,
+                "p99": 765.2424502784409
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 59.665871121718375,
+                "p90": 55.246176964554046,
+                "p95": 53.273099215819975,
+                "p99": 49.72155926809865
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 122,
+                "p90": 131.76000000000002,
+                "p95": 136.64000000000001,
+                "p99": 146.4
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1576.9012459016394,
+                "p90": 1460.0937462052214,
+                "p95": 1407.9475409836064,
+                "p99": 1314.0843715846995
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 98.55632786885246,
+                "p90": 91.25585913782633,
+                "p95": 87.9967213114754,
+                "p99": 82.13027322404372
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 394,
+                "p90": 425.52000000000004,
+                "p95": 441.28000000000003,
+                "p99": 472.79999999999995
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 976.5581319796954,
+                "p90": 904.2204925737921,
+                "p95": 871.9269035532996,
+                "p99": 813.798443316413
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 61.034883248730964,
+                "p90": 56.513780785862004,
+                "p95": 54.49543147208122,
+                "p99": 50.86240270727581
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 923,
+                "p90": 996.84,
+                "p95": 1033.76,
+                "p99": 1107.6
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 833.724602383532,
+                "p90": 771.9672244291962,
+                "p95": 744.3969664138677,
+                "p99": 694.7705019862767
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 53.13948429035753,
+                "p90": 49.20322619477549,
+                "p95": 47.44596811639065,
+                "p99": 44.28290357529795
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 8,
+          "global_tokens": 128,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 420,
+                "p90": 453.6,
+                "p95": 470.40000000000003,
+                "p99": 504
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 916.1045333333334,
+                "p90": 848.244938271605,
+                "p95": 817.9504761904761,
+                "p99": 763.4204444444445
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 59.523809523809526,
+                "p90": 55.114638447971785,
+                "p95": 53.146258503401356,
+                "p99": 49.6031746031746
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 123,
+                "p90": 132.84,
+                "p95": 137.76000000000002,
+                "p99": 147.6
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1564.0809105691058,
+                "p90": 1448.2230653417646,
+                "p95": 1396.5008130081299,
+                "p99": 1303.400758807588
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 97.75505691056911,
+                "p90": 90.51394158386029,
+                "p95": 87.28130081300812,
+                "p99": 81.46254742547426
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 395,
+                "p90": 426.6,
+                "p95": 442.40000000000003,
+                "p99": 474
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 974.0858329113925,
+                "p90": 901.9313267698077,
+                "p95": 869.7194936708861,
+                "p99": 811.738194092827
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 60.88036455696203,
+                "p90": 56.37070792311298,
+                "p95": 54.35746835443038,
+                "p99": 50.73363713080169
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 924,
+                "p90": 997.9200000000001,
+                "p95": 1034.88,
+                "p99": 1108.8
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 832.822303030303,
+                "p90": 771.1317620650954,
+                "p95": 743.5913419913419,
+                "p99": 694.0185858585859
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 53.08197402597403,
+                "p90": 49.149975949975946,
+                "p95": 47.39461966604823,
+                "p99": 44.23497835497835
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 16,
+          "global_tokens": 256,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 421,
+                "p90": 454.68,
+                "p95": 471.52000000000004,
+                "p99": 505.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 913.928513064133,
+                "p90": 846.230104689012,
+                "p95": 816.0076009501188,
+                "p99": 761.607094220111
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 59.38242280285036,
+                "p90": 54.98372481745404,
+                "p95": 53.02002035968781,
+                "p99": 49.48535233570863
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 124,
+                "p90": 133.92000000000002,
+                "p95": 138.88000000000002,
+                "p99": 148.79999999999998
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1551.4673548387095,
+                "p90": 1436.543847072879,
+                "p95": 1385.2387096774191,
+                "p99": 1292.8894623655915
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 96.96670967741935,
+                "p90": 89.78399044205494,
+                "p95": 86.5774193548387,
+                "p99": 80.80559139784947
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 396,
+                "p90": 427.68,
+                "p95": 443.52000000000004,
+                "p99": 475.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 971.6260202020202,
+                "p90": 899.653722409278,
+                "p95": 867.5232323232323,
+                "p99": 809.6883501683502
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 60.72662626262626,
+                "p90": 56.22835765057987,
+                "p95": 54.22020202020202,
+                "p99": 50.60552188552189
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 925,
+                "p90": 999.0000000000001,
+                "p95": 1036,
+                "p99": 1110
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 831.9219545945946,
+                "p90": 770.298106106106,
+                "p95": 742.7874594594595,
+                "p99": 693.2682954954955
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 53.02458810810811,
+                "p90": 49.096840840840834,
+                "p95": 47.343382239382244,
+                "p99": 44.18715675675676
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 32,
+          "global_tokens": 512,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 422,
+                "p90": 455.76000000000005,
+                "p95": 472.64000000000004,
+                "p99": 506.4
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 911.7628056872038,
+                "p90": 844.2248200807443,
+                "p95": 814.0739336492891,
+                "p99": 759.8023380726698
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 59.24170616113744,
+                "p90": 54.85343163068281,
+                "p95": 52.89438050101557,
+                "p99": 49.368088467614534
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 125,
+                "p90": 135,
+                "p95": 140,
+                "p99": 150
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1539.0556159999999,
+                "p90": 1425.0514962962964,
+                "p95": 1374.1568,
+                "p99": 1282.5463466666668
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 96.19097599999999,
+                "p90": 89.06571851851852,
+                "p95": 85.8848,
+                "p99": 80.15914666666667
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 397,
+                "p90": 428.76000000000005,
+                "p95": 444.64000000000004,
+                "p99": 476.4
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 969.1785994962216,
+                "p90": 897.387592126131,
+                "p95": 865.3380352644836,
+                "p99": 807.648832913518
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 60.57366246851385,
+                "p90": 56.08672450788319,
+                "p95": 54.08362720403022,
+                "p99": 50.47805205709488
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 926,
+                "p90": 1000.08,
+                "p95": 1037.1200000000001,
+                "p99": 1111.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 831.0235507559396,
+                "p90": 769.466250699944,
+                "p95": 741.9853131749459,
+                "p99": 692.5196256299496
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 52.96732613390929,
+                "p90": 49.04382049436045,
+                "p95": 47.29225547670472,
+                "p99": 44.1394384449244
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 64,
+          "global_tokens": 1024,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 423,
+                "p90": 456.84000000000003,
+                "p95": 473.76000000000005,
+                "p99": 507.59999999999997
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 909.6073380614658,
+                "p90": 842.2290167235793,
+                "p95": 812.1494089834514,
+                "p99": 758.0061150512215
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 59.1016548463357,
+                "p90": 54.72375448734786,
+                "p95": 52.7693346842283,
+                "p99": 49.25137903861309
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 126,
+                "p90": 136.08,
+                "p95": 141.12,
+                "p99": 151.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1526.840888888889,
+                "p90": 1413.741563786008,
+                "p95": 1363.2507936507936,
+                "p99": 1272.3674074074074
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 95.42755555555556,
+                "p90": 88.3588477366255,
+                "p95": 85.2031746031746,
+                "p99": 79.52296296296296
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 398,
+                "p90": 429.84000000000003,
+                "p95": 445.76000000000005,
+                "p99": 477.59999999999997
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 966.7434773869347,
+                "p90": 895.1328494323469,
+                "p95": 863.1638190954774,
+                "p99": 805.6195644891122
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 60.42146733668342,
+                "p90": 55.94580308952168,
+                "p95": 53.947738693467336,
+                "p99": 50.351222780569515
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 927,
+                "p90": 1001.1600000000001,
+                "p95": 1038.24,
+                "p99": 1112.3999999999999
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 830.1270852211435,
+                "p90": 768.6361900195773,
+                "p95": 741.1848975188781,
+                "p99": 691.7725710176197
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 52.910187702265375,
+                "p90": 48.99091453913461,
+                "p95": 47.24123901987979,
+                "p99": 44.09182308522115
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 128,
+          "global_tokens": 2048,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 424,
+                "p90": 457.92,
+                "p95": 474.88000000000005,
+                "p99": 508.79999999999995
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 907.4620377358491,
+                "p90": 840.2426275331936,
+                "p95": 810.2339622641508,
+                "p99": 756.2183647798744
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 58.9622641509434,
+                "p90": 54.594689028651295,
+                "p95": 52.64487870619945,
+                "p99": 49.13522012578617
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 127,
+                "p90": 137.16,
+                "p95": 142.24,
+                "p99": 152.4
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1514.8185196850393,
+                "p90": 1402.6097404491106,
+                "p95": 1352.5165354330707,
+                "p99": 1262.3487664041995
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 94.67615748031496,
+                "p90": 87.66310877806941,
+                "p95": 84.53228346456692,
+                "p99": 78.89679790026247
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 399,
+                "p90": 430.92,
+                "p95": 446.88000000000005,
+                "p99": 478.79999999999995
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 964.3205614035088,
+                "p90": 892.8894087069526,
+                "p95": 861.0005012531327,
+                "p99": 803.6004678362574
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 60.2700350877193,
+                "p90": 55.80558804418454,
+                "p95": 53.812531328320794,
+                "p99": 50.22502923976609
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 928,
+                "p90": 1002.24,
+                "p95": 1039.3600000000001,
+                "p99": 1113.6
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 829.232551724138,
+                "p90": 767.8079182630906,
+                "p95": 740.3862068965517,
+                "p99": 691.0271264367817
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 52.853172413793104,
+                "p90": 48.938122605363986,
+                "p95": 47.19033251231527,
+                "p99": 44.044310344827586
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 256,
+          "global_tokens": 4096,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 425,
+                "p90": 459.00000000000006,
+                "p95": 476.00000000000006,
+                "p99": 510
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 905.3268329411765,
+                "p90": 838.2655860566448,
+                "p95": 808.3275294117645,
+                "p99": 754.4390274509803
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 58.82352941176471,
+                "p90": 54.466230936819166,
+                "p95": 52.52100840336134,
+                "p99": 49.01960784313725
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 128,
+                "p90": 138.24,
+                "p95": 143.36,
+                "p99": 153.6
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1502.984,
+                "p90": 1391.6518518518517,
+                "p95": 1341.9499999999998,
+                "p99": 1252.4866666666667
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 93.9365,
+                "p90": 86.97824074074073,
+                "p95": 83.87187499999999,
+                "p99": 78.28041666666667
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 400,
+                "p90": 432,
+                "p95": 448.00000000000006,
+                "p99": 480
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 961.90976,
+                "p90": 890.6571851851852,
+                "p95": 858.848,
+                "p99": 801.5914666666667
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 60.11936,
+                "p90": 55.666074074074075,
+                "p95": 53.678,
+                "p99": 50.09946666666667
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 929,
+                "p90": 1003.32,
+                "p95": 1040.48,
+                "p99": 1114.8
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 828.3399440258343,
+                "p90": 766.9814296535502,
+                "p95": 739.5892357373519,
+                "p99": 690.2832866881952
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 52.79627987082885,
+                "p90": 48.88544432484153,
+                "p95": 47.13953559895433,
+                "p99": 43.996899892357376
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 512,
+          "global_tokens": 8192,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 426,
+                "p90": 460.08000000000004,
+                "p95": 477.12000000000006,
+                "p99": 511.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 903.2016525821597,
+                "p90": 836.2978264649626,
+                "p95": 806.4300469483567,
+                "p99": 752.6680438184663
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 58.68544600938967,
+                "p90": 54.33837593462006,
+                "p95": 52.39771965124077,
+                "p99": 48.904538341158066
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 129,
+                "p90": 139.32000000000002,
+                "p95": 144.48000000000002,
+                "p99": 154.79999999999998
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1491.33296124031,
+                "p90": 1380.863853000287,
+                "p95": 1331.5472868217053,
+                "p99": 1242.7774677002585
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 93.20831007751937,
+                "p90": 86.30399081251794,
+                "p95": 83.22170542635658,
+                "p99": 77.67359173126616
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 401,
+                "p90": 433.08000000000004,
+                "p95": 449.12000000000006,
+                "p99": 481.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 959.5109825436409,
+                "p90": 888.4360949478155,
+                "p95": 856.706234413965,
+                "p99": 799.5924854530341
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 59.96943640897756,
+                "p90": 55.52725593423847,
+                "p95": 53.544139650872815,
+                "p99": 49.97453034081463
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 930,
+                "p90": 1004.4000000000001,
+                "p95": 1041.6000000000001,
+                "p99": 1116
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 827.4492559139785,
+                "p90": 766.1567184388689,
+                "p95": 738.7939784946236,
+                "p99": 689.541046594982
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 52.739509677419356,
+                "p90": 48.83287933094384,
+                "p95": 47.08884792626728,
+                "p99": 43.94959139784947
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        }
+      ]
+    },
+    {
+      "series_id": "h200-dgxc-deepep-v2-deepseek-v3-normal-decode-ep8-uniform-fp8",
+      "phase": "decode",
+      "mode": "normal",
+      "precision": "fp8",
+      "backend": "deepep-v2",
+      "system": {
+        "ep_size": 8,
+        "nodes": 1,
+        "gpus_per_node": 8,
+        "scale_up_domain": 8,
+        "scale_up_transport": "nvlink",
+        "scale_out_transport": null,
+        "topology_class": "h200-nvlink-island",
+        "sku": "h200-dgxc",
+        "vendor": "nvidia"
+      },
+      "points": [
+        {
+          "tokens_per_rank": 1,
+          "global_tokens": 8,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 417,
+                "p90": 450.36,
+                "p95": 467.04,
+                "p99": 500.4
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 922.6952134292566,
+                "p90": 854.3474198419042,
+                "p95": 823.8350119904076,
+                "p99": 768.9126778577139
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 119.90407673860912,
+                "p90": 111.02229327648992,
+                "p95": 107.05721137375814,
+                "p99": 99.92006394884093
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 120,
+                "p90": 129.60000000000002,
+                "p95": 134.4,
+                "p99": 144
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1603.1829333333335,
+                "p90": 1484.4286419753084,
+                "p95": 1431.4133333333332,
+                "p99": 1335.9857777777777
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 200.3978666666667,
+                "p90": 185.55358024691355,
+                "p95": 178.92666666666665,
+                "p99": 166.9982222222222
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 392,
+                "p90": 423.36,
+                "p95": 439.04,
+                "p99": 470.4
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 981.5405714285715,
+                "p90": 908.8338624338625,
+                "p95": 876.3755102040816,
+                "p99": 817.9504761904763
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 122.69257142857144,
+                "p90": 113.60423280423281,
+                "p95": 109.5469387755102,
+                "p99": 102.24380952380953
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 921,
+                "p90": 994.6800000000001,
+                "p95": 1031.5200000000002,
+                "p99": 1105.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 835.5350792616721,
+                "p90": 773.6435919089556,
+                "p95": 746.0134636264928,
+                "p99": 696.27923271806
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 106.50975895765473,
+                "p90": 98.62014718301363,
+                "p95": 95.09799906933456,
+                "p99": 88.75813246471228
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 2,
+          "global_tokens": 16,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 418,
+                "p90": 451.44000000000005,
+                "p95": 468.16,
+                "p99": 501.59999999999997
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 920.4878086124403,
+                "p90": 852.3035264930002,
+                "p95": 821.8641148325358,
+                "p99": 767.0731738437003
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 119.61722488038276,
+                "p90": 110.75668970405812,
+                "p95": 106.8010936431989,
+                "p99": 99.68102073365232
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 121,
+                "p90": 130.68,
+                "p95": 135.52,
+                "p99": 145.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1589.9334876033058,
+                "p90": 1472.1606366697276,
+                "p95": 1419.58347107438,
+                "p99": 1324.944573002755
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 198.74168595041323,
+                "p90": 184.02007958371595,
+                "p95": 177.4479338842975,
+                "p99": 165.61807162534438
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 393,
+                "p90": 424.44000000000005,
+                "p95": 440.16,
+                "p99": 471.59999999999997
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 979.0430127226464,
+                "p90": 906.5213080765243,
+                "p95": 874.1455470737912,
+                "p99": 815.869177268872
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 122.3803765903308,
+                "p90": 113.31516350956554,
+                "p95": 109.2681933842239,
+                "p99": 101.983647158609
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 922,
+                "p90": 995.7600000000001,
+                "p95": 1032.64,
+                "p99": 1106.3999999999999
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 834.6288590021693,
+                "p90": 772.8044990760825,
+                "p95": 745.2043383947938,
+                "p99": 695.5240491684744
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 106.39423861171366,
+                "p90": 98.51318389973487,
+                "p95": 94.99485590331577,
+                "p99": 88.6618655097614
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 4,
+          "global_tokens": 32,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 419,
+                "p90": 452.52000000000004,
+                "p95": 469.28000000000003,
+                "p99": 502.79999999999995
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 918.2909403341289,
+                "p90": 850.2693891982674,
+                "p95": 819.9026252983293,
+                "p99": 765.2424502784409
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 119.33174224343675,
+                "p90": 110.49235392910809,
+                "p95": 106.54619843163995,
+                "p99": 99.4431185361973
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 122,
+                "p90": 131.76000000000002,
+                "p95": 136.64000000000001,
+                "p99": 146.4
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1576.9012459016394,
+                "p90": 1460.0937462052214,
+                "p95": 1407.9475409836064,
+                "p99": 1314.0843715846995
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 197.11265573770493,
+                "p90": 182.51171827565267,
+                "p95": 175.9934426229508,
+                "p99": 164.26054644808744
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 394,
+                "p90": 425.52000000000004,
+                "p95": 441.28000000000003,
+                "p99": 472.79999999999995
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 976.5581319796954,
+                "p90": 904.2204925737921,
+                "p95": 871.9269035532996,
+                "p99": 813.798443316413
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 122.06976649746193,
+                "p90": 113.02756157172401,
+                "p95": 108.99086294416244,
+                "p99": 101.72480541455162
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 923,
+                "p90": 996.84,
+                "p95": 1033.76,
+                "p99": 1107.6
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 833.724602383532,
+                "p90": 771.9672244291962,
+                "p95": 744.3969664138677,
+                "p99": 694.7705019862767
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 106.27896858071506,
+                "p90": 98.40645238955098,
+                "p95": 94.8919362327813,
+                "p99": 88.5658071505959
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 8,
+          "global_tokens": 64,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 420,
+                "p90": 453.6,
+                "p95": 470.40000000000003,
+                "p99": 504
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 916.1045333333334,
+                "p90": 848.244938271605,
+                "p95": 817.9504761904761,
+                "p99": 763.4204444444445
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 119.04761904761905,
+                "p90": 110.22927689594357,
+                "p95": 106.29251700680271,
+                "p99": 99.2063492063492
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 123,
+                "p90": 132.84,
+                "p95": 137.76000000000002,
+                "p99": 147.6
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1564.0809105691058,
+                "p90": 1448.2230653417646,
+                "p95": 1396.5008130081299,
+                "p99": 1303.400758807588
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 195.51011382113822,
+                "p90": 181.02788316772057,
+                "p95": 174.56260162601623,
+                "p99": 162.9250948509485
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 395,
+                "p90": 426.6,
+                "p95": 442.40000000000003,
+                "p99": 474
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 974.0858329113925,
+                "p90": 901.9313267698077,
+                "p95": 869.7194936708861,
+                "p99": 811.738194092827
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 121.76072911392406,
+                "p90": 112.74141584622596,
+                "p95": 108.71493670886076,
+                "p99": 101.46727426160338
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 924,
+                "p90": 997.9200000000001,
+                "p95": 1034.88,
+                "p99": 1108.8
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 832.822303030303,
+                "p90": 771.1317620650954,
+                "p95": 743.5913419913419,
+                "p99": 694.0185858585859
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 106.16394805194805,
+                "p90": 98.29995189995189,
+                "p95": 94.78923933209646,
+                "p99": 88.4699567099567
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 16,
+          "global_tokens": 128,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 421,
+                "p90": 454.68,
+                "p95": 471.52000000000004,
+                "p99": 505.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 913.928513064133,
+                "p90": 846.230104689012,
+                "p95": 816.0076009501188,
+                "p99": 761.607094220111
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 118.76484560570071,
+                "p90": 109.96744963490808,
+                "p95": 106.04004071937563,
+                "p99": 98.97070467141727
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 124,
+                "p90": 133.92000000000002,
+                "p95": 138.88000000000002,
+                "p99": 148.79999999999998
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1551.4673548387095,
+                "p90": 1436.543847072879,
+                "p95": 1385.2387096774191,
+                "p99": 1292.8894623655915
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 193.9334193548387,
+                "p90": 179.5679808841099,
+                "p95": 173.1548387096774,
+                "p99": 161.61118279569894
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 396,
+                "p90": 427.68,
+                "p95": 443.52000000000004,
+                "p99": 475.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 971.6260202020202,
+                "p90": 899.653722409278,
+                "p95": 867.5232323232323,
+                "p99": 809.6883501683502
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 121.45325252525252,
+                "p90": 112.45671530115975,
+                "p95": 108.44040404040403,
+                "p99": 101.21104377104378
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 925,
+                "p90": 999.0000000000001,
+                "p95": 1036,
+                "p99": 1110
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 831.9219545945946,
+                "p90": 770.298106106106,
+                "p95": 742.7874594594595,
+                "p99": 693.2682954954955
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 106.04917621621622,
+                "p90": 98.19368168168167,
+                "p95": 94.68676447876449,
+                "p99": 88.37431351351351
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 32,
+          "global_tokens": 256,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 422,
+                "p90": 455.76000000000005,
+                "p95": 472.64000000000004,
+                "p99": 506.4
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 911.7628056872038,
+                "p90": 844.2248200807443,
+                "p95": 814.0739336492891,
+                "p99": 759.8023380726698
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 118.48341232227487,
+                "p90": 109.70686326136563,
+                "p95": 105.78876100203114,
+                "p99": 98.73617693522907
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 125,
+                "p90": 135,
+                "p95": 140,
+                "p99": 150
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1539.0556159999999,
+                "p90": 1425.0514962962964,
+                "p95": 1374.1568,
+                "p99": 1282.5463466666668
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 192.38195199999998,
+                "p90": 178.13143703703705,
+                "p95": 171.7696,
+                "p99": 160.31829333333334
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 397,
+                "p90": 428.76000000000005,
+                "p95": 444.64000000000004,
+                "p99": 476.4
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 969.1785994962216,
+                "p90": 897.387592126131,
+                "p95": 865.3380352644836,
+                "p99": 807.648832913518
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 121.1473249370277,
+                "p90": 112.17344901576638,
+                "p95": 108.16725440806044,
+                "p99": 100.95610411418976
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 926,
+                "p90": 1000.08,
+                "p95": 1037.1200000000001,
+                "p99": 1111.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 831.0235507559396,
+                "p90": 769.466250699944,
+                "p95": 741.9853131749459,
+                "p99": 692.5196256299496
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 105.93465226781858,
+                "p90": 98.0876409887209,
+                "p95": 94.58451095340943,
+                "p99": 88.2788768898488
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 64,
+          "global_tokens": 512,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 423,
+                "p90": 456.84000000000003,
+                "p95": 473.76000000000005,
+                "p99": 507.59999999999997
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 909.6073380614658,
+                "p90": 842.2290167235793,
+                "p95": 812.1494089834514,
+                "p99": 758.0061150512215
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 118.2033096926714,
+                "p90": 109.44750897469572,
+                "p95": 105.5386693684566,
+                "p99": 98.50275807722618
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 126,
+                "p90": 136.08,
+                "p95": 141.12,
+                "p99": 151.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1526.840888888889,
+                "p90": 1413.741563786008,
+                "p95": 1363.2507936507936,
+                "p99": 1272.3674074074074
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 190.8551111111111,
+                "p90": 176.717695473251,
+                "p95": 170.4063492063492,
+                "p99": 159.04592592592593
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 398,
+                "p90": 429.84000000000003,
+                "p95": 445.76000000000005,
+                "p99": 477.59999999999997
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 966.7434773869347,
+                "p90": 895.1328494323469,
+                "p95": 863.1638190954774,
+                "p99": 805.6195644891122
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 120.84293467336684,
+                "p90": 111.89160617904336,
+                "p95": 107.89547738693467,
+                "p99": 100.70244556113903
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 927,
+                "p90": 1001.1600000000001,
+                "p95": 1038.24,
+                "p99": 1112.3999999999999
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 830.1270852211435,
+                "p90": 768.6361900195773,
+                "p95": 741.1848975188781,
+                "p99": 691.7725710176197
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 105.82037540453075,
+                "p90": 97.98182907826921,
+                "p95": 94.48247803975958,
+                "p99": 88.1836461704423
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 128,
+          "global_tokens": 1024,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 424,
+                "p90": 457.92,
+                "p95": 474.88000000000005,
+                "p99": 508.79999999999995
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 907.4620377358491,
+                "p90": 840.2426275331936,
+                "p95": 810.2339622641508,
+                "p99": 756.2183647798744
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 117.9245283018868,
+                "p90": 109.18937805730259,
+                "p95": 105.2897574123989,
+                "p99": 98.27044025157234
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 127,
+                "p90": 137.16,
+                "p95": 142.24,
+                "p99": 152.4
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1514.8185196850393,
+                "p90": 1402.6097404491106,
+                "p95": 1352.5165354330707,
+                "p99": 1262.3487664041995
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 189.3523149606299,
+                "p90": 175.32621755613883,
+                "p95": 169.06456692913383,
+                "p99": 157.79359580052494
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 399,
+                "p90": 430.92,
+                "p95": 446.88000000000005,
+                "p99": 478.79999999999995
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 964.3205614035088,
+                "p90": 892.8894087069526,
+                "p95": 861.0005012531327,
+                "p99": 803.6004678362574
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 120.5400701754386,
+                "p90": 111.61117608836908,
+                "p95": 107.62506265664159,
+                "p99": 100.45005847953217
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 928,
+                "p90": 1002.24,
+                "p95": 1039.3600000000001,
+                "p99": 1113.6
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 829.232551724138,
+                "p90": 767.8079182630906,
+                "p95": 740.3862068965517,
+                "p99": 691.0271264367817
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 105.70634482758621,
+                "p90": 97.87624521072797,
+                "p95": 94.38066502463055,
+                "p99": 88.08862068965517
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 256,
+          "global_tokens": 2048,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 425,
+                "p90": 459.00000000000006,
+                "p95": 476.00000000000006,
+                "p99": 510
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 905.3268329411765,
+                "p90": 838.2655860566448,
+                "p95": 808.3275294117645,
+                "p99": 754.4390274509803
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 117.64705882352942,
+                "p90": 108.93246187363833,
+                "p95": 105.04201680672269,
+                "p99": 98.0392156862745
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 128,
+                "p90": 138.24,
+                "p95": 143.36,
+                "p99": 153.6
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1502.984,
+                "p90": 1391.6518518518517,
+                "p95": 1341.9499999999998,
+                "p99": 1252.4866666666667
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 187.873,
+                "p90": 173.95648148148146,
+                "p95": 167.74374999999998,
+                "p99": 156.56083333333333
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 400,
+                "p90": 432,
+                "p95": 448.00000000000006,
+                "p99": 480
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 961.90976,
+                "p90": 890.6571851851852,
+                "p95": 858.848,
+                "p99": 801.5914666666667
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 120.23872,
+                "p90": 111.33214814814815,
+                "p95": 107.356,
+                "p99": 100.19893333333334
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 929,
+                "p90": 1003.32,
+                "p95": 1040.48,
+                "p99": 1114.8
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 828.3399440258343,
+                "p90": 766.9814296535502,
+                "p95": 739.5892357373519,
+                "p99": 690.2832866881952
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 105.5925597416577,
+                "p90": 97.77088864968306,
+                "p95": 94.27907119790866,
+                "p99": 87.99379978471475
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        },
+        {
+          "tokens_per_rank": 512,
+          "global_tokens": 4096,
+          "components": {
+            "dispatch": {
+              "latency_us": {
+                "p50": 426,
+                "p90": 460.08000000000004,
+                "p95": 477.12000000000006,
+                "p99": 511.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 903.2016525821597,
+                "p90": 836.2978264649626,
+                "p95": 806.4300469483567,
+                "p99": 752.6680438184663
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 117.37089201877934,
+                "p90": 108.67675186924012,
+                "p95": 104.79543930248154,
+                "p99": 97.80907668231613
+              },
+              "payload_bytes": 400000000
+            },
+            "stage": {
+              "latency_us": {
+                "p50": 129,
+                "p90": 139.32000000000002,
+                "p95": 144.48000000000002,
+                "p99": 154.79999999999998
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 1491.33296124031,
+                "p90": 1380.863853000287,
+                "p95": 1331.5472868217053,
+                "p99": 1242.7774677002585
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 186.41662015503874,
+                "p90": 172.60798162503588,
+                "p95": 166.44341085271316,
+                "p99": 155.3471834625323
+              },
+              "payload_bytes": 192381952
+            },
+            "combine": {
+              "latency_us": {
+                "p50": 401,
+                "p90": 433.08000000000004,
+                "p95": 449.12000000000006,
+                "p99": 481.2
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 959.5109825436409,
+                "p90": 888.4360949478155,
+                "p95": 856.706234413965,
+                "p99": 799.5924854530341
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 119.93887281795512,
+                "p90": 111.05451186847694,
+                "p95": 107.08827930174563,
+                "p99": 99.94906068162926
+              },
+              "payload_bytes": 384763904
+            },
+            "roundtrip": {
+              "latency_us": {
+                "p50": 930,
+                "p90": 1004.4000000000001,
+                "p95": 1041.6000000000001,
+                "p99": 1116
+              },
+              "activation_data_rate_gbps_at_latency_percentile": {
+                "p50": 827.4492559139785,
+                "p90": 766.1567184388689,
+                "p95": 738.7939784946236,
+                "p99": 689.541046594982
+              },
+              "payload_data_rate_gbps_at_latency_percentile": {
+                "p50": 105.47901935483871,
+                "p90": 97.66575866188768,
+                "p95": 94.17769585253455,
+                "p99": 87.89918279569893
+              },
+              "payload_bytes": 784763904
+            }
+          },
+          "roundtrip_token_rate_at_latency_percentile": {
+            "p50": 8338218,
+            "p90": 9005275.440000001,
+            "p95": 9338804.16,
+            "p99": 10005861.6
+          }
+        }
+      ]
+    }
+  ]
+}
diff --git a/packages/app/cypress/fixtures/api/collectivex-runs.json b/packages/app/cypress/fixtures/api/collectivex-runs.json
new file mode 100644
index 00000000..57b709a6
--- /dev/null
+++ b/packages/app/cypress/fixtures/api/collectivex-runs.json
@@ -0,0 +1,21 @@
+{
+  "version": 1,
+  "runs": [
+    {
+      "run_id": "160",
+      "run_attempt": 1,
+      "generated_at": "2026-07-08T12:20:00Z",
+      "conclusion": "success",
+      "covered_skus": ["b200-dgxc", "b300", "h200-dgxc", "mi355x"],
+      "requested_cases": 5,
+      "measured_cases": 3,
+      "requested_points": 50,
+      "terminal_points": 40,
+      "terminal_counts": {
+        "measured": 3,
+        "unsupported": 1,
+        "failed": 0
+      }
+    }
+  ]
+}
diff --git a/packages/app/package.json b/packages/app/package.json
index d536a240..177abc1e 100644
--- a/packages/app/package.json
+++ b/packages/app/package.json
@@ -32,6 +32,7 @@
     "@chenglou/pretext": "^0.0.8",
     "@jpinsonneau/html-to-image": "^1.11.13",
     "@noble/ciphers": "^2.2.0",
+    "@noble/hashes": "^2.2.0",
     "@posthog/nextjs-config": "^1.9.68",
     "@radix-ui/react-accordion": "^1.2.16",
     "@radix-ui/react-dialog": "^1.1.19",
@@ -69,7 +70,8 @@
     "remark-gfm": "^4.0.1",
     "shiki": "^4.3.1",
     "tailwind-merge": "^3.6.0",
-    "three": "^0.185.1"
+    "three": "^0.185.1",
+    "zod": "^4.4.3"
   },
   "devDependencies": {
     "@bahmutov/cypress-esbuild-preprocessor": "^2.2.8",
diff --git a/packages/app/scripts/capture-cypress-fixtures.ts b/packages/app/scripts/capture-cypress-fixtures.ts
index 5f149289..c292d430 100644
--- a/packages/app/scripts/capture-cypress-fixtures.ts
+++ b/packages/app/scripts/capture-cypress-fixtures.ts
@@ -13,6 +13,9 @@
 import { mkdir, writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
 
+import { buildRunSummary } from '@semianalysisai/inferencex-db/collectivex/reader';
+import { makeCollectiveXDataset } from '@semianalysisai/inferencex-db/collectivex/test-fixture';
+
 const baseUrl = (
   process.argv.filter((a) => a !== '--').slice(2)[0] ?? 'https://inferencex.semianalysis.com'
 ).replace(/\/$/u, '');
@@ -250,6 +253,17 @@ async function main() {
       }),
     ],
     ['workflow-info', await writeFixture('workflow-info', workflowInfo)],
+    // CollectiveX fixtures are synthetic (deterministic contract builders),
+    // not captured — production may hold arbitrary sweep data while the e2e
+    // suite asserts on the builders' known shape.
+    ['collectivex-latest', await writeFixture('collectivex-latest', makeCollectiveXDataset())],
+    [
+      'collectivex-runs',
+      await writeFixture('collectivex-runs', {
+        version: 1,
+        runs: [buildRunSummary(makeCollectiveXDataset())],
+      }),
+    ],
   ];
 
   for (const [name, bytes] of sizes) {
diff --git a/packages/app/src/app/(dashboard)/collectivex/page.tsx b/packages/app/src/app/(dashboard)/collectivex/page.tsx
new file mode 100644
index 00000000..d3380bd9
--- /dev/null
+++ b/packages/app/src/app/(dashboard)/collectivex/page.tsx
@@ -0,0 +1,10 @@
+import type { Metadata } from 'next';
+
+import CollectiveXDisplay from '@/components/collectivex/CollectiveXDisplay';
+import { tabMetadata } from '@/lib/tab-meta';
+
+export const metadata: Metadata = tabMetadata('collectivex');
+
+export default function CollectiveXPage() {
+  return <CollectiveXDisplay />;
+}
diff --git a/packages/app/src/app/api/v1/collectivex/latest/route.test.ts b/packages/app/src/app/api/v1/collectivex/latest/route.test.ts
new file mode 100644
index 00000000..7812d185
--- /dev/null
+++ b/packages/app/src/app/api/v1/collectivex/latest/route.test.ts
@@ -0,0 +1,104 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { makeCollectiveXDataset } from '@semianalysisai/inferencex-db/collectivex/test-fixture';
+
+const { mockGetLatest, mockFromRow, mockGetDb, mockEnsureLatest } = vi.hoisted(() => ({
+  mockGetLatest: vi.fn(),
+  mockFromRow: vi.fn(),
+  mockGetDb: vi.fn(() => 'mock-sql'),
+  mockEnsureLatest: vi.fn(),
+}));
+
+vi.mock('@semianalysisai/inferencex-db/connection', () => ({
+  getCollectiveXDb: mockGetDb,
+  FIXTURES_MODE: false,
+}));
+
+vi.mock('@semianalysisai/inferencex-db/queries/collectivex', () => ({
+  getLatestCollectiveXRun: mockGetLatest,
+  collectiveXDatasetFromRow: mockFromRow,
+}));
+
+vi.mock('@/lib/collectivex-lazy-ingest', () => ({
+  ensureLatestCollectiveXRun: mockEnsureLatest,
+  collectiveXSweepErrorStatus: (error: unknown) => {
+    const code = error instanceof Error && 'code' in error ? (error.code as string) : null;
+    if (code === 'not-found') return 404;
+    if (code === 'unavailable') return 503;
+    if (code === 'invalid') return 502;
+    return null;
+  },
+}));
+
+vi.mock('@/lib/api-cache', () => ({
+  COLLECTIVEX_CACHE_SCOPE: 'collectivex',
+  COLLECTIVEX_CACHE_CONTROL: 'public, max-age=0, s-maxage=60',
+  cachedJson: (data: unknown) => Response.json(data),
+}));
+
+import { NextRequest } from 'next/server';
+
+import { GET } from './route';
+
+function req(url: string): NextRequest {
+  return new NextRequest(new URL(url, 'http://localhost'));
+}
+
+function sweepError(code: string): Error {
+  return Object.assign(new Error(code), { code });
+}
+
+const dataset = makeCollectiveXDataset();
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.spyOn(console, 'error').mockImplementation(() => {});
+  mockEnsureLatest.mockResolvedValue(undefined);
+  mockGetLatest.mockResolvedValue({ run_id: dataset.run.run_id });
+  mockFromRow.mockReturnValue(dataset);
+});
+
+describe('GET /api/v1/collectivex/latest', () => {
+  it('returns 400 for a missing or unknown version', async () => {
+    for (const url of ['/api/v1/collectivex/latest', '/api/v1/collectivex/latest?version=99']) {
+      const res = await GET(req(url));
+      expect(res.status).toBe(400);
+    }
+    expect(mockEnsureLatest).not.toHaveBeenCalled();
+  });
+
+  it('lazily ingests then serves the latest run assembled as a dataset', async () => {
+    const res = await GET(req('/api/v1/collectivex/latest?version=1'));
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual(dataset);
+    expect(mockEnsureLatest).toHaveBeenCalledWith(1);
+    expect(mockGetLatest).toHaveBeenCalledWith('mock-sql', 1);
+  });
+
+  it('serves the stored run when GitHub discovery fails', async () => {
+    mockEnsureLatest.mockRejectedValue(sweepError('unavailable'));
+    const res = await GET(req('/api/v1/collectivex/latest?version=1'));
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual(dataset);
+  });
+
+  it('returns 503 when discovery fails and nothing is stored', async () => {
+    mockEnsureLatest.mockRejectedValue(sweepError('unavailable'));
+    mockGetLatest.mockResolvedValue(null);
+    const res = await GET(req('/api/v1/collectivex/latest?version=1'));
+    expect(res.status).toBe(503);
+  });
+
+  it('returns 404 when neither GitHub nor the DB has a run', async () => {
+    mockGetLatest.mockResolvedValue(null);
+    const res = await GET(req('/api/v1/collectivex/latest?version=1'));
+    expect(res.status).toBe(404);
+  });
+
+  it('returns 500 without leaking details on DB failure', async () => {
+    mockGetLatest.mockRejectedValue(new Error('boom'));
+    const res = await GET(req('/api/v1/collectivex/latest?version=1'));
+    expect(res.status).toBe(500);
+    expect(await res.json()).toEqual({ error: 'Internal server error' });
+  });
+});
diff --git a/packages/app/src/app/api/v1/collectivex/latest/route.ts b/packages/app/src/app/api/v1/collectivex/latest/route.ts
new file mode 100644
index 00000000..52010b9b
--- /dev/null
+++ b/packages/app/src/app/api/v1/collectivex/latest/route.ts
@@ -0,0 +1,56 @@
+import { type NextRequest, NextResponse } from 'next/server';
+
+import { parseCollectiveXVersion } from '@semianalysisai/inferencex-db/collectivex/types';
+import { FIXTURES_MODE, getCollectiveXDb } from '@semianalysisai/inferencex-db/connection';
+import {
+  collectiveXDatasetFromRow,
+  getLatestCollectiveXRun,
+} from '@semianalysisai/inferencex-db/queries/collectivex';
+
+import { COLLECTIVEX_CACHE_CONTROL, COLLECTIVEX_CACHE_SCOPE, cachedJson } from '@/lib/api-cache';
+import {
+  collectiveXSweepErrorStatus,
+  ensureLatestCollectiveXRun,
+} from '@/lib/collectivex-lazy-ingest';
+import { loadFixture } from '@/lib/test-fixtures';
+
+export const dynamic = 'force-dynamic';
+export const runtime = 'nodejs';
+
+export async function GET(request: NextRequest) {
+  const version = parseCollectiveXVersion(request.nextUrl.searchParams.get('version') ?? '');
+  if (!version) {
+    return NextResponse.json({ error: 'Unknown version' }, { status: 400 });
+  }
+  if (FIXTURES_MODE) return cachedJson(loadFixture('collectivex-latest'));
+
+  // Discovery failures must not take the page down — serve whatever the DB
+  // already holds and only surface the error when there is no fallback.
+  let ensureError: unknown = null;
+  try {
+    await ensureLatestCollectiveXRun(version);
+  } catch (error) {
+    ensureError = error;
+  }
+
+  try {
+    const row = await getLatestCollectiveXRun(getCollectiveXDb(), version);
+    if (row !== null) {
+      if (ensureError)
+        console.error('CollectiveX discovery failed; serving stored run:', ensureError);
+      return cachedJson(collectiveXDatasetFromRow(row), {
+        tag: COLLECTIVEX_CACHE_SCOPE,
+        cacheControl: COLLECTIVEX_CACHE_CONTROL,
+      });
+    }
+    if (ensureError) {
+      console.error('CollectiveX discovery failed with no stored fallback:', ensureError);
+      const status = collectiveXSweepErrorStatus(ensureError) ?? 502;
+      return NextResponse.json({ error: 'Unavailable' }, { status });
+    }
+    return NextResponse.json({ error: 'Not found' }, { status: 404 });
+  } catch (error) {
+    console.error('Error fetching CollectiveX latest run:', error);
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+  }
+}
diff --git a/packages/app/src/app/api/v1/collectivex/runs/[runId]/route.test.ts b/packages/app/src/app/api/v1/collectivex/runs/[runId]/route.test.ts
new file mode 100644
index 00000000..cfd20042
--- /dev/null
+++ b/packages/app/src/app/api/v1/collectivex/runs/[runId]/route.test.ts
@@ -0,0 +1,158 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { makeCollectiveXDataset } from '@semianalysisai/inferencex-db/collectivex/test-fixture';
+
+const { mockGetRun, mockDelete, mockFromRow, mockGetDb, mockGetWriteDb, mockPurge, mockEnsureRun } =
+  vi.hoisted(() => ({
+    mockGetRun: vi.fn(),
+    mockDelete: vi.fn(),
+    mockFromRow: vi.fn(),
+    mockGetDb: vi.fn(() => 'mock-sql'),
+    mockGetWriteDb: vi.fn(() => 'mock-write-sql'),
+    mockPurge: vi.fn(() => Promise.resolve(0)),
+    mockEnsureRun: vi.fn(),
+  }));
+
+vi.mock('@semianalysisai/inferencex-db/connection', () => ({
+  getCollectiveXDb: mockGetDb,
+  getCollectiveXWriteDb: mockGetWriteDb,
+  FIXTURES_MODE: false,
+}));
+
+vi.mock('@semianalysisai/inferencex-db/queries/collectivex', () => ({
+  getCollectiveXRun: mockGetRun,
+  deleteCollectiveXRun: mockDelete,
+  collectiveXDatasetFromRow: mockFromRow,
+}));
+
+vi.mock('@/lib/collectivex-lazy-ingest', () => ({
+  ensureCollectiveXRun: mockEnsureRun,
+  collectiveXSweepErrorStatus: (error: unknown) => {
+    const code = error instanceof Error && 'code' in error ? (error.code as string) : null;
+    if (code === 'not-found') return 404;
+    if (code === 'unavailable') return 503;
+    if (code === 'invalid') return 502;
+    return null;
+  },
+}));
+
+vi.mock('@/lib/api-cache', () => ({
+  COLLECTIVEX_CACHE_SCOPE: 'collectivex',
+  COLLECTIVEX_CACHE_CONTROL: 'public, max-age=0, s-maxage=60',
+  cachedJson: (data: unknown) => Response.json(data),
+  purgeCollectiveX: mockPurge,
+}));
+
+import { NextRequest } from 'next/server';
+
+import { DELETE, GET } from './route';
+
+const SECRET = 'test-admin-secret';
+const dataset = makeCollectiveXDataset();
+const runId = dataset.run.run_id;
+
+function sweepError(code: string): Error {
+  return Object.assign(new Error(code), { code });
+}
+
+function get(url: string, id: string) {
+  return GET(new NextRequest(new URL(url, 'http://localhost')), {
+    params: Promise.resolve({ runId: id }),
+  });
+}
+
+function del(id: string, token?: string) {
+  return DELETE(
+    new NextRequest(new URL(`/api/v1/collectivex/runs/${id}`, 'http://localhost'), {
+      method: 'DELETE',
+      headers: token ? { Authorization: `Bearer ${token}` } : {},
+    }),
+    { params: Promise.resolve({ runId: id }) },
+  );
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.stubEnv('COLLECTIVEX_ADMIN_SECRET', SECRET);
+  mockEnsureRun.mockResolvedValue(undefined);
+  mockGetRun.mockResolvedValue({ run_id: runId });
+  mockFromRow.mockReturnValue(dataset);
+  mockDelete.mockResolvedValue(true);
+});
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+});
+
+describe('GET /api/v1/collectivex/runs/[runId]', () => {
+  it('returns 400 for malformed version or run id', async () => {
+    const badRunId = await get(`/x?version=1`, 'abc');
+    const badVersion = await get(`/x?version=99`, runId);
+    expect(badRunId.status).toBe(400);
+    expect(badVersion.status).toBe(400);
+    expect(mockEnsureRun).not.toHaveBeenCalled();
+  });
+
+  it('lazily ingests then serves the run assembled as a dataset', async () => {
+    const res = await get(`/x?version=1`, runId);
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual(dataset);
+    expect(mockEnsureRun).toHaveBeenCalledWith(1, runId);
+    expect(mockGetRun).toHaveBeenCalledWith('mock-sql', 1, runId);
+  });
+
+  it.each([
+    ['not-found', 404],
+    ['unavailable', 503],
+    ['invalid', 502],
+  ] as const)('maps %s ingest failures without exposing details', async (code, status) => {
+    vi.spyOn(console, 'error').mockImplementation(() => {});
+    mockEnsureRun.mockRejectedValue(sweepError(code));
+    const res = await get(`/x?version=1`, runId);
+    expect(res.status).toBe(status);
+  });
+
+  it('returns 404 when the run is absent after a clean ensure', async () => {
+    mockGetRun.mockResolvedValue(null);
+    const res = await get(`/x?version=1`, runId);
+    expect(res.status).toBe(404);
+  });
+});
+
+describe('DELETE /api/v1/collectivex/runs/[runId]', () => {
+  it('rejects missing or wrong bearer tokens', async () => {
+    const missing = await del(runId);
+    const wrong = await del(runId, 'wrong-token');
+    expect(missing.status).toBe(401);
+    expect(wrong.status).toBe(401);
+    expect(mockDelete).not.toHaveBeenCalled();
+  });
+
+  it('rejects all requests when the secret is not configured', async () => {
+    vi.stubEnv('COLLECTIVEX_ADMIN_SECRET', '');
+    const res = await del(runId, '');
+    expect(res.status).toBe(401);
+    expect(mockDelete).not.toHaveBeenCalled();
+  });
+
+  it('tombstones the run and purges only the CollectiveX cache scope', async () => {
+    const res = await del(runId, SECRET);
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ deleted: true, runId });
+    expect(mockDelete).toHaveBeenCalledWith('mock-write-sql', runId);
+    expect(mockPurge).toHaveBeenCalledTimes(1);
+  });
+
+  it('returns 404 without purging when the run does not exist', async () => {
+    mockDelete.mockResolvedValue(false);
+    const res = await del(runId, SECRET);
+    expect(res.status).toBe(404);
+    expect(mockPurge).not.toHaveBeenCalled();
+  });
+
+  it('returns 400 for malformed run ids', async () => {
+    const res = await del('not-a-run-id', SECRET);
+    expect(res.status).toBe(400);
+    expect(mockDelete).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/app/src/app/api/v1/collectivex/runs/[runId]/route.ts b/packages/app/src/app/api/v1/collectivex/runs/[runId]/route.ts
new file mode 100644
index 00000000..44469d14
--- /dev/null
+++ b/packages/app/src/app/api/v1/collectivex/runs/[runId]/route.ts
@@ -0,0 +1,104 @@
+import { timingSafeEqual } from 'crypto';
+
+import { type NextRequest, NextResponse } from 'next/server';
+
+import { parseCollectiveXVersion } from '@semianalysisai/inferencex-db/collectivex/types';
+import {
+  FIXTURES_MODE,
+  getCollectiveXDb,
+  getCollectiveXWriteDb,
+} from '@semianalysisai/inferencex-db/connection';
+import {
+  collectiveXDatasetFromRow,
+  deleteCollectiveXRun,
+  getCollectiveXRun,
+} from '@semianalysisai/inferencex-db/queries/collectivex';
+
+import {
+  COLLECTIVEX_CACHE_CONTROL,
+  COLLECTIVEX_CACHE_SCOPE,
+  cachedJson,
+  purgeCollectiveX,
+} from '@/lib/api-cache';
+import { collectiveXSweepErrorStatus, ensureCollectiveXRun } from '@/lib/collectivex-lazy-ingest';
+import { loadFixture } from '@/lib/test-fixtures';
+
+export const dynamic = 'force-dynamic';
+export const runtime = 'nodejs';
+
+const RUN_ID = /^[1-9][0-9]*$/u;
+
+export async function GET(request: NextRequest, context: { params: Promise<{ runId: string }> }) {
+  const { runId } = await context.params;
+  const version = parseCollectiveXVersion(request.nextUrl.searchParams.get('version') ?? '');
+  if (!version || !RUN_ID.test(runId)) {
+    return NextResponse.json({ error: 'Unknown version or run id' }, { status: 400 });
+  }
+  if (FIXTURES_MODE) return cachedJson(loadFixture('collectivex-latest'));
+
+  try {
+    await ensureCollectiveXRun(version, runId);
+    const row = await getCollectiveXRun(getCollectiveXDb(), version, runId);
+    if (row === null) {
+      return NextResponse.json({ error: 'Not found' }, { status: 404 });
+    }
+    // Short window like the sibling routes: a GitHub re-run of failed shards
+    // refreshes this run's stored contents, and deletion must not linger.
+    return cachedJson(collectiveXDatasetFromRow(row), {
+      tag: COLLECTIVEX_CACHE_SCOPE,
+      cacheControl: COLLECTIVEX_CACHE_CONTROL,
+    });
+  } catch (error) {
+    const status = collectiveXSweepErrorStatus(error);
+    if (status !== null) {
+      return NextResponse.json({ error: status === 404 ? 'Not found' : 'Unavailable' }, { status });
+    }
+    console.error('Error fetching CollectiveX run:', error);
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+  }
+}
+
+/** Constant-time Bearer check that tolerates multibyte header bytes. */
+function bearerMatches(header: string, secret: string): boolean {
+  const provided = Buffer.from(header);
+  const expected = Buffer.from(`Bearer ${secret}`);
+  // Compare BYTE lengths — a multibyte char can make the JS string lengths
+  // equal while the buffers differ, and timingSafeEqual throws on that.
+  return provided.length === expected.length && timingSafeEqual(provided, expected);
+}
+
+/**
+ * Admin deletion of an ingested run. Authenticated with a dedicated Bearer
+ * secret — the token is remembered in browser localStorage, so it must not
+ * be the CI-held INVALIDATE_SECRET (scoped blast radius, independently
+ * rotatable). Deletion tombstones the run (lazy discovery must never
+ * re-ingest it) and purges the CollectiveX cache scope so the picker and
+ * latest views drop it immediately.
+ */
+export async function DELETE(
+  request: NextRequest,
+  context: { params: Promise<{ runId: string }> },
+) {
+  const secret = process.env.COLLECTIVEX_ADMIN_SECRET;
+  const authHeader = request.headers.get('Authorization') ?? '';
+  if (!secret || !bearerMatches(authHeader, secret)) {
+    return new NextResponse('Unauthorized', { status: 401 });
+  }
+
+  const { runId } = await context.params;
+  if (!RUN_ID.test(runId)) {
+    return NextResponse.json({ error: 'Unknown run id' }, { status: 400 });
+  }
+
+  try {
+    const deleted = await deleteCollectiveXRun(getCollectiveXWriteDb(), runId);
+    if (!deleted) {
+      return NextResponse.json({ error: 'Not found' }, { status: 404 });
+    }
+    purgeCollectiveX();
+    return NextResponse.json({ deleted: true, runId });
+  } catch (error) {
+    console.error('Error deleting CollectiveX run:', error);
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+  }
+}
diff --git a/packages/app/src/app/api/v1/collectivex/runs/route.test.ts b/packages/app/src/app/api/v1/collectivex/runs/route.test.ts
new file mode 100644
index 00000000..a9d3772e
--- /dev/null
+++ b/packages/app/src/app/api/v1/collectivex/runs/route.test.ts
@@ -0,0 +1,102 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { buildRunSummary } from '@semianalysisai/inferencex-db/collectivex/reader';
+import { makeCollectiveXDataset } from '@semianalysisai/inferencex-db/collectivex/test-fixture';
+
+const { mockList, mockGetDb, mockEnsureList } = vi.hoisted(() => ({
+  mockList: vi.fn(),
+  mockGetDb: vi.fn(() => 'mock-sql'),
+  mockEnsureList: vi.fn(),
+}));
+
+vi.mock('@semianalysisai/inferencex-db/connection', () => ({
+  getCollectiveXDb: mockGetDb,
+  FIXTURES_MODE: false,
+}));
+
+vi.mock('@semianalysisai/inferencex-db/queries/collectivex', () => ({
+  listCollectiveXRuns: mockList,
+}));
+
+vi.mock('@/lib/collectivex-lazy-ingest', () => ({
+  ensureCollectiveXRunsList: mockEnsureList,
+  collectiveXSweepErrorStatus: (error: unknown) => {
+    const code = error instanceof Error && 'code' in error ? (error.code as string) : null;
+    if (code === 'not-found') return 404;
+    if (code === 'unavailable') return 503;
+    if (code === 'invalid') return 502;
+    return null;
+  },
+}));
+
+vi.mock('@/lib/api-cache', () => ({
+  COLLECTIVEX_CACHE_SCOPE: 'collectivex',
+  COLLECTIVEX_CACHE_CONTROL: 'public, max-age=0, s-maxage=60',
+  cachedJson: (data: unknown) => Response.json(data),
+}));
+
+import { NextRequest } from 'next/server';
+
+import { GET } from './route';
+
+function req(url: string): NextRequest {
+  return new NextRequest(new URL(url, 'http://localhost'));
+}
+
+function sweepError(code: string): Error {
+  return Object.assign(new Error(code), { code });
+}
+
+const summary = buildRunSummary(makeCollectiveXDataset());
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  vi.spyOn(console, 'error').mockImplementation(() => {});
+  mockEnsureList.mockResolvedValue(undefined);
+  mockList.mockResolvedValue([summary]);
+});
+
+describe('GET /api/v1/collectivex/runs', () => {
+  it('returns 400 for a missing or unknown version', async () => {
+    for (const url of ['/api/v1/collectivex/runs', '/api/v1/collectivex/runs?version=abc']) {
+      const res = await GET(req(url));
+      expect(res.status).toBe(400);
+    }
+    expect(mockEnsureList).not.toHaveBeenCalled();
+  });
+
+  it('backfills recent runs then lists stored summaries newest first', async () => {
+    const res = await GET(req('/api/v1/collectivex/runs?version=1'));
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ version: 1, runs: [summary] });
+    expect(mockEnsureList).toHaveBeenCalledWith(1);
+    expect(mockList).toHaveBeenCalledWith('mock-sql', 1);
+  });
+
+  it('serves the stored list when the GitHub backfill fails', async () => {
+    mockEnsureList.mockRejectedValue(sweepError('unavailable'));
+    const res = await GET(req('/api/v1/collectivex/runs?version=1'));
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ version: 1, runs: [summary] });
+  });
+
+  it('returns 503 when the backfill fails and nothing is stored', async () => {
+    mockEnsureList.mockRejectedValue(sweepError('unavailable'));
+    mockList.mockResolvedValue([]);
+    const res = await GET(req('/api/v1/collectivex/runs?version=1'));
+    expect(res.status).toBe(503);
+  });
+
+  it('returns an empty list when GitHub has no runs yet', async () => {
+    mockList.mockResolvedValue([]);
+    const res = await GET(req('/api/v1/collectivex/runs?version=1'));
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ version: 1, runs: [] });
+  });
+
+  it('returns 500 without leaking details on DB failure', async () => {
+    mockList.mockRejectedValue(new Error('boom'));
+    const res = await GET(req('/api/v1/collectivex/runs?version=1'));
+    expect(res.status).toBe(500);
+  });
+});
diff --git a/packages/app/src/app/api/v1/collectivex/runs/route.ts b/packages/app/src/app/api/v1/collectivex/runs/route.ts
new file mode 100644
index 00000000..31768422
--- /dev/null
+++ b/packages/app/src/app/api/v1/collectivex/runs/route.ts
@@ -0,0 +1,51 @@
+import { type NextRequest, NextResponse } from 'next/server';
+
+import { parseCollectiveXVersion } from '@semianalysisai/inferencex-db/collectivex/types';
+import { FIXTURES_MODE, getCollectiveXDb } from '@semianalysisai/inferencex-db/connection';
+import { listCollectiveXRuns } from '@semianalysisai/inferencex-db/queries/collectivex';
+
+import { COLLECTIVEX_CACHE_CONTROL, COLLECTIVEX_CACHE_SCOPE, cachedJson } from '@/lib/api-cache';
+import {
+  collectiveXSweepErrorStatus,
+  ensureCollectiveXRunsList,
+} from '@/lib/collectivex-lazy-ingest';
+import { loadFixture } from '@/lib/test-fixtures';
+
+export const dynamic = 'force-dynamic';
+export const runtime = 'nodejs';
+
+export async function GET(request: NextRequest) {
+  const version = parseCollectiveXVersion(request.nextUrl.searchParams.get('version') ?? '');
+  if (!version) {
+    return NextResponse.json({ error: 'Unknown version' }, { status: 400 });
+  }
+  if (FIXTURES_MODE) return cachedJson(loadFixture('collectivex-runs'));
+
+  // Backfill failures must not take the picker down — serve the stored list
+  // and only surface the error when there is nothing at all to show.
+  let ensureError: unknown = null;
+  try {
+    await ensureCollectiveXRunsList(version);
+  } catch (error) {
+    ensureError = error;
+  }
+
+  try {
+    const runs = await listCollectiveXRuns(getCollectiveXDb(), version);
+    if (runs.length === 0 && ensureError) {
+      console.error('CollectiveX run backfill failed with no stored fallback:', ensureError);
+      const status = collectiveXSweepErrorStatus(ensureError) ?? 502;
+      return NextResponse.json({ error: 'Unavailable' }, { status });
+    }
+    if (ensureError) {
+      console.error('CollectiveX run backfill failed; serving stored list:', ensureError);
+    }
+    return cachedJson(
+      { version, runs },
+      { tag: COLLECTIVEX_CACHE_SCOPE, cacheControl: COLLECTIVEX_CACHE_CONTROL },
+    );
+  } catch (error) {
+    console.error('Error listing CollectiveX runs:', error);
+    return NextResponse.json({ error: 'Internal server error' }, { status: 500 });
+  }
+}
diff --git a/packages/app/src/app/api/v1/invalidate/route.test.ts b/packages/app/src/app/api/v1/invalidate/route.test.ts
index 4947107a..6d25d6f2 100644
--- a/packages/app/src/app/api/v1/invalidate/route.test.ts
+++ b/packages/app/src/app/api/v1/invalidate/route.test.ts
@@ -1,11 +1,14 @@
 import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
 
-const { mockPurgeAll } = vi.hoisted(() => ({
+const { mockPurgeAll, mockPurgeCollectiveX } = vi.hoisted(() => ({
   mockPurgeAll: vi.fn(),
+  mockPurgeCollectiveX: vi.fn(),
 }));
 
 vi.mock('@/lib/api-cache', () => ({
+  COLLECTIVEX_CACHE_SCOPE: 'collectivex',
   purgeAll: mockPurgeAll,
+  purgeCollectiveX: mockPurgeCollectiveX,
 }));
 
 import { POST } from './route';
@@ -42,8 +45,8 @@ afterEach(() => {
   }
 });
 
-function postReq(headers?: Record<string, string>): Request {
-  return new Request('http://localhost/api/v1/invalidate', {
+function postReq(headers?: Record<string, string>, query = ''): Request {
+  return new Request(`http://localhost/api/v1/invalidate${query}`, {
     method: 'POST',
     headers: headers ?? {},
   });
@@ -124,4 +127,22 @@ describe('POST /api/v1/invalidate', () => {
     const body = await res.json();
     expect(body).toEqual({ invalidated: true, blobsDeleted: 0 });
   });
+
+  it('purges only the CollectiveX scope when requested', async () => {
+    const res = await POST(
+      postReq({ Authorization: 'Bearer test-secret-123' }, '?scope=collectivex'),
+    );
+    expect(res.status).toBe(200);
+    const body = await res.json();
+    expect(body).toEqual({ invalidated: true, scope: 'collectivex' });
+    expect(mockPurgeCollectiveX).toHaveBeenCalledOnce();
+    expect(mockPurgeAll).not.toHaveBeenCalled();
+  });
+
+  it('rejects unknown scopes without purging anything', async () => {
+    const res = await POST(postReq({ Authorization: 'Bearer test-secret-123' }, '?scope=nope'));
+    expect(res.status).toBe(400);
+    expect(mockPurgeAll).not.toHaveBeenCalled();
+    expect(mockPurgeCollectiveX).not.toHaveBeenCalled();
+  });
 });
diff --git a/packages/app/src/app/api/v1/invalidate/route.ts b/packages/app/src/app/api/v1/invalidate/route.ts
index 0fc8cd12..e648e75b 100644
--- a/packages/app/src/app/api/v1/invalidate/route.ts
+++ b/packages/app/src/app/api/v1/invalidate/route.ts
@@ -2,12 +2,13 @@ import { timingSafeEqual } from 'crypto';
 
 import { NextResponse } from 'next/server';
 
-import { purgeAll } from '@/lib/api-cache';
+import { COLLECTIVEX_CACHE_SCOPE, purgeAll, purgeCollectiveX } from '@/lib/api-cache';
 
 export async function POST(request: Request) {
   const secret = process.env.INVALIDATE_SECRET;
   const authHeader = request.headers.get('Authorization') ?? '';
-  const expected = `Bearer ${secret}`;
+  const provided = Buffer.from(authHeader);
+  const expected = Buffer.from(`Bearer ${secret}`);
   // The shared staging deployment is already protected by Vercel. Its CI
   // caller must present the project-scoped automation bypass before Vercel
   // forwards this header to the route, so a second app secret is redundant.
@@ -18,16 +19,26 @@ export async function POST(request: Request) {
     process.env.VERCEL_GIT_COMMIT_REF === 'staging' &&
     Boolean(request.headers.get('x-vercel-protection-bypass'));
 
+  // Compare BYTE lengths — a multibyte char can make the JS string lengths
+  // equal while the buffers differ, and timingSafeEqual throws on that.
   if (
     !isProtectedStagingRequest &&
-    (!secret ||
-      authHeader.length !== expected.length ||
-      !timingSafeEqual(Buffer.from(authHeader), Buffer.from(expected)))
+    (!secret || provided.length !== expected.length || !timingSafeEqual(provided, expected))
   ) {
     return new NextResponse('Unauthorized', { status: 401 });
   }
 
-  const blobsDeleted = await purgeAll();
+  // ?scope=collectivex purges only the CollectiveX cache scope; the default
+  // remains a full purge (which covers CollectiveX too).
+  const scope = new URL(request.url).searchParams.get('scope');
+  if (scope && scope !== COLLECTIVEX_CACHE_SCOPE) {
+    return NextResponse.json({ error: 'unknown scope' }, { status: 400 });
+  }
+  if (scope === COLLECTIVEX_CACHE_SCOPE) {
+    purgeCollectiveX();
+    return NextResponse.json({ invalidated: true, scope });
+  }
 
+  const blobsDeleted = await purgeAll();
   return NextResponse.json({ invalidated: true, blobsDeleted });
 }
diff --git a/packages/app/src/app/sitemap.ts b/packages/app/src/app/sitemap.ts
index 2dd3e934..8bce0549 100644
--- a/packages/app/src/app/sitemap.ts
+++ b/packages/app/src/app/sitemap.ts
@@ -22,6 +22,7 @@ const TABS = [
   'reliability',
   'gpu-specs',
   'gpu-metrics',
+  'collectivex',
 ] as const;
 
 type SitemapEntry = MetadataRoute.Sitemap[number];
diff --git a/packages/app/src/app/zh/(dashboard)/collectivex/page.tsx b/packages/app/src/app/zh/(dashboard)/collectivex/page.tsx
new file mode 100644
index 00000000..6496ec8a
--- /dev/null
+++ b/packages/app/src/app/zh/(dashboard)/collectivex/page.tsx
@@ -0,0 +1,16 @@
+import type { Metadata } from 'next';
+
+import CollectiveXDisplay from '@/components/collectivex/CollectiveXDisplay';
+import { ZhTabIntro } from '@/components/zh/zh-tab-intro';
+import { tabMetadataZh } from '@/lib/tab-meta-zh';
+
+export const metadata: Metadata = tabMetadataZh('collectivex');
+
+export default function ZhCollectiveXPage() {
+  return (
+    <>
+      <ZhTabIntro tab="collectivex" />
+      <CollectiveXDisplay />
+    </>
+  );
+}
diff --git a/packages/app/src/components/collectivex/CollectiveXChart.tsx b/packages/app/src/components/collectivex/CollectiveXChart.tsx
new file mode 100644
index 00000000..d46f1e01
--- /dev/null
+++ b/packages/app/src/components/collectivex/CollectiveXChart.tsx
@@ -0,0 +1,238 @@
+'use client';
+
+import * as d3 from 'd3';
+import { useMemo } from 'react';
+
+import { D3Chart } from '@/lib/d3-chart/D3Chart';
+
+import { chartPoints, collectiveXColorKey, fitAlphaBeta } from './data';
+import type {
+  CollectiveXChartPoint,
+  CollectiveXOperation,
+  CollectiveXPercentile,
+  CollectiveXSeries,
+  CollectiveXYAxis,
+} from './types';
+
+interface CollectiveXChartProps {
+  chartId: string;
+  series: CollectiveXSeries[];
+  colors: Record<string, string>;
+  operation: CollectiveXOperation;
+  percentile: CollectiveXPercentile;
+  yAxis: CollectiveXYAxis;
+  caption?: React.ReactNode;
+  legendElement?: React.ReactNode;
+  testId?: string;
+}
+
+const OPERATION_LABELS: Record<CollectiveXOperation, string> = {
+  dispatch: 'Dispatch',
+  stage: 'Stage',
+  combine: 'Combine',
+  roundtrip: 'Round trip (measured)',
+};
+
+const Y_AXIS_LABELS: Record<CollectiveXYAxis, string> = {
+  latency: 'Latency (µs)',
+  'tokens-per-second': 'Token rate at selected latency percentile (tokens/s)',
+  'activation-rate': 'Activation-data rate at selected latency percentile (GB/s)',
+  'payload-rate': 'Payload bandwidth at selected latency percentile (GB/s, per GPU)',
+};
+
+function paddedDomain(values: number[]): [number, number] {
+  if (values.length === 0) return [1, 10];
+  const min = d3.min(values) ?? 1;
+  const max = d3.max(values) ?? 1;
+  return min === max ? [min / 2, max * 2] : [min / 1.08, max * 1.08];
+}
+
+function formatCompact(value: number): string {
+  if (value >= 1e9) return `${(value / 1e9).toFixed(value < 1e10 ? 1 : 0)}G`;
+  if (value >= 1e6) return `${(value / 1e6).toFixed(value < 1e7 ? 1 : 0)}M`;
+  if (value >= 1e3) return `${(value / 1e3).toFixed(value < 1e4 ? 1 : 0)}k`;
+  if (value >= 10) return value.toFixed(0);
+  if (value >= 1) return value.toFixed(value < 3 ? 1 : 0);
+  return value.toFixed(2);
+}
+
+function formatTokenCount(value: number): string {
+  return Number.isInteger(value) ? value.toLocaleString('en-US') : formatCompact(value);
+}
+
+function formatMetric(value: number, yAxis: CollectiveXYAxis): string {
+  if (yAxis === 'latency') return `${value.toFixed(value >= 100 ? 0 : 1)} µs`;
+  if (yAxis === 'tokens-per-second') return `${formatCompact(value)} tok/s`;
+  return `${value.toFixed(value >= 100 ? 0 : 2)} GB/s`;
+}
+
+function formatPercentiles(
+  value: CollectiveXSeries['points'][number]['components']['dispatch'],
+): string {
+  if (value === null) return 'unavailable';
+  return `${value.latency_us.p50.toFixed(1)} / ${value.latency_us.p90.toFixed(1)} / ${value.latency_us.p95.toFixed(1)} / ${value.latency_us.p99.toFixed(1)} µs`;
+}
+
+function escapeHtml(value: string): string {
+  return value
+    .replaceAll('&', '&amp;')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#039;');
+}
+
+export function CollectiveXChart({
+  chartId,
+  series,
+  colors,
+  operation,
+  percentile,
+  yAxis,
+  caption,
+  legendElement,
+  testId,
+}: CollectiveXChartProps) {
+  const points = useMemo(
+    () => chartPoints(series, operation, percentile, yAxis),
+    [series, operation, percentile, yAxis],
+  );
+  const seriesById = useMemo(() => new Map(series.map((item) => [item.series_id, item])), [series]);
+  // Per-series α/β fit for the current operation (p50). β is the per-GPU
+  // bandwidth term, α the fixed overhead; surfaced in the tooltip. Null when a
+  // series has too few points / a degenerate byte axis to fit.
+  const fitsBySeries = useMemo(
+    () => new Map(series.map((item) => [item.series_id, fitAlphaBeta(item, operation)])),
+    [series, operation],
+  );
+  const lines = useMemo(() => {
+    const result: Record<string, { x: number; y: number }[]> = {};
+    for (const point of points) {
+      (result[point.seriesId] ??= []).push({ x: point.x, y: point.y });
+    }
+    for (const line of Object.values(result)) {
+      line.sort((a, b) => a.x - b.x);
+    }
+    return result;
+  }, [points]);
+
+  const xDomain = useMemo(() => paddedDomain(points.map((point) => point.x)), [points]);
+  const yDomain = useMemo(() => paddedDomain(points.map((point) => point.y)), [points]);
+  const xTickValues = useMemo(
+    () => [...new Set(points.map((point) => point.x))].toSorted((a, b) => a - b),
+    [points],
+  );
+
+  const noDataOverlay =
+    points.length === 0 ? (
+      <div className="absolute inset-0 flex items-center justify-center pointer-events-none">
+        <p className="text-sm text-muted-foreground">
+          {series.length > 0
+            ? `${OPERATION_LABELS[operation]} is unavailable for the selected series.`
+            : 'No matching CollectiveX series.'}
+        </p>
+      </div>
+    ) : undefined;
+
+  return (
+    <D3Chart<CollectiveXChartPoint>
+      chartId={chartId}
+      data={points}
+      height={560}
+      margin={{ top: 24, right: 20, bottom: 62, left: 78 }}
+      watermark="logo"
+      testId={testId}
+      grabCursor
+      instructions="Shift+Scroll to zoom · Drag to pan · Double-click to reset · Click a point to pin tooltip"
+      xScale={{ type: 'log', domain: xDomain, nice: false }}
+      yScale={{ type: 'log', domain: yDomain, nice: false }}
+      xAxis={{
+        label: 'Source tokens / rank (log)',
+        tickCount: 8,
+        tickValues: xTickValues,
+        tickFormat: (value) => formatTokenCount(Number(value)),
+      }}
+      yAxis={{
+        label: Y_AXIS_LABELS[yAxis],
+        tickCount: 5,
+        tickFormat: (value) => formatCompact(Number(value)),
+      }}
+      layers={[
+        {
+          type: 'line',
+          key: 'collectivex-lines',
+          lines,
+          config: {
+            getColor: (key) => {
+              const item = seriesById.get(key);
+              return colors[item ? collectiveXColorKey(item) : ''] ?? '#888';
+            },
+            strokeWidth: 2.25,
+            curve: d3.curveLinear,
+          },
+        },
+        {
+          type: 'point',
+          key: 'collectivex-points',
+          data: points,
+          config: {
+            getCx: () => 0,
+            getCy: () => 0,
+            getX: (point) => point.x,
+            getY: (point) => point.y,
+            getColor: (point) => colors[point.colorKey] ?? '#888',
+            getRadius: () => 3.5,
+            stroke: 'var(--background)',
+            strokeWidth: 1,
+            keyFn: (point) => `${point.seriesId}-${point.x}`,
+            maxPoints: Infinity,
+          },
+        },
+      ]}
+      zoom={{
+        enabled: true,
+        axes: 'both',
+        scaleExtent: [1, 20],
+        resetEventName: `collectivex_zoom_reset_${chartId}`,
+      }}
+      tooltip={{
+        rulerType: 'crosshair',
+        attachToLayer: 1,
+        content: (point, isPinned) => {
+          const color = colors[point.colorKey] ?? '#888';
+          const measurement = point.point;
+          const measuredRoundtrip = measurement.components.roundtrip;
+          const fit = fitsBySeries.get(point.seriesId);
+          const fitLine = fit
+            ? `<div class="mt-1 text-muted-foreground">Fit β=${fit.betaGbps.toFixed(fit.betaGbps >= 100 ? 0 : 1)} GB/s · α=${fit.alphaUs.toFixed(1)} µs (p50, per GPU)</div>`
+            : '';
+          return `<div class="rounded-md border bg-background/95 px-3 py-2 text-xs shadow-md backdrop-blur-sm" style="min-width: 230px; max-width: 380px; user-select: ${isPinned ? 'text' : 'none'}">
+            ${isPinned ? '<div style="color: var(--muted-foreground); font-size: 10px; margin-bottom: 6px; font-style: italic;">Click elsewhere to dismiss</div>' : ''}
+            <div class="font-semibold mb-1" style="color: ${color}">${escapeHtml(point.seriesLabel)}</div>
+            <div>${escapeHtml(OPERATION_LABELS[operation])} ${yAxis === 'latency' ? percentile : `at ${percentile} latency`}: <strong>${formatMetric(point.y, yAxis)}</strong></div>
+            <div class="text-muted-foreground">${measurement.tokens_per_rank} tokens/rank · ${measurement.global_tokens} global tokens</div>
+            <div class="mt-1 text-muted-foreground">Latency p50 / p90 / p95 / p99</div>
+            <div class="text-muted-foreground">Dispatch: ${formatPercentiles(measurement.components.dispatch)}</div>
+            <div class="text-muted-foreground">Stage: ${formatPercentiles(measurement.components.stage)}</div>
+            <div class="text-muted-foreground">Combine: ${formatPercentiles(measurement.components.combine)}</div>
+            <div class="text-muted-foreground">Round trip: ${formatPercentiles(measuredRoundtrip)}${measuredRoundtrip ? ' (measured)' : ''}</div>
+            ${fitLine}
+          </div>`;
+        },
+        getRulerX: (point, scale) =>
+          (scale as d3.ScaleLinear<number, number> | d3.ScaleLogarithmic<number, number>)(point.x),
+        getRulerY: (point, scale) => scale(point.y),
+        onHoverStart: (selection) => {
+          selection.attr('r', 6);
+        },
+        onHoverEnd: (selection) => {
+          selection.attr('r', 3.5);
+        },
+      }}
+      transitionDuration={200}
+      legendElement={legendElement}
+      noDataOverlay={noDataOverlay}
+      caption={caption}
+    />
+  );
+}
diff --git a/packages/app/src/components/collectivex/CollectiveXDisplay.tsx b/packages/app/src/components/collectivex/CollectiveXDisplay.tsx
new file mode 100644
index 00000000..1d1f1576
--- /dev/null
+++ b/packages/app/src/components/collectivex/CollectiveXDisplay.tsx
@@ -0,0 +1,987 @@
+'use client';
+
+import { BookOpen, ExternalLink, Loader2, RefreshCw, Trash2 } from 'lucide-react';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+
+import { Button } from '@/components/ui/button';
+import { Card } from '@/components/ui/card';
+import ChartLegend from '@/components/ui/chart-legend';
+import { Label } from '@/components/ui/label';
+import { SegmentedToggle, type SegmentedToggleOption } from '@/components/ui/segmented-toggle';
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from '@/components/ui/select';
+import {
+  useCollectiveX,
+  useCollectiveXRun,
+  useCollectiveXRuns,
+  useDeleteCollectiveXRun,
+} from '@/hooks/api/use-collectivex';
+import { useThemeColors } from '@/hooks/useThemeColors';
+import { track } from '@/lib/analytics';
+import { useLocale } from '@/lib/use-locale';
+
+import { CollectiveXChart } from './CollectiveXChart';
+import { CollectiveXInventory } from './CollectiveXInventory';
+import {
+  collectiveXColorKey,
+  collectiveXSeriesLabel,
+  collectiveXTopologyLabel,
+  seriesMatchesSelection,
+  type CollectiveXSeriesSelection,
+} from './data';
+import {
+  COLLECTIVEX_VERSIONS,
+  COLLECTIVEX_DEFAULT_VERSION,
+  collectiveXVersionLabel,
+  type CollectiveXMode,
+  type CollectiveXOperation,
+  type CollectiveXPercentile,
+  type CollectiveXPhase,
+  type CollectiveXPrecision,
+  type CollectiveXVersion,
+  type CollectiveXYAxis,
+} from './types';
+
+interface SelectOption<T extends string | number> {
+  value: T;
+  label: string;
+}
+
+const PERCENTILE_OPTIONS: SegmentedToggleOption<CollectiveXPercentile>[] = [
+  { value: 'p50', label: 'p50' },
+  { value: 'p90', label: 'p90' },
+  { value: 'p95', label: 'p95' },
+  { value: 'p99', label: 'p99' },
+];
+const STRINGS = {
+  en: {
+    operation: {
+      dispatch: 'Dispatch',
+      combine: 'Combine',
+      roundtrip: 'Round trip',
+    },
+    operationHeading: {
+      dispatch: 'Dispatch',
+      combine: 'Combine',
+      roundtrip: 'Round trip (measured)',
+    },
+    phase: { decode: 'Decode', prefill: 'Prefill' },
+    phaseValue: { decode: 'decode', prefill: 'prefill' },
+    mode: { normal: 'Normal', 'low-latency': 'Low-latency' },
+    precision: { bf16: 'BF16', fp8: 'FP8' },
+    yAxis: {
+      latency: 'Latency',
+      'tokens-per-second': 'Token rate at selected latency percentile',
+      'payload-rate': 'Payload bandwidth at selected latency percentile (per GPU)',
+    },
+    all: 'All',
+    loading: 'Resolving CollectiveX run...',
+    unavailable: 'CollectiveX run unavailable',
+    loadError: 'The CollectiveX dataset failed to load.',
+    retry: 'Retry',
+    description:
+      'Expert-parallel latency and payload rate across collective libraries and systems.',
+    source: 'Source',
+    methodology: 'Methodology',
+    refresh: 'Refresh',
+    seriesCount: 'Series',
+    measuredCases: 'Measured cases',
+    terminalCases: 'Terminal cases',
+    publishedUtc: 'Published (UTC)',
+    version: 'Benchmark version',
+    runControl: 'Run',
+    loadRuns: 'Load runs',
+    loadingRuns: 'Loading runs…',
+    latestPublished: 'Latest run',
+    epControl: 'EP degree',
+    operationControl: 'Operation',
+    phaseControl: 'Phase',
+    phaseAria: 'CollectiveX phase',
+    modeControl: 'Kernel mode',
+    modeAria: 'CollectiveX kernel mode',
+    precisionControl: 'Precision',
+    precisionAria: 'CollectiveX precision',
+    latencyPercentile: 'Latency percentile',
+    percentileAria: 'CollectiveX percentile',
+    sku: 'SKU',
+    backend: 'Backend',
+    yAxisControl: 'Y axis',
+    tokenRateOption: 'Token rate at latency percentile',
+    noSeries: 'No measured series match these filters.',
+    resetFilter: 'Reset filter',
+    payloadNote:
+      'Payload rate is derived at the selected latency percentile and is not physical link bandwidth.',
+    payloadBandwidthNote:
+      'Payload bandwidth is the full logical payload (incl. FP8 scale bytes) ÷ latency, per GPU — a derived rate over logical bytes, not physical link bandwidth. The tooltip β/α is a least-squares fit of latency vs bytes across the ladder (β = per-GPU bandwidth term, α = fixed overhead).',
+    deleteRun: 'Delete run',
+    deleteConfirm: (id: string) =>
+      `Delete run #${id} from the dashboard database? This cannot be undone.`,
+    deleteTokenPrompt: 'Admin token required to delete runs:',
+    deleteUnauthorized: 'Invalid admin token.',
+    deleteFailed: 'Deleting the run failed. Try again.',
+  },
+  zh: {
+    operation: {
+      dispatch: '分发',
+      combine: '合并',
+      roundtrip: '往返',
+      'isolated-sum': '分项之和',
+    },
+    operationHeading: {
+      dispatch: '分发',
+      combine: '合并',
+      roundtrip: '往返（实测）',
+      'isolated-sum': '分项之和（派生）',
+    },
+    phase: { decode: '解码', prefill: '预填充' },
+    phaseValue: { decode: '解码', prefill: '预填充' },
+    precision: { bf16: 'BF16', fp8: 'FP8' },
+    scale: { log: '对数', linear: '线性' },
+    xAxis: {
+      'tokens-per-rank': '每 rank 源 token 数',
+      'global-tokens': '全局源 token 数',
+    },
+    yAxis: {
+      latency: '延迟',
+      'tokens-per-second': '所选延迟分位点的 token 速率',
+      'payload-rate': '所选延迟分位点的载荷带宽（每 GPU）',
+    },
+    mode: { normal: '常规', 'low-latency': '低延迟' },
+    fabricScope: { all: '全部', 'scale-up': '域内', 'scale-out': '跨域' },
+    topologyScope: { 'scale-up': '域内（scale-up）', 'scale-out': '跨域（scale-out）' },
+    payloadUnit: { 'token-rank': 'Token-rank 载荷', 'token-expert': 'Token-expert 载荷' },
+    combineSemantics: {
+      'activation-only': '仅激活值合并',
+      'gate-weighted': '门控加权合并',
+    },
+    tabs: {
+      inventory: 'Matrix case inventory',
+      case: 'Selected matrix case',
+      evidence: '证据',
+    },
+    noCases: 'This run has no matrix cases to inspect.',
+    all: '全部',
+    loading: 'Resolving CollectiveX run...',
+    unavailable: 'CollectiveX run unavailable',
+    sourceUnavailable: 'The GitHub Actions run source is temporarily unavailable.',
+    runsErrorMessage: 'No CollectiveX run has been published yet.',
+    loadError: 'The CollectiveX dataset failed to load.',
+    retry: '重试',
+    description: '对比集合通信库与系统的专家并行（EP）延迟和逻辑载荷速率。',
+    source: '源代码',
+    methodology: '测试方法',
+    sourceLinkUnavailable: 'Source unavailable because measured series span different revisions',
+    refresh: '刷新',
+    seriesCount: 'Series',
+    measuredCases: 'Measured cases',
+    terminalCases: '已终结用例',
+    retainedAttempts: '保留尝试',
+    allocations: '独立分配',
+    publishedUtc: '发布时间（UTC）',
+    version: '基准版本',
+    runControl: 'Run',
+    loadRuns: 'Load runs',
+    loadingRuns: 'Loading runs…',
+    latestPublished: 'Latest run',
+    modeControl: '模式',
+    modeAria: 'CollectiveX 模式',
+    epControl: 'EP 并行度',
+    fabricScopeControl: '互联范围',
+    fabricScopeAria: 'CollectiveX 互联范围',
+    operationControl: '操作',
+    phaseControl: '阶段',
+    phaseAria: 'CollectiveX 阶段',
+    precisionControl: '精度',
+    precisionAria: 'CollectiveX 精度',
+    latencyPercentile: '延迟分位点',
+    percentileAria: 'CollectiveX 延迟分位点',
+    sku: 'SKU',
+    backend: '后端',
+    routing: '路由',
+    xAxisControl: 'X 轴',
+    xScale: 'X 轴刻度',
+    xScaleAria: 'CollectiveX X 轴刻度',
+    yAxisControl: 'Y 轴',
+    tokenRateOption: '延迟分位点对应的 token 速率',
+    yScale: 'Y 轴刻度',
+    yScaleAria: 'CollectiveX Y 轴刻度',
+    noSeries: 'No measured series match these filters.',
+    highContrast: '高对比度',
+    resetFilter: '重置筛选',
+    stableOrdering: '排名顺序稳定性已通过',
+    samplingContract: (trials: number, iterations: number, samples: number, warmups: number) =>
+      `${trials}×${iterations} = 每个分项 ${samples} 个样本 · ${warmups} 次同步预热`,
+    selectedFactorsDiffer: '所选配置存在差异',
+    differenceLabels: {
+      model: '模型',
+      suite: '测试套件',
+      mode: '模式',
+      phase: '阶段',
+      'backend implementation': '后端实现',
+      'implementation build': '实现构建',
+      'system identity': '系统标识',
+      'fabric scope': '互联范围',
+      topology: '拓扑',
+      transport: '传输方式',
+      'world size': '全局 rank 数',
+      'EP degree': 'EP 并行度',
+      placement: '放置方式',
+      workload: '工作负载',
+      'model shape': '模型形状',
+      routing: '路由',
+      'EPLB plan': 'EPLB 方案',
+      dtypes: '数据类型',
+      'resource profile': '资源配置',
+      measurement: '测量协议',
+      'token ladder': 'token 梯度',
+      'component availability': '测量分项可用性',
+      correctness: '正确性',
+    },
+    missingComponents: '不可用的测量分项保持为空，并从图表中省略。',
+    isolatedNote: '分项之和为派生值，不用于计算吞吐量。',
+    payloadNote: '逻辑载荷速率按所选延迟分位点派生，不代表物理链路带宽。',
+    payloadBandwidthNote:
+      '载荷带宽为完整逻辑载荷（含 FP8 缩放字节）÷ 延迟（每 GPU），是基于逻辑字节的派生速率，不代表物理链路带宽。工具提示中的 β/α 为延迟对字节在整个梯度上的最小二乘拟合（β = 每 GPU 带宽项，α = 固定开销）。',
+    provenance: '发布数据溯源',
+    runLabel: 'Run',
+    attemptLabel: 'Attempt',
+    matrixLabel: 'Matrix',
+    sourceBundles: '源产物包',
+    // English placeholders per the repository's temporary language override
+    // (no new Chinese translations); localize when the override lifts.
+    deleteRun: 'Delete run',
+    deleteConfirm: (id: string) =>
+      `Delete run #${id} from the dashboard database? This cannot be undone.`,
+    deleteTokenPrompt: 'Admin token required to delete runs:',
+    deleteUnauthorized: 'Invalid admin token.',
+    deleteFailed: 'Deleting the run failed. Try again.',
+  },
+} as const;
+const CONCLUSION_CLASSES: Record<string, string> = {
+  success: 'border-emerald-600/40 bg-emerald-500/10 text-emerald-700 dark:text-emerald-300',
+  failure: 'border-red-600/40 bg-red-500/10 text-red-700 dark:text-red-300',
+};
+const CONCLUSION_FALLBACK_CLASS =
+  'border-amber-600/40 bg-amber-500/10 text-amber-700 dark:text-amber-300';
+// Remembered admin bearer token for run deletion; cleared on a 401 so a
+// rotated secret re-prompts instead of failing silently forever.
+const ADMIN_TOKEN_STORAGE_KEY = 'collectivex-admin-token';
+
+function formatDate(value: string, locale: 'en' | 'zh'): string {
+  return new Intl.DateTimeFormat(locale === 'zh' ? 'zh-CN' : 'en', {
+    dateStyle: 'medium',
+    timeStyle: 'short',
+    timeZone: 'UTC',
+  }).format(new Date(value));
+}
+
+function ControlGroup({ label, children }: { label: string; children: React.ReactNode }) {
+  return (
+    <div className="min-w-0 space-y-1.5">
+      <Label className="text-[11px] uppercase tracking-wide text-muted-foreground">{label}</Label>
+      {children}
+    </div>
+  );
+}
+
+function selectOptions(
+  values: string[],
+  allLabel: string,
+  uppercase = false,
+): SelectOption<string>[] {
+  return values.map((value) => ({
+    value,
+    label: value === 'all' ? allLabel : uppercase ? value.toUpperCase() : value,
+  }));
+}
+
+export default function CollectiveXDisplay() {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const [version, setVersion] = useState<CollectiveXVersion>(COLLECTIVEX_DEFAULT_VERSION);
+  // JIT run picker: `runsRequested` gates the run listing behind the "Load runs"
+  // button; `selectedRunId` (null = the latest published run) pins the view to one
+  // specific run's dataset. Runs are keyed by their GitHub Actions run id.
+  const [runsRequested, setRunsRequested] = useState(false);
+  const [selectedRunId, setSelectedRunId] = useState<string | null>(null);
+  const latestQuery = useCollectiveX(version);
+  const runsQuery = useCollectiveXRuns(version, runsRequested);
+  const runQuery = useCollectiveXRun(version, selectedRunId);
+  // A pinned run overrides the latest run.
+  const activeQuery = selectedRunId === null ? latestQuery : runQuery;
+  const { data, error, isLoading, isFetching } = activeQuery;
+  const [epSize, setEpSize] = useState(8);
+  const [operation, setOperation] = useState<CollectiveXOperation>('roundtrip');
+  const [phase, setPhase] = useState<CollectiveXPhase>('decode');
+  // Normal (throughput) kernels are the baseline; the availability effect
+  // below falls back when a slice only measured low-latency kernels.
+  const [mode, setMode] = useState<CollectiveXMode>('normal');
+  // Prefer FP8 when the run measured it; the availability effect below falls
+  // back to bf16 for runs (or EP/phase slices) without FP8 series.
+  const [precision, setPrecision] = useState<CollectiveXPrecision>('fp8');
+  const [percentile, setPercentile] = useState<CollectiveXPercentile>('p99');
+  const [yAxis, setYAxis] = useState<CollectiveXYAxis>('latency');
+  const [sku, setSku] = useState('all');
+  const [backend, setBackend] = useState('all');
+  const [activeSeriesIds, setActiveSeriesIds] = useState<Set<string>>(new Set());
+  const [legendExpanded, setLegendExpanded] = useState(true);
+  const operationOptions: SelectOption<CollectiveXOperation>[] = [
+    { value: 'dispatch', label: t.operation.dispatch },
+    { value: 'stage', label: 'Stage' },
+    { value: 'combine', label: t.operation.combine },
+    { value: 'roundtrip', label: t.operation.roundtrip },
+  ];
+  const versionOptions: SelectOption<CollectiveXVersion>[] = COLLECTIVEX_VERSIONS.map((value) => ({
+    value,
+    label: collectiveXVersionLabel(value),
+  }));
+  const runList = runsQuery.data ?? [];
+  const runOptions: SelectOption<string>[] = useMemo(
+    () => [
+      { value: 'latest', label: t.latestPublished },
+      ...runList.map((run) => ({
+        value: run.run_id,
+        label: `#${run.run_id} · ${run.conclusion ?? 'pending'} · ${run.measured_cases}/${run.requested_cases} cases · ${run.terminal_points}/${run.requested_points} points · ${run.covered_skus.length} SKU · ${formatDate(run.generated_at, locale)}`,
+      })),
+    ],
+    [locale, runList, t.latestPublished],
+  );
+  // Runs are per-version; changing the version drops any pinned run and folds
+  // the picker back to its JIT button.
+  useEffect(() => {
+    setSelectedRunId(null);
+    setRunsRequested(false);
+  }, [version]);
+  // If a refreshed listing no longer carries the pinned run, fall back to the
+  // latest run rather than a dangling id.
+  useEffect(() => {
+    if (
+      selectedRunId !== null &&
+      runsQuery.data &&
+      !runsQuery.data.some((run) => run.run_id === selectedRunId)
+    ) {
+      setSelectedRunId(null);
+    }
+  }, [runsQuery.data, selectedRunId]);
+  const dataset = data;
+  const availableEpSizes = useMemo(
+    () =>
+      [...new Set(dataset?.series.map((item) => item.system.ep_size))].toSorted((a, b) => a - b),
+    [dataset?.series],
+  );
+  const availablePhases = useMemo(
+    () =>
+      [
+        ...new Set(
+          dataset?.series
+            .filter((item) => item.system.ep_size === epSize)
+            .map((item) => item.phase),
+        ),
+      ].toSorted((left, right) =>
+        left === right ? 0 : left === 'decode' ? -1 : right === 'decode' ? 1 : 0,
+      ),
+    [dataset?.series, epSize],
+  );
+  const phaseOptions: SegmentedToggleOption<CollectiveXPhase>[] = availablePhases.map((value) => ({
+    value,
+    label: t.phase[value],
+  }));
+  const availableModes = useMemo(
+    () =>
+      [
+        ...new Set(
+          dataset?.series
+            .filter((item) => item.system.ep_size === epSize && item.phase === phase)
+            .map((item) => item.mode),
+        ),
+      ].toSorted((left, right) =>
+        left === right ? 0 : left === 'normal' ? -1 : right === 'normal' ? 1 : 0,
+      ),
+    [dataset?.series, epSize, phase],
+  );
+  const modeOptions: SegmentedToggleOption<CollectiveXMode>[] = availableModes.map((value) => ({
+    value,
+    label: t.mode[value],
+  }));
+  const availablePrecisions = useMemo(
+    () =>
+      [
+        ...new Set(
+          dataset?.series
+            .filter(
+              (item) =>
+                item.system.ep_size === epSize && item.phase === phase && item.mode === mode,
+            )
+            .map((item) => item.precision),
+        ),
+      ].toSorted(),
+    [dataset?.series, epSize, mode, phase],
+  );
+  const precisionOptions: SegmentedToggleOption<CollectiveXPrecision>[] = availablePrecisions.map(
+    (value) => ({ value, label: t.precision[value] }),
+  );
+  useEffect(() => {
+    if (availableEpSizes.length > 0 && !availableEpSizes.includes(epSize)) {
+      setEpSize(availableEpSizes[0]);
+    }
+    if (availablePhases.length > 0 && !availablePhases.includes(phase)) {
+      setPhase(availablePhases[0]);
+    }
+    if (availableModes.length > 0 && !availableModes.includes(mode)) {
+      setMode(availableModes[0]);
+    }
+    if (availablePrecisions.length > 0 && !availablePrecisions.includes(precision)) {
+      setPrecision(availablePrecisions[0]);
+    }
+  }, [
+    availableEpSizes,
+    availableModes,
+    availablePhases,
+    availablePrecisions,
+    epSize,
+    mode,
+    phase,
+    precision,
+  ]);
+  const seriesSelection = useMemo<CollectiveXSeriesSelection>(
+    () => ({ epSize, phase, mode, precision }),
+    [epSize, mode, phase, precision],
+  );
+  // SKU and EP determine topology; V1 fixes routing. EP, phase, kernel mode,
+  // and precision are needed before the library/SKU comparison filters.
+  const matchedSeries = useMemo(
+    () => (dataset?.series ?? []).filter((item) => seriesMatchesSelection(item, seriesSelection)),
+    [dataset?.series, seriesSelection],
+  );
+  const skuOptions = useMemo(
+    () => ['all', ...new Set(matchedSeries.map((item) => item.system.sku))],
+    [matchedSeries],
+  );
+  const backendOptions = useMemo(
+    () => [
+      'all',
+      ...new Set(
+        matchedSeries
+          .filter((item) => sku === 'all' || item.system.sku === sku)
+          .map((item) => item.backend),
+      ),
+    ],
+    [matchedSeries, sku],
+  );
+  useEffect(() => {
+    if (!skuOptions.includes(sku)) setSku('all');
+    if (!backendOptions.includes(backend)) setBackend('all');
+  }, [backend, backendOptions, sku, skuOptions]);
+  const phaseSeries = useMemo(
+    () =>
+      matchedSeries.filter(
+        (item) =>
+          (sku === 'all' || item.system.sku === sku) &&
+          (backend === 'all' || item.backend === backend),
+      ),
+    [backend, matchedSeries, sku],
+  );
+
+  useEffect(() => {
+    setActiveSeriesIds(new Set(phaseSeries.map((item) => item.series_id)));
+  }, [phaseSeries]);
+
+  const activeSeries = useMemo(
+    () => phaseSeries.filter((item) => activeSeriesIds.has(item.series_id)),
+    [activeSeriesIds, phaseSeries],
+  );
+  const colorKeys = useMemo(
+    () => [...new Set(phaseSeries.map(collectiveXColorKey))],
+    [phaseSeries],
+  );
+  const { resolveColor, getCssColor } = useThemeColors({
+    highContrast: false,
+    activeKeys: colorKeys,
+    hcKeys: colorKeys,
+    hcVendorKeyFor: (key) => key.split('_')[0],
+  });
+  const colors = useMemo(
+    () => Object.fromEntries(colorKeys.map((key) => [key, getCssColor(resolveColor(key, key))])),
+    [colorKeys, getCssColor, resolveColor],
+  );
+  const legendItems = useMemo(
+    () =>
+      phaseSeries.map((item) => ({
+        name: item.series_id,
+        label: collectiveXSeriesLabel(item),
+        color: colors[collectiveXColorKey(item)] ?? 'var(--muted-foreground)',
+        isActive: activeSeriesIds.has(item.series_id),
+        title: `EP${item.system.ep_size} · ${collectiveXTopologyLabel(item.system)}`,
+        onClick: () => {
+          setActiveSeriesIds((previous) => {
+            const next = new Set(previous);
+            if (next.has(item.series_id)) next.delete(item.series_id);
+            else next.add(item.series_id);
+            return next;
+          });
+          track('collectivex_series_toggled', { series: item.series_id });
+        },
+      })),
+    [activeSeriesIds, colors, phaseSeries],
+  );
+  const handleRefresh = useCallback(() => {
+    track('collectivex_data_refreshed');
+    void activeQuery.refetch();
+    if (runsRequested) void runsQuery.refetch();
+  }, [activeQuery, runsQuery, runsRequested]);
+  const deleteRun = useDeleteCollectiveXRun();
+  const shownRunId = dataset?.run.run_id;
+  const handleDeleteRun = useCallback(async () => {
+    if (!shownRunId) return;
+    track('collectivex_run_delete_prompted', { run: shownRunId });
+    if (!window.confirm(t.deleteConfirm(shownRunId))) return;
+    const stored = localStorage.getItem(ADMIN_TOKEN_STORAGE_KEY) ?? '';
+    const token = stored || (window.prompt(t.deleteTokenPrompt)?.trim() ?? '');
+    if (!token) return;
+    try {
+      const deleted = await deleteRun.mutateAsync({ runId: shownRunId, token });
+      if (!deleted) {
+        localStorage.removeItem(ADMIN_TOKEN_STORAGE_KEY);
+        track('collectivex_run_delete_failed', { run: shownRunId, reason: 'unauthorized' });
+        window.alert(t.deleteUnauthorized);
+        return;
+      }
+      localStorage.setItem(ADMIN_TOKEN_STORAGE_KEY, token);
+      track('collectivex_run_delete_confirmed', { run: shownRunId });
+      // The deleted run can no longer be pinned; fall back to the new latest.
+      setSelectedRunId(null);
+    } catch {
+      track('collectivex_run_delete_failed', { run: shownRunId, reason: 'error' });
+      window.alert(t.deleteFailed);
+    }
+  }, [deleteRun, shownRunId, t]);
+  if (isLoading) {
+    return (
+      <Card data-testid="collectivex-loading" className="min-h-80 items-center justify-center">
+        <Loader2 className="size-6 animate-spin text-muted-foreground" />
+        <p className="mt-3 text-sm text-muted-foreground">{t.loading}</p>
+      </Card>
+    );
+  }
+  if (error || !data || !dataset) {
+    const message = error instanceof Error ? error.message : t.loadError;
+    return (
+      <Card data-testid="collectivex-error" className="border-destructive">
+        <h1 className="text-lg font-semibold">{t.unavailable}</h1>
+        <p className="mt-2 text-sm text-destructive">{message}</p>
+        <div className="mt-4 flex flex-wrap items-center gap-3">
+          <div className="min-w-32">
+            <SelectControl
+              label={t.version}
+              testId="collectivex-error-version-select"
+              value={version}
+              options={versionOptions}
+              onChange={setVersion}
+            />
+          </div>
+          {selectedRunId !== null && (
+            <Button
+              variant="outline"
+              data-testid="collectivex-error-latest"
+              onClick={() => setSelectedRunId(null)}
+            >
+              {t.latestPublished}
+            </Button>
+          )}
+          <Button variant="outline" onClick={handleRefresh}>
+            <RefreshCw className="size-4" />
+            {t.retry}
+          </Button>
+        </div>
+      </Card>
+    );
+  }
+
+  const run = dataset.run;
+  const conclusionClass =
+    (run.conclusion && CONCLUSION_CLASSES[run.conclusion]) ?? CONCLUSION_FALLBACK_CLASS;
+
+  return (
+    <section data-testid="collectivex-display" className="flex flex-col gap-4">
+      <Card>
+        <div className="flex flex-col gap-4 lg:flex-row lg:items-start lg:justify-between">
+          <div>
+            <div className="flex flex-wrap items-center gap-2">
+              <h1 className="text-xl font-semibold">CollectiveX</h1>
+              <span
+                data-testid="collectivex-run-conclusion"
+                className={`rounded-md border px-2 py-0.5 text-[11px] font-medium ${conclusionClass}`}
+              >
+                #{run.run_id} · {run.conclusion ?? 'pending'}
+              </span>
+            </div>
+            <p className="mt-2 text-sm text-muted-foreground">{t.description}</p>
+          </div>
+          <div className="flex shrink-0 flex-wrap items-center gap-2">
+            <a
+              data-testid="collectivex-source-link"
+              href={`https://github.com/SemiAnalysisAI/InferenceX/tree/${run.source_sha}/experimental/CollectiveX`}
+              target="_blank"
+              rel="noopener noreferrer"
+              onClick={() => track('collectivex_source_opened', { source_sha: run.source_sha })}
+              className="inline-flex h-9 items-center gap-1.5 rounded-md border px-3 text-sm font-medium text-muted-foreground transition-colors hover:bg-muted hover:text-foreground"
+            >
+              {t.source} <ExternalLink className="size-3.5" />
+            </a>
+            <a
+              data-testid="collectivex-methodology-link"
+              href={`https://github.com/SemiAnalysisAI/InferenceX/blob/${run.source_sha}/experimental/CollectiveX/docs/methodology.md`}
+              target="_blank"
+              rel="noopener noreferrer"
+              onClick={() =>
+                track('collectivex_methodology_opened', { source_sha: run.source_sha })
+              }
+              className="inline-flex h-9 items-center gap-1.5 rounded-md border px-3 text-sm font-medium text-muted-foreground transition-colors hover:bg-muted hover:text-foreground"
+            >
+              <BookOpen className="size-3.5" /> {t.methodology}
+            </a>
+            <Button variant="outline" size="sm" onClick={handleRefresh} disabled={isFetching}>
+              {isFetching ? (
+                <Loader2 className="size-4 animate-spin" />
+              ) : (
+                <RefreshCw className="size-4" />
+              )}
+              {t.refresh}
+            </Button>
+            <Button
+              variant="outline"
+              size="sm"
+              data-testid="collectivex-delete-run"
+              className="text-destructive hover:bg-destructive/10 hover:text-destructive"
+              onClick={() => void handleDeleteRun()}
+              disabled={deleteRun.isPending}
+            >
+              {deleteRun.isPending ? (
+                <Loader2 className="size-4 animate-spin" />
+              ) : (
+                <Trash2 className="size-4" />
+              )}
+              {t.deleteRun}
+            </Button>
+          </div>
+        </div>
+        <div className="mt-5 grid grid-cols-2 gap-3 sm:grid-cols-4">
+          <Stat value={dataset.series.length} label={t.seriesCount} />
+          <Stat value={`${run.measured_cases}/${run.requested_cases}`} label={t.measuredCases} />
+          <Stat value={`${run.terminal_cases}/${run.requested_cases}`} label={t.terminalCases} />
+          <Stat value={formatDate(run.generated_at, locale)} label={t.publishedUtc} compact />
+        </div>
+      </Card>
+
+      {phaseSeries.length === 0 && (
+        <Card data-testid="collectivex-empty-state" className="py-4">
+          <p className="text-sm text-muted-foreground">{t.noSeries}</p>
+        </Card>
+      )}
+      <Card data-testid="collectivex-main-chart" className="relative">
+        <CollectiveXChart
+          chartId="collectivex-explorer"
+          testId="collectivex-explorer-chart"
+          series={activeSeries}
+          colors={colors}
+          operation={operation}
+          percentile={percentile}
+          yAxis={yAxis}
+          caption={
+            <>
+              <h2 className="text-lg font-semibold">
+                {operation === 'stage' ? 'Stage' : t.operationHeading[operation]} ·{' '}
+                {t.phaseValue[phase]} ·{' '}
+                {yAxis === 'latency'
+                  ? percentile
+                  : locale === 'zh'
+                    ? `${percentile} 延迟分位点`
+                    : `at ${percentile} latency`}
+              </h2>
+              <p className="text-sm text-muted-foreground">
+                {yAxis === 'activation-rate'
+                  ? 'Activation-data rate at selected latency percentile'
+                  : t.yAxis[yAxis]}
+              </p>
+            </>
+          }
+          legendElement={
+            <ChartLegend
+              variant="sidebar"
+              legendItems={legendItems}
+              disableActiveSort
+              onItemRemove={(id) =>
+                setActiveSeriesIds(
+                  (previous) => new Set([...previous].filter((item) => item !== id)),
+                )
+              }
+              isLegendExpanded={legendExpanded}
+              onExpandedChange={setLegendExpanded}
+              actions={
+                activeSeries.length < phaseSeries.length
+                  ? [
+                      {
+                        id: 'collectivex-reset-filter',
+                        label: t.resetFilter,
+                        onClick: () =>
+                          setActiveSeriesIds(new Set(phaseSeries.map((item) => item.series_id))),
+                      },
+                    ]
+                  : []
+              }
+            />
+          }
+        />
+        {yAxis === 'activation-rate' && (
+          <p className="mt-2 text-xs text-muted-foreground">{t.payloadNote}</p>
+        )}
+        {yAxis === 'payload-rate' && (
+          <p className="mt-2 text-xs text-muted-foreground">{t.payloadBandwidthNote}</p>
+        )}
+      </Card>
+      <Card className="py-4 md:py-5">
+        <div className="grid gap-x-5 gap-y-3 sm:grid-cols-2 lg:grid-cols-4 xl:grid-cols-6">
+          <SelectControl
+            label={t.version}
+            testId="collectivex-version-select"
+            value={version}
+            options={versionOptions}
+            onChange={(value) => {
+              setVersion(value);
+              track('collectivex_version_changed', { version: value });
+            }}
+          />
+          <ControlGroup label={t.runControl}>
+            {runsRequested ? (
+              runsQuery.isLoading ? (
+                <Button
+                  variant="outline"
+                  className="w-full justify-center"
+                  disabled
+                  data-testid="collectivex-runs-loading"
+                >
+                  <Loader2 className="size-4 animate-spin" />
+                  {t.loadingRuns}
+                </Button>
+              ) : runsQuery.error || !runsQuery.data ? (
+                <Button
+                  variant="outline"
+                  className="w-full justify-center"
+                  data-testid="collectivex-runs-retry"
+                  onClick={() => void runsQuery.refetch()}
+                >
+                  <RefreshCw className="size-4" />
+                  {t.retry}
+                </Button>
+              ) : (
+                <Select
+                  value={selectedRunId ?? 'latest'}
+                  onValueChange={(next) => {
+                    setSelectedRunId(next === 'latest' ? null : next);
+                    track('collectivex_run_selected', { version, run: next });
+                  }}
+                >
+                  <SelectTrigger data-testid="collectivex-run-select" className="min-w-0 w-full">
+                    <SelectValue />
+                  </SelectTrigger>
+                  <SelectContent>
+                    {runOptions.map((item) => (
+                      <SelectItem key={item.value} value={item.value}>
+                        {item.label}
+                      </SelectItem>
+                    ))}
+                  </SelectContent>
+                </Select>
+              )
+            ) : (
+              <Button
+                variant="outline"
+                className="w-full justify-center"
+                data-testid="collectivex-load-runs"
+                onClick={() => {
+                  setRunsRequested(true);
+                  track('collectivex_runs_requested', { version });
+                }}
+              >
+                {t.loadRuns}
+              </Button>
+            )}
+          </ControlGroup>
+          <SelectControl
+            label={t.epControl}
+            testId="collectivex-ep-select"
+            value={String(epSize)}
+            options={availableEpSizes.map((value) => ({
+              value: String(value),
+              label: `EP${value}`,
+            }))}
+            onChange={(value) => {
+              setEpSize(Number(value));
+              track('collectivex_ep_changed', { ep: Number(value) });
+            }}
+          />
+          <SelectControl
+            label={t.operationControl}
+            testId="collectivex-operation-select"
+            value={operation}
+            options={operationOptions}
+            onChange={(next) => {
+              setOperation(next);
+              if (next !== 'roundtrip' && yAxis === 'tokens-per-second') setYAxis('latency');
+            }}
+          />
+          <ControlGroup label={t.phaseControl}>
+            <SegmentedToggle
+              value={phase}
+              options={phaseOptions}
+              onValueChange={setPhase}
+              ariaLabel={t.phaseAria}
+              testId="collectivex-phase-toggle"
+            />
+          </ControlGroup>
+          {availableModes.length > 1 && (
+            <ControlGroup label={t.modeControl}>
+              <SegmentedToggle
+                value={mode}
+                options={modeOptions}
+                onValueChange={(next) => {
+                  setMode(next);
+                  track('collectivex_mode_changed', { mode: next });
+                }}
+                ariaLabel={t.modeAria}
+                testId="collectivex-mode-toggle"
+              />
+            </ControlGroup>
+          )}
+          <ControlGroup label={t.precisionControl}>
+            <SegmentedToggle
+              value={precision}
+              options={precisionOptions}
+              onValueChange={(next) => {
+                setPrecision(next);
+                track('collectivex_precision_changed', { precision: next });
+              }}
+              ariaLabel={t.precisionAria}
+              testId="collectivex-precision-toggle"
+            />
+          </ControlGroup>
+          <ControlGroup label={t.latencyPercentile}>
+            <SegmentedToggle
+              value={percentile}
+              options={PERCENTILE_OPTIONS}
+              onValueChange={setPercentile}
+              ariaLabel={t.percentileAria}
+              testId="collectivex-percentile-toggle"
+            />
+          </ControlGroup>
+          <SelectControl
+            label={t.sku}
+            testId="collectivex-sku-select"
+            value={sku}
+            options={selectOptions(skuOptions, t.all, true)}
+            onChange={setSku}
+          />
+          <SelectControl
+            label={t.backend}
+            testId="collectivex-backend-select"
+            value={backend}
+            options={selectOptions(backendOptions, t.all)}
+            onChange={setBackend}
+          />
+          <SelectControl
+            label={t.yAxisControl}
+            testId="collectivex-y-axis-select"
+            value={yAxis}
+            onChange={setYAxis}
+            options={[
+              { value: 'latency', label: t.yAxis.latency },
+              ...(operation === 'roundtrip'
+                ? ([
+                    {
+                      value: 'tokens-per-second',
+                      label: t.tokenRateOption,
+                    },
+                  ] as const)
+                : []),
+              {
+                value: 'activation-rate',
+                label: 'Activation-data rate at latency percentile',
+              },
+              {
+                value: 'payload-rate',
+                label: t.yAxis['payload-rate'],
+              },
+            ]}
+          />
+        </div>
+      </Card>
+      <CollectiveXInventory
+        key={`${dataset.version}-${run.run_id}-${run.run_attempt}`}
+        dataset={dataset}
+      />
+    </section>
+  );
+}
+
+function Stat({
+  value,
+  label,
+  compact = false,
+}: {
+  value: React.ReactNode;
+  label: string;
+  compact?: boolean;
+}) {
+  return (
+    <div>
+      <p className={compact ? 'text-sm font-semibold' : 'text-2xl font-semibold'}>{value}</p>
+      <p className="text-xs text-muted-foreground">{label}</p>
+    </div>
+  );
+}
+
+function SelectControl<T extends string | number>({
+  label,
+  testId,
+  value,
+  options,
+  onChange,
+  placeholder,
+}: {
+  label: string;
+  testId: string;
+  value: T;
+  options: SelectOption<T>[];
+  onChange: (value: T) => void;
+  placeholder?: string;
+}) {
+  // Radix Select speaks strings; numeric option values (e.g. the release version)
+  // round-trip through String() and are recovered from the option list on change.
+  return (
+    <ControlGroup label={label}>
+      <Select
+        value={String(value)}
+        onValueChange={(next) => {
+          const match = options.find((item) => String(item.value) === next);
+          if (match) onChange(match.value);
+        }}
+      >
+        <SelectTrigger data-testid={testId} className="min-w-0 w-full">
+          <SelectValue placeholder={placeholder} />
+        </SelectTrigger>
+        <SelectContent>
+          {options.map((item) => (
+            <SelectItem key={String(item.value)} value={String(item.value)}>
+              {item.label}
+            </SelectItem>
+          ))}
+        </SelectContent>
+      </Select>
+    </ControlGroup>
+  );
+}
diff --git a/packages/app/src/components/collectivex/CollectiveXInventory.tsx b/packages/app/src/components/collectivex/CollectiveXInventory.tsx
new file mode 100644
index 00000000..7b854379
--- /dev/null
+++ b/packages/app/src/components/collectivex/CollectiveXInventory.tsx
@@ -0,0 +1,149 @@
+'use client';
+
+import { useMemo } from 'react';
+
+import { Badge } from '@/components/ui/badge';
+import { Card } from '@/components/ui/card';
+import { type DataTableColumn, DataTable } from '@/components/ui/data-table';
+
+import { collectiveXTopologyLabel } from './data';
+import type { CollectiveXCoverage, CollectiveXDataset, CollectiveXTerminalStatus } from './types';
+
+const TERMINAL_ORDER: CollectiveXTerminalStatus[] = [
+  'measured',
+  'unsupported',
+  'failed',
+  'invalid',
+  'diagnostic',
+  'pending',
+];
+
+const STATUS_CLASS: Record<CollectiveXTerminalStatus, string> = {
+  measured: 'border-emerald-600/40 bg-emerald-500/10 text-emerald-700 dark:text-emerald-300',
+  unsupported: 'border-zinc-500/40 bg-zinc-500/10 text-zinc-700 dark:text-zinc-300',
+  failed: 'border-red-700/50 bg-red-700/10 text-red-800 dark:text-red-300',
+  invalid: 'border-red-600/40 bg-red-500/10 text-red-700 dark:text-red-300',
+  diagnostic: 'border-amber-600/40 bg-amber-500/10 text-amber-700 dark:text-amber-300',
+  pending: 'border-zinc-500/40 bg-zinc-500/5 text-muted-foreground',
+};
+
+function terminalCounts(item: CollectiveXCoverage): Record<CollectiveXTerminalStatus, number> {
+  const counts = Object.fromEntries(TERMINAL_ORDER.map((status) => [status, 0])) as Record<
+    CollectiveXTerminalStatus,
+    number
+  >;
+  for (const point of item.points) counts[point.terminal_status] += 1;
+  return counts;
+}
+
+function TerminalBadges({ item }: { item: CollectiveXCoverage }) {
+  const counts = terminalCounts(item);
+  const reasons = [...new Set(item.points.flatMap((point) => point.reason ?? []))];
+  return (
+    <div className="min-w-44">
+      <div className="flex flex-wrap gap-1">
+        {TERMINAL_ORDER.filter((status) => counts[status] > 0).map((status) => (
+          <Badge key={status} variant="outline" className={STATUS_CLASS[status]}>
+            {status} {counts[status]}
+          </Badge>
+        ))}
+      </div>
+      {reasons.length > 0 && (
+        <p className="mt-1 text-xs text-muted-foreground">{reasons.join(', ')}</p>
+      )}
+    </div>
+  );
+}
+
+export function CollectiveXInventory({ dataset }: { dataset: CollectiveXDataset }) {
+  const columns = useMemo<DataTableColumn<CollectiveXCoverage>[]>(
+    () => [
+      {
+        header: 'Case',
+        cell: (row) => (
+          <div className="min-w-56">
+            <p className="font-medium">{row.label}</p>
+            <p className="mt-0.5 font-mono text-[11px] text-muted-foreground">{row.case_id}</p>
+          </div>
+        ),
+        sortValue: (row) => `${row.label} ${row.case_id}`,
+      },
+      { header: 'SKU', cell: (row) => row.sku.toUpperCase(), sortValue: (row) => row.sku },
+      {
+        header: 'Backend',
+        cell: (row) => row.backend,
+        sortValue: (row) => row.backend,
+        className: 'whitespace-nowrap',
+      },
+      {
+        header: 'EP',
+        cell: (row) => `EP${row.topology.ep_size}`,
+        sortValue: (row) => row.topology.ep_size,
+      },
+      {
+        header: 'Phase',
+        cell: (row) => row.phase,
+        sortValue: (row) => row.phase,
+      },
+      {
+        header: 'Mode',
+        cell: (row) => row.mode,
+        sortValue: (row) => row.mode,
+      },
+      {
+        header: 'Precision',
+        cell: (row) => row.precision,
+        sortValue: (row) => row.precision,
+      },
+      {
+        header: 'Topology',
+        cell: (row) => collectiveXTopologyLabel(row.topology),
+        sortValue: (row) => collectiveXTopologyLabel(row.topology),
+        className: 'whitespace-nowrap',
+      },
+      {
+        header: 'Disposition',
+        cell: (row) => (
+          <div className="min-w-48">
+            <p>
+              {row.disposition} · {row.outcome}
+            </p>
+            {(row.detail || row.reason) && (
+              <p className="text-xs text-muted-foreground">{row.detail ?? row.reason}</p>
+            )}
+          </div>
+        ),
+        sortValue: (row) =>
+          `${row.disposition} ${row.outcome} ${row.reason ?? ''} ${row.detail ?? ''}`,
+      },
+      {
+        header: 'Point status',
+        cell: (row) => <TerminalBadges item={row} />,
+        sortValue: (row) =>
+          `${TERMINAL_ORDER.map((status) => `${status}:${terminalCounts(row)[status]}`).join(' ')} ${row.points.map((point) => point.reason ?? '').join(' ')}`,
+      },
+    ],
+    [],
+  );
+  const points = dataset.coverage.flatMap((item) => item.points);
+  const measured = points.filter((point) => point.terminal_status === 'measured').length;
+  const unsupported = points.filter((point) => point.terminal_status === 'unsupported').length;
+
+  return (
+    <Card data-testid="collectivex-inventory" className="min-w-0 w-full max-w-full overflow-hidden">
+      <h2 className="text-lg font-semibold">Matrix case inventory</h2>
+      <p className="mt-1 text-sm text-muted-foreground">
+        {dataset.coverage.length} cases · {dataset.run.measured_cases} measured ·{' '}
+        {dataset.run.unsupported_cases} unsupported · {dataset.run.terminal_points}/
+        {dataset.run.requested_points} terminal points · {measured} measured · {unsupported}{' '}
+        unsupported
+      </p>
+      <DataTable
+        data={dataset.coverage}
+        columns={columns}
+        testId="collectivex-inventory-table"
+        analyticsPrefix="collectivex_inventory"
+      />
+    </Card>
+  );
+}
diff --git a/packages/app/src/components/collectivex/CollectiveXTables.tsx b/packages/app/src/components/collectivex/CollectiveXTables.tsx
new file mode 100644
index 00000000..14c5843e
--- /dev/null
+++ b/packages/app/src/components/collectivex/CollectiveXTables.tsx
@@ -0,0 +1,267 @@
+'use client';
+
+import { useMemo } from 'react';
+
+import { Badge } from '@/components/ui/badge';
+import { Card } from '@/components/ui/card';
+import { type DataTableColumn, DataTable } from '@/components/ui/data-table';
+import { useLocale } from '@/lib/use-locale';
+
+import { collectiveXTopologyLabel } from './data';
+
+import type { CollectiveXCoverage, CollectiveXOutcome } from './types';
+
+const OUTCOME_CLASSES = {
+  success: 'border-emerald-600/40 bg-emerald-500/15 text-emerald-700 dark:text-emerald-300',
+  unsupported: 'border-zinc-500/40 bg-zinc-500/15 text-zinc-700 dark:text-zinc-300',
+  failed: 'border-red-700/50 bg-red-700/15 text-red-800 dark:text-red-300',
+  invalid: 'border-red-600/40 bg-red-500/15 text-red-700 dark:text-red-300',
+  diagnostic: 'border-amber-600/40 bg-amber-500/15 text-amber-700 dark:text-amber-300',
+  pending: 'border-zinc-500/40 bg-zinc-500/5 text-muted-foreground',
+} satisfies Record<CollectiveXOutcome, string>;
+
+const STRINGS = {
+  en: {
+    outcome: {
+      success: 'success',
+      unsupported: 'unsupported',
+      failed: 'failed',
+      invalid: 'invalid',
+      diagnostic: 'diagnostic',
+      pending: 'pending',
+    },
+    phase: { decode: 'decode', prefill: 'prefill' },
+    mode: { normal: 'Normal', 'low-latency': 'Low latency' },
+    scope: { 'scale-up': 'Scale-up', 'scale-out': 'Scale-out' },
+    disposition: { runnable: 'runnable', unsupported: 'unsupported' },
+    case: 'Case',
+    sku: 'SKU',
+    backend: 'Backend',
+    phaseHeader: 'Phase',
+    precisionHeader: 'Precision',
+    modeHeader: 'Mode',
+    epHeader: 'EP',
+    scopeHeader: 'Fabric scope',
+    topologyHeader: 'Topology',
+    dispositionHeader: 'Disposition',
+    outcomeHeader: 'Outcome',
+    attempts: 'Attempts',
+    selected: 'Selected',
+    caseId: 'Case ID',
+    attemptId: 'Attempt ID',
+    failureMode: 'Failure mode',
+    reason: 'Reason',
+    terminalCoverage: 'Terminal coverage',
+    allocation: 'Allocation',
+    run: 'Run',
+    attempt: 'Try',
+    role: 'Role',
+    terminalRole: 'terminal selection',
+    allocationRole: 'allocation selection',
+    retainedRole: 'retained',
+    evidence: 'Evidence',
+    retainedAttempts: 'Retained attempts',
+  },
+  zh: {
+    outcome: {
+      success: '成功',
+      unsupported: '不支持',
+      failed: '失败',
+      invalid: '无效',
+      diagnostic: '诊断',
+      pending: '待运行',
+    },
+    phase: { decode: '解码', prefill: '预填充' },
+    mode: { normal: '常规', 'low-latency': '低延迟' },
+    scope: { 'scale-up': '域内（scale-up）', 'scale-out': '跨域（scale-out）' },
+    disposition: { runnable: '可运行', unsupported: '不支持' },
+    case: '用例',
+    sku: 'SKU',
+    backend: '后端',
+    phaseHeader: '阶段',
+    precisionHeader: '精度',
+    modeHeader: '模式',
+    epHeader: 'EP',
+    scopeHeader: '互联范围',
+    topologyHeader: '拓扑',
+    dispositionHeader: '计划状态',
+    outcomeHeader: '结果',
+    attempts: '尝试次数',
+    selected: '已选尝试',
+    caseId: '用例 ID',
+    attemptId: '尝试 ID',
+    failureMode: '失败类型',
+    reason: '原因',
+    terminalCoverage: '终结状态覆盖',
+    allocation: '独立分配',
+    run: '运行',
+    attempt: '尝试序号',
+    role: '用途',
+    terminalRole: '终结状态选择',
+    allocationRole: '独立分配选择',
+    retainedRole: '保留',
+    evidence: '证据数',
+    retainedAttempts: '保留的全部尝试',
+  },
+} as const;
+
+const REASON_LABELS = {
+  zh: {
+    'artifact-validation-failed': '产物校验失败',
+    'backend-platform-unsupported': '后端不支持该平台',
+    'backend-token-capacity': '后端 token 容量不足',
+    'launcher-setup-failed': '启动器初始化失败',
+    'repository-staging-failed': '代码仓库暂存失败',
+    'container-registry-verification-failed': '容器镜像仓库校验失败',
+    'scheduler-allocation-failed': '调度资源分配失败',
+    'container-image-preparation-failed': '容器镜像准备失败',
+    'container-image-identity-failed': '容器镜像身份校验失败',
+    'container-runtime-launch-failed': '容器运行时启动失败',
+    'backend-setup-failed': '后端初始化失败',
+    'artifact-collection-failed': '产物收集失败',
+    'runtime-identity-mismatch': '运行时身份不匹配',
+    'execution-timeout': '执行超时',
+    'execution-deadlock': '执行死锁',
+    'distributed-command-failed': '分布式命令执行失败',
+    'post-emit-distributed-command-failed': '结果写出后的分布式命令失败',
+    'unsupported-capability': '能力不支持',
+    'execution-failed': '执行失败',
+    'validation-failed': '校验失败',
+    'diagnostic-evidence': '诊断证据',
+    capability: '能力限制',
+    setup: '初始化',
+    'repository-stage': '代码仓库暂存',
+    'registry-verification': '镜像仓库校验',
+    'scheduler-allocation': '调度资源分配',
+    'container-import': '容器镜像导入',
+    'container-hash': '容器镜像哈希校验',
+    'container-launch': '容器启动',
+    'backend-setup': '后端初始化',
+    'artifact-collection': '产物收集',
+    'runtime-identity': '运行时身份',
+    timeout: '超时',
+    deadlock: '死锁',
+    execution: '执行',
+    'insufficient-allocations': '独立分配不足',
+    'incomplete-repeat-coverage': '重复运行覆盖不完整',
+    'correctness-failed': '正确性校验失败',
+    'missing-measured-roundtrip-p99': '缺少实测往返 p99',
+    'unstable-ordering': '排名顺序不稳定',
+    'incomplete-provenance': '来源与运行溯源不完整',
+    'noncanonical-workload': '工作负载不符合规范',
+    'unresolved-anomaly': '异常尚未解释',
+    'semantic-correctness-failed': '语义正确性校验失败',
+    'measurement-nonconformant': '测量协议不符合要求',
+    'expert-oracle-incomplete': '专家路由正确性校验不完整',
+    'incomplete-aligned-repeats': '对齐的重复运行不完整',
+    'missing-uniform-baseline': '缺少 uniform 基线',
+    'incomplete-routing-anchors': '路由基准锚点不完整',
+    'implementation-config-mismatch': '实现配置不一致',
+    'unmatched-token-coverage': 'token 点位覆盖不一致',
+    'awaiting-v1-runs': '等待 CollectiveX v1 运行结果',
+  },
+} as const;
+
+export function collectiveXReasonLabel(value: string, locale: 'en' | 'zh'): string {
+  if (locale === 'en') return value;
+  return REASON_LABELS.zh[value as keyof typeof REASON_LABELS.zh] ?? value;
+}
+
+function OutcomeBadge({ outcome }: { outcome: CollectiveXOutcome }) {
+  const t = STRINGS[useLocale()];
+  return (
+    <Badge variant="outline" className={OUTCOME_CLASSES[outcome]}>
+      {t.outcome[outcome]}
+    </Badge>
+  );
+}
+
+function shortId(value: string | null): string {
+  if (value === null) return '-';
+  const suffix = value.lastIndexOf('-');
+  return suffix === -1 ? value : value.slice(suffix + 1).slice(-8);
+}
+
+export function CollectiveXCoverageTable({ coverage }: { coverage: CollectiveXCoverage[] }) {
+  const locale = useLocale();
+  const t = STRINGS[locale];
+  const columns = useMemo<DataTableColumn<CollectiveXCoverage>[]>(
+    () => [
+      {
+        header: t.case,
+        cell: (row) => (
+          <div title={`${t.caseId}: ${row.case_id}`}>
+            <p className="font-medium whitespace-nowrap">{row.label}</p>
+            <p className="font-mono text-[11px] text-muted-foreground">{shortId(row.case_id)}</p>
+          </div>
+        ),
+        sortValue: (row) => row.label,
+      },
+      {
+        header: t.sku,
+        cell: (row) => row.sku.toUpperCase(),
+        sortValue: (row) => row.sku,
+      },
+      {
+        header: t.backend,
+        cell: (row) => row.backend,
+        sortValue: (row) => row.backend,
+      },
+      {
+        header: t.phaseHeader,
+        cell: (row) => t.phase[row.phase],
+        sortValue: (row) => t.phase[row.phase],
+      },
+      {
+        header: t.modeHeader,
+        cell: (row) => row.mode,
+        sortValue: (row) => row.mode,
+      },
+      {
+        header: t.precisionHeader,
+        cell: (row) => row.precision,
+        sortValue: (row) => row.precision,
+      },
+      {
+        header: t.epHeader,
+        cell: (row) => `EP${row.topology.ep_size}`,
+        sortValue: (row) => row.topology.ep_size,
+      },
+      {
+        header: t.topologyHeader,
+        cell: (row) => collectiveXTopologyLabel(row.topology),
+        sortValue: (row) => collectiveXTopologyLabel(row.topology),
+        className: 'whitespace-nowrap',
+      },
+      {
+        header: t.dispositionHeader,
+        cell: (row) => t.disposition[row.disposition],
+        sortValue: (row) => t.disposition[row.disposition],
+      },
+      {
+        header: t.outcomeHeader,
+        cell: (row) => <OutcomeBadge outcome={row.outcome} />,
+        sortValue: (row) => t.outcome[row.outcome],
+      },
+      {
+        header: t.reason,
+        cell: (row) => (row.reason ? collectiveXReasonLabel(row.reason, locale) : '-'),
+        sortValue: (row) =>
+          row.reason ? `${collectiveXReasonLabel(row.reason, locale)} ${row.reason}` : '',
+      },
+    ],
+    [locale, t],
+  );
+
+  return (
+    <Card data-testid="collectivex-coverage">
+      <h2 className="text-lg font-semibold">{t.terminalCoverage}</h2>
+      <DataTable
+        data={coverage}
+        columns={columns}
+        testId="collectivex-coverage-table"
+        analyticsPrefix="collectivex_coverage_table"
+      />
+    </Card>
+  );
+}
diff --git a/packages/app/src/components/collectivex/data.test.ts b/packages/app/src/components/collectivex/data.test.ts
new file mode 100644
index 00000000..1cef8037
--- /dev/null
+++ b/packages/app/src/components/collectivex/data.test.ts
@@ -0,0 +1,225 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  chartPoints,
+  collectiveXColorKey,
+  collectiveXSeriesLabel,
+  collectiveXTopologyLabel,
+  fitAlphaBeta,
+  metricValue,
+  seriesMatchesSelection,
+  type CollectiveXSeriesSelection,
+} from './data';
+import type { CollectiveXPercentiles, CollectiveXSeries } from './types';
+import { makeCollectiveXDataset, makeCollectiveXSeries } from './test-fixture';
+
+const dataset = makeCollectiveXDataset();
+// series[0]: deepep-v2 EP8 scale-up (nvlink, single node).
+// series[1]: MoRI EP16 scale-out (xGMI scale-up + RDMA scale-out, two nodes).
+const [scaleUp, scaleOut] = dataset.series;
+
+describe('collectiveXTopologyLabel', () => {
+  it('shows only the scale-up transport when there is no scale-out fabric', () => {
+    expect(collectiveXTopologyLabel(scaleUp.system)).toBe(
+      '1x8 · domain 8 · nvlink · h200-nvlink-island',
+    );
+  });
+
+  it('joins scale-up and scale-out transports when a scale-out fabric is present', () => {
+    expect(collectiveXTopologyLabel(scaleOut.system)).toBe(
+      '2x8 · domain 8 · xgmi+rdma · mi355x-xgmi-rdma',
+    );
+  });
+});
+
+describe('collectiveXSeriesLabel', () => {
+  it('renders the varying identity axes of a series', () => {
+    expect(collectiveXSeriesLabel(scaleUp)).toBe(
+      'H200-DGXC · deepep-v2 · EP8 · normal · decode · bf16',
+    );
+  });
+
+  it('distinguishes the dispatch precision', () => {
+    expect(collectiveXSeriesLabel(makeCollectiveXSeries({ precision: 'fp8' }))).toBe(
+      'H200-DGXC · deepep-v2 · EP8 · normal · decode · fp8',
+    );
+  });
+
+  it('shows the selected EP degree, mode, and phase', () => {
+    expect(collectiveXSeriesLabel(scaleOut)).toContain('EP16 · normal · decode');
+  });
+});
+
+describe('collectiveXColorKey', () => {
+  it('assigns the same key to two series with identical configuration', () => {
+    const a = makeCollectiveXSeries({ variant: 'a' });
+    const b = makeCollectiveXSeries({ variant: 'b' });
+    // The color key is configuration-derived and excludes the series id.
+    expect(collectiveXColorKey(a)).toBe(collectiveXColorKey(b));
+  });
+
+  it('assigns distinct keys to series differing in EP degree', () => {
+    const a = makeCollectiveXSeries({ ep: 8 });
+    const b = makeCollectiveXSeries({ ep: 16 });
+    expect(collectiveXColorKey(a)).not.toBe(collectiveXColorKey(b));
+  });
+
+  it('assigns distinct keys to bf16 and fp8 series of one configuration', () => {
+    const bf16 = makeCollectiveXSeries();
+    const fp8 = makeCollectiveXSeries({ precision: 'fp8' });
+    expect(collectiveXColorKey(bf16)).not.toBe(collectiveXColorKey(fp8));
+  });
+
+  it('assigns distinct keys to normal and low-latency series of one configuration', () => {
+    const normal = makeCollectiveXSeries();
+    const lowLatency = makeCollectiveXSeries({ mode: 'low-latency' });
+    expect(collectiveXColorKey(normal)).not.toBe(collectiveXColorKey(lowLatency));
+  });
+
+  it('leads with the system vendor so getVendor places series in vendor hue zones', () => {
+    // The chart color system reads the first "_"-separated token to classify the
+    // vendor (NVIDIA greens, AMD reds), matching the InferenceX charts.
+    expect(collectiveXColorKey(scaleUp).split('_')[0]).toBe('nvidia');
+    const amd = makeCollectiveXSeries({ sku: 'mi355x', vendor: 'amd' });
+    expect(collectiveXColorKey(amd).split('_')[0]).toBe('amd');
+  });
+});
+
+describe('seriesMatchesSelection', () => {
+  const base: CollectiveXSeriesSelection = {
+    epSize: 8,
+    phase: 'decode',
+    mode: 'normal',
+    precision: 'bf16',
+  };
+
+  it('matches on EP size, phase, mode, and precision', () => {
+    expect(seriesMatchesSelection(scaleUp, base)).toBe(true);
+  });
+
+  it('rejects a series whose EP, phase, mode, or precision differs from the selection', () => {
+    expect(seriesMatchesSelection(scaleUp, { ...base, epSize: 16 })).toBe(false);
+    expect(seriesMatchesSelection(scaleUp, { ...base, phase: 'prefill' })).toBe(false);
+    expect(seriesMatchesSelection(scaleUp, { ...base, mode: 'low-latency' })).toBe(false);
+    expect(seriesMatchesSelection(scaleUp, { ...base, precision: 'fp8' })).toBe(false);
+  });
+});
+
+describe('metricValue', () => {
+  const point = scaleUp.points[0];
+
+  it('returns the latency percentile for the requested component', () => {
+    expect(metricValue(point, 'dispatch', 'p50', 'latency')).toBe(
+      point.components.dispatch?.latency_us.p50,
+    );
+  });
+
+  it('returns the roundtrip token rate only for the roundtrip operation', () => {
+    expect(metricValue(point, 'roundtrip', 'p50', 'tokens-per-second')).toBe(
+      point.roundtrip_token_rate_at_latency_percentile.p50,
+    );
+    expect(metricValue(point, 'dispatch', 'p50', 'tokens-per-second')).toBeNull();
+  });
+
+  it('returns the activation data rate', () => {
+    expect(metricValue(point, 'dispatch', 'p50', 'activation-rate')).toBeGreaterThan(0);
+  });
+
+  it('returns the per-GPU payload bandwidth distinct from the activation rate', () => {
+    const payload = metricValue(point, 'dispatch', 'p50', 'payload-rate');
+    const activation = metricValue(point, 'dispatch', 'p50', 'activation-rate');
+    expect(payload).toBeGreaterThan(0);
+    // Payload uses total_logical_bytes ÷ ep; activation uses aggregate activation bytes.
+    expect(payload).not.toBeCloseTo(activation as number, 1);
+  });
+
+  it('returns null for an unavailable component', () => {
+    const unavailable = makeCollectiveXSeries({ rows: [{ stageUnavailable: true }] }).points[0];
+    expect(metricValue(unavailable, 'stage', 'p50', 'latency')).toBeNull();
+  });
+});
+
+function pct(value: number): CollectiveXPercentiles {
+  return { p50: value, p90: value, p95: value, p99: value };
+}
+
+describe('fitAlphaBeta', () => {
+  // Build a series whose dispatch latency is exactly α + bytesPerGpu/β with
+  // α = 10 µs and β = 250 GB/s (per GPU), so the OLS must recover both. ep = 8,
+  // so aggregate payload_bytes = bytesPerGpu × 8 and fitAlphaBeta divides it back.
+  const EP = 8;
+  function fitSeries(): CollectiveXSeries {
+    const point = (bytesPerGpu: number) => {
+      const latency = 10 + bytesPerGpu / (250 * 1e3); // µs
+      const rate = (bytesPerGpu / latency) * 1e-3; // GB/s per GPU
+      const component = {
+        latency_us: pct(latency),
+        activation_data_rate_gbps_at_latency_percentile: pct(rate),
+        payload_data_rate_gbps_at_latency_percentile: pct(rate),
+        payload_bytes: bytesPerGpu * EP,
+      };
+      return {
+        tokens_per_rank: bytesPerGpu / 1e4,
+        global_tokens: bytesPerGpu / 1e3,
+        components: { dispatch: component, stage: null, combine: component, roundtrip: component },
+        roundtrip_token_rate_at_latency_percentile: pct(1),
+      };
+    };
+    return {
+      series_id: 'fit-series',
+      phase: 'decode',
+      mode: 'normal',
+      precision: 'bf16',
+      backend: 'nccl-ep',
+      system: {
+        ep_size: 8,
+        nodes: 1,
+        gpus_per_node: 8,
+        scale_up_domain: 8,
+        scale_up_transport: 'nvlink',
+        scale_out_transport: null,
+        topology_class: 'h100-nvlink-island',
+        sku: 'h100',
+        vendor: 'nvidia',
+      },
+      points: [point(1e6), point(2e6), point(3e6)],
+    };
+  }
+
+  it('recovers the fixed overhead (alpha) and per-GPU bandwidth (beta)', () => {
+    const fit = fitAlphaBeta(fitSeries(), 'dispatch');
+    expect(fit).not.toBeNull();
+    expect(fit?.alphaUs).toBeCloseTo(10, 3);
+    expect(fit?.betaGbps).toBeCloseTo(250, 3);
+    expect(fit?.pointCount).toBe(3);
+  });
+
+  it('returns null when the byte axis has no variance across the ladder', () => {
+    // The default fixture holds bytes constant across the ladder, so bytes/GPU
+    // reconstructs to a single value and there is no slope to fit.
+    expect(fitAlphaBeta(makeCollectiveXSeries(), 'dispatch')).toBeNull();
+  });
+});
+
+describe('chartPoints', () => {
+  it('emits one point per token row with populated axes', () => {
+    const points = chartPoints([scaleUp], 'dispatch', 'p50', 'latency');
+    expect(points).toHaveLength(scaleUp.points.length);
+    for (const point of points) {
+      expect(point.seriesId).toBe(scaleUp.series_id);
+      expect(point.colorKey).toBe(collectiveXColorKey(scaleUp));
+      expect(point.x).toBeGreaterThan(0);
+      expect(point.y).toBeGreaterThan(0);
+    }
+  });
+
+  it('drops points whose metric is unavailable', () => {
+    // Dispatch has no per-operation token rate, so tokens-per-second is null everywhere.
+    expect(chartPoints([scaleUp], 'dispatch', 'p50', 'tokens-per-second')).toHaveLength(0);
+  });
+
+  it('keeps roundtrip token-rate points', () => {
+    const points = chartPoints([scaleUp], 'roundtrip', 'p50', 'tokens-per-second');
+    expect(points).toHaveLength(scaleUp.points.length);
+  });
+});
diff --git a/packages/app/src/components/collectivex/data.ts b/packages/app/src/components/collectivex/data.ts
new file mode 100644
index 00000000..22276710
--- /dev/null
+++ b/packages/app/src/components/collectivex/data.ts
@@ -0,0 +1,162 @@
+import type {
+  CollectiveXChartPoint,
+  CollectiveXComponent,
+  CollectiveXMode,
+  CollectiveXOperation,
+  CollectiveXPercentile,
+  CollectiveXPhase,
+  CollectiveXPoint,
+  CollectiveXPrecision,
+  CollectiveXSeries,
+  CollectiveXYAxis,
+} from './types';
+
+export interface CollectiveXSeriesSelection {
+  epSize: number;
+  phase: CollectiveXPhase;
+  mode: CollectiveXMode;
+  precision: CollectiveXPrecision;
+}
+
+export function collectiveXTopologyLabel(
+  system: Pick<
+    CollectiveXSeries['system'],
+    | 'nodes'
+    | 'gpus_per_node'
+    | 'scale_up_domain'
+    | 'scale_up_transport'
+    | 'scale_out_transport'
+    | 'topology_class'
+  >,
+): string {
+  const transports = system.scale_out_transport
+    ? `${system.scale_up_transport}+${system.scale_out_transport}`
+    : system.scale_up_transport;
+  return `${system.nodes}x${system.gpus_per_node} · domain ${system.scale_up_domain} · ${transports} · ${system.topology_class}`;
+}
+
+export function collectiveXSeriesLabel(series: CollectiveXSeries): string {
+  return `${series.system.sku.toUpperCase()} · ${series.backend} · EP${series.system.ep_size} · ${series.mode} · ${series.phase} · ${series.precision}`;
+}
+
+export function collectiveXColorKey(series: CollectiveXSeries): string {
+  return `${series.system.vendor}_${series.system.sku}_${series.backend}_ep${series.system.ep_size}_${series.mode}_${series.phase}_${series.precision}`;
+}
+
+export function seriesMatchesSelection(
+  series: CollectiveXSeries,
+  selection: CollectiveXSeriesSelection,
+): boolean {
+  return (
+    series.system.ep_size === selection.epSize &&
+    series.phase === selection.phase &&
+    series.mode === selection.mode &&
+    series.precision === selection.precision
+  );
+}
+
+export function metricValue(
+  point: CollectiveXPoint,
+  operation: CollectiveXOperation,
+  percentile: CollectiveXPercentile,
+  yAxis: CollectiveXYAxis,
+): number | null {
+  const component: CollectiveXComponent | null = point.components[operation];
+  if (component === null) return null;
+  if (yAxis === 'latency') return component.latency_us[percentile];
+  if (yAxis === 'tokens-per-second') {
+    return operation === 'roundtrip'
+      ? point.roundtrip_token_rate_at_latency_percentile[percentile]
+      : null;
+  }
+  if (yAxis === 'payload-rate') {
+    return component.payload_data_rate_gbps_at_latency_percentile?.[percentile] ?? null;
+  }
+  return component.activation_data_rate_gbps_at_latency_percentile?.[percentile] ?? null;
+}
+
+export interface CollectiveXFit {
+  /** Fixed per-call overhead (µs): the launch/sync/rendezvous floor. */
+  alphaUs: number;
+  /** Per-GPU bandwidth term (GB/s): the slope of latency vs bytes. */
+  betaGbps: number;
+  /** Points that entered the fit. */
+  pointCount: number;
+}
+
+/** Ordinary least squares; returns [intercept, slope]. */
+function ols(xs: number[], ys: number[]): [number, number] {
+  const n = xs.length;
+  const meanX = xs.reduce((a, b) => a + b, 0) / n;
+  const meanY = ys.reduce((a, b) => a + b, 0) / n;
+  let sxx = 0;
+  let sxy = 0;
+  for (let i = 0; i < n; i++) {
+    sxx += (xs[i] - meanX) ** 2;
+    sxy += (xs[i] - meanX) * (ys[i] - meanY);
+  }
+  const slope = sxy / sxx;
+  return [meanY - slope * meanX, slope];
+}
+
+/**
+ * Separate the bandwidth term (β) from the fixed overhead (α) for one operation
+ * across a series' token ladder: latency(bytes) ≈ α + bytes/β. Regresses the
+ * per-point latency against the per-GPU payload bytes (raw `payload_bytes` ÷
+ * ep_size), so β lands in the same per-GPU GB/s units as the payload-rate axis
+ * and α is the fixed overhead in µs. p50 by default (p99 carries tail noise).
+ * Mirrors experimental/CollectiveX/bandwidth.py. Returns null when fewer than
+ * three points, a degenerate (near-zero-variance) byte axis — e.g. a constant
+ * payload across the ladder — or a non-positive slope leaves no bandwidth term.
+ */
+export function fitAlphaBeta(
+  series: CollectiveXSeries,
+  operation: CollectiveXOperation,
+  percentile: CollectiveXPercentile = 'p50',
+): CollectiveXFit | null {
+  const ep = Math.max(1, series.system.ep_size);
+  const bytesPerGpu: number[] = [];
+  const latencies: number[] = [];
+  for (const point of series.points) {
+    const component = point.components[operation];
+    if (component === null || component.payload_bytes === null) continue;
+    const latency = component.latency_us[percentile];
+    if (latency <= 0) continue;
+    bytesPerGpu.push(component.payload_bytes / ep);
+    latencies.push(latency);
+  }
+  if (bytesPerGpu.length < 3) return null;
+  // Reject a near-constant byte axis (constant payload across the ladder): a
+  // relative spread this small carries no real slope, only numeric noise.
+  const min = Math.min(...bytesPerGpu);
+  const max = Math.max(...bytesPerGpu);
+  if (max - min <= 1e-9 * max) return null;
+  const [alphaUs, slopeUsPerByte] = ols(bytesPerGpu, latencies);
+  if (slopeUsPerByte <= 0) return null;
+  return { alphaUs, betaGbps: 1e-3 / slopeUsPerByte, pointCount: bytesPerGpu.length };
+}
+
+export function chartPoints(
+  series: CollectiveXSeries[],
+  operation: CollectiveXOperation,
+  percentile: CollectiveXPercentile,
+  yAxis: CollectiveXYAxis,
+): CollectiveXChartPoint[] {
+  return series.flatMap((item) =>
+    item.points.flatMap((point) => {
+      const x = point.tokens_per_rank;
+      const y = metricValue(point, operation, percentile, yAxis);
+      if (!Number.isFinite(x) || x <= 0 || y === null || y <= 0 || !Number.isFinite(y)) return [];
+      return [
+        {
+          seriesId: item.series_id,
+          seriesLabel: collectiveXSeriesLabel(item),
+          colorKey: collectiveXColorKey(item),
+          x,
+          y,
+          point,
+        },
+      ];
+    }),
+  );
+}
diff --git a/packages/app/src/components/collectivex/test-fixture.ts b/packages/app/src/components/collectivex/test-fixture.ts
new file mode 100644
index 00000000..8551afa8
--- /dev/null
+++ b/packages/app/src/components/collectivex/test-fixture.ts
@@ -0,0 +1,7 @@
+/**
+ * Re-export of the CollectiveX contract fixture builders, which live next to
+ * the shared reader in the db package. Kept at this path so component tests
+ * and cypress specs import fixtures the same way as the rest of this folder.
+ */
+
+export * from '@semianalysisai/inferencex-db/collectivex/test-fixture';
diff --git a/packages/app/src/components/collectivex/types.ts b/packages/app/src/components/collectivex/types.ts
new file mode 100644
index 00000000..1f15832d
--- /dev/null
+++ b/packages/app/src/components/collectivex/types.ts
@@ -0,0 +1,26 @@
+/**
+ * UI-side CollectiveX types. The neutral contract (dataset/series/coverage
+ * shapes, version constants, reader) lives in the db package so the ingest
+ * script and this frontend share one source of truth — see
+ * `packages/db/src/collectivex/`.
+ */
+
+import type {
+  CollectiveXPoint,
+  CollectiveXVersion,
+} from '@semianalysisai/inferencex-db/collectivex/types';
+
+export * from '@semianalysisai/inferencex-db/collectivex/types';
+
+export const collectiveXVersionLabel = (version: CollectiveXVersion): string => `V${version}`;
+
+export type CollectiveXYAxis = 'latency' | 'tokens-per-second' | 'activation-rate' | 'payload-rate';
+
+export interface CollectiveXChartPoint {
+  seriesId: string;
+  seriesLabel: string;
+  colorKey: string;
+  x: number;
+  y: number;
+  point: CollectiveXPoint;
+}
diff --git a/packages/app/src/components/dashboard-shell.tsx b/packages/app/src/components/dashboard-shell.tsx
index 17eb1386..d44ff843 100644
--- a/packages/app/src/components/dashboard-shell.tsx
+++ b/packages/app/src/components/dashboard-shell.tsx
@@ -4,8 +4,19 @@ import { GlobalFilterProvider } from '@/components/GlobalFilterContext';
 import { NudgeEngine } from '@/components/nudge-engine';
 import { TabNav } from '@/components/tab-nav';
 import { UnofficialRunProvider } from '@/components/unofficial-run-provider';
+import { usePathname } from 'next/navigation';
 
 export function DashboardShell({ children }: { children: React.ReactNode }) {
+  const pathname = usePathname();
+  const content = (
+    <main className="relative">
+      <div className="container mx-auto px-4 lg:px-8 flex flex-col gap-4">
+        <TabNav />
+        {children}
+      </div>
+    </main>
+  );
+  if (pathname === '/collectivex' || pathname === '/zh/collectivex') return content;
   return (
     <>
       <NudgeEngine scope="dashboard" />
diff --git a/packages/app/src/components/header/header.tsx b/packages/app/src/components/header/header.tsx
index 021d5795..9a8507d4 100644
--- a/packages/app/src/components/header/header.tsx
+++ b/packages/app/src/components/header/header.tsx
@@ -25,6 +25,7 @@ const DASHBOARD_TABS = [
   '/reliability',
   '/gpu-specs',
   '/gpu-metrics',
+  '/collectivex',
   '/submissions',
   '/current-inferencex-image',
 ];
diff --git a/packages/app/src/components/tab-nav.tsx b/packages/app/src/components/tab-nav.tsx
index ec99db5f..edc3e126 100644
--- a/packages/app/src/components/tab-nav.tsx
+++ b/packages/app/src/components/tab-nav.tsx
@@ -32,6 +32,7 @@ const VISIBLE_TABS = [
   { href: '/historical', label: 'Historical Trends', testId: 'tab-trigger-historical' },
   { href: '/calculator', label: 'TCO Calculator', testId: 'tab-trigger-calculator' },
   { href: '/gpu-specs', label: 'GPU Specs', testId: 'tab-trigger-gpu-specs' },
+  { href: '/collectivex', label: 'CollectiveX', testId: 'tab-trigger-collectivex' },
   { href: '/submissions', label: 'Submissions', testId: 'tab-trigger-submissions' },
 ] as const;
 
diff --git a/packages/app/src/components/ui/chart-legend-item.tsx b/packages/app/src/components/ui/chart-legend-item.tsx
index 6b7e9d6d..a3d10b31 100644
--- a/packages/app/src/components/ui/chart-legend-item.tsx
+++ b/packages/app/src/components/ui/chart-legend-item.tsx
@@ -33,12 +33,14 @@ export interface CommonLegendItemProps {
   isLegendExpanded?: boolean; // Whether the legend is expanded to show full text
   sidebarMode?: boolean; // Use sidebar-style visual feedback (line-through + faded dot)
   onRemove?: (name: string) => void;
+  hideAriaLabel?: string;
   /**
    * When provided, renders a small table icon that opens a per-series points
    * table (all data points for this hardware/framework series). Only the
    * inference tab's legend passes this — other tabs get no icon.
    */
   onShowPoints?: (name: string) => void;
+  showPointsAriaLabel?: string;
 }
 
 const ChartLegendItem: React.FC<CommonLegendItemProps> = ({
@@ -57,6 +59,8 @@ const ChartLegendItem: React.FC<CommonLegendItemProps> = ({
   sidebarMode = false,
   onRemove,
   onShowPoints,
+  hideAriaLabel,
+  showPointsAriaLabel,
 }) => {
   const locale = useLocale();
   const t = STRINGS[locale];
@@ -105,7 +109,7 @@ const ChartLegendItem: React.FC<CommonLegendItemProps> = ({
                 onRemove!(hw || name);
               }}
               className="absolute inset-0 inline-flex items-center justify-center opacity-0 group-hover/item:opacity-100"
-              aria-label={t.hide(label)}
+              aria-label={hideAriaLabel ?? t.hide(label)}
               title={t.hide(label)}
             >
               <X size={14} strokeWidth={4} className="text-foreground" />
@@ -139,7 +143,7 @@ const ChartLegendItem: React.FC<CommonLegendItemProps> = ({
         <button
           type="button"
           data-testid={`legend-points-${hw || name}`}
-          aria-label={t.showAllPoints(label)}
+          aria-label={showPointsAriaLabel ?? t.showAllPoints(label)}
           onClick={() => onShowPoints(hw || name)}
           // Reduced opacity at rest (still visible/tappable on touch), full on
           // row hover or keyboard focus. ml-auto pins the icon to the row's
diff --git a/packages/app/src/components/ui/chart-legend.tsx b/packages/app/src/components/ui/chart-legend.tsx
index 9c14c49f..957643b3 100644
--- a/packages/app/src/components/ui/chart-legend.tsx
+++ b/packages/app/src/components/ui/chart-legend.tsx
@@ -41,9 +41,13 @@ const STRINGS = {
     collapse: 'Collapse',
     expand: 'Expand',
     searchPlaceholder: 'Search...',
+    searchAria: 'Search legend',
     clearSearch: 'Clear search',
+    moreInfo: (label: string) => `More info about ${label}`,
     collapseLegend: 'Collapse legend',
     expandLegend: 'Expand legend',
+    hide: (label: string) => `Hide ${label}`,
+    showPoints: (label: string) => `Show all ${label} data points`,
     atomFootnote:
       'The ATOM engine is promising, however it has yet to serve production tokens. It is still in its infant stage.',
   },
@@ -52,9 +56,13 @@ const STRINGS = {
     collapse: '收起',
     expand: '展开',
     searchPlaceholder: '搜索…',
+    searchAria: '搜索图例',
     clearSearch: '清除搜索',
+    moreInfo: (label: string) => `查看${label}的更多信息`,
     collapseLegend: '收起图例',
     expandLegend: '展开图例',
+    hide: (label: string) => `隐藏${label}`,
+    showPoints: (label: string) => `显示${label}的全部数据点`,
     atomFootnote: 'ATOM 引擎前景可期，但尚未用于生产环境 token 服务，仍处于早期阶段。',
   },
 } as const;
@@ -270,6 +278,7 @@ export default function ChartLegend({
             onChange={(e) => setSearchQuery(e.target.value)}
             onBlur={trackSearchOnBlur}
             placeholder={t.searchPlaceholder}
+            aria-label={t.searchAria}
             className="w-full px-2 py-1 pr-6 rounded-md border border-border bg-background text-foreground text-xs placeholder:text-muted-foreground focus:outline-none focus:ring-1 focus:ring-sky-500/50 focus:border-sky-500/50"
           />
           {searchQuery && (
@@ -316,7 +325,7 @@ export default function ChartLegend({
                     <button
                       type="button"
                       data-testid={`${sw.id}-info`}
-                      aria-label={`More info about ${sw.label}`}
+                      aria-label={t.moreInfo(sw.label)}
                       className="text-muted-foreground hover:text-foreground cursor-help -m-1.5 p-1.5 inline-flex items-center"
                     >
                       <Info size={14} />
@@ -455,6 +464,8 @@ export default function ChartLegend({
         onHoverEnd={onItemHoverEnd}
         onRemove={effectiveRemove}
         onShowPoints={item.onShowPoints}
+        hideAriaLabel={t.hide(item.label)}
+        showPointsAriaLabel={t.showPoints(item.label)}
         asFragment
         isLegendExpanded={effectiveExpanded}
         sidebarMode={isSidebar}
@@ -551,6 +562,8 @@ export default function ChartLegend({
                         onHoverEnd={onItemHoverEnd}
                         onRemove={effectiveRemove}
                         onShowPoints={item.onShowPoints}
+                        hideAriaLabel={t.hide(item.label)}
+                        showPointsAriaLabel={t.showPoints(item.label)}
                         sidebarMode={isSidebar}
                         asFragment
                       />
diff --git a/packages/app/src/components/ui/data-table.tsx b/packages/app/src/components/ui/data-table.tsx
index 955847ad..5815541a 100644
--- a/packages/app/src/components/ui/data-table.tsx
+++ b/packages/app/src/components/ui/data-table.tsx
@@ -12,7 +12,6 @@ import {
 } from 'lucide-react';
 
 import { track } from '@/lib/analytics';
-import { useLocale } from '@/lib/use-locale';
 import {
   Select,
   SelectContent,
@@ -20,35 +19,7 @@ import {
   SelectTrigger,
   SelectValue,
 } from '@/components/ui/select';
-
-const STRINGS = {
-  en: {
-    noData: 'No data available for the current filters.',
-    searchPlaceholder: 'Search...',
-    searchLabel: 'Search table',
-    clearSearch: 'Clear search',
-    noResults: (q: string) => `No results match "${q}"`,
-    perPage: 'per page',
-    rowsPerPage: 'Rows per page',
-    prevPage: 'Previous page',
-    nextPage: 'Next page',
-    of: 'of',
-    filteredFrom: (total: number) => `(filtered from ${total})`,
-  },
-  zh: {
-    noData: '当前筛选条件下无可用数据。',
-    searchPlaceholder: '搜索…',
-    searchLabel: '搜索表格',
-    clearSearch: '清除搜索',
-    noResults: (q: string) => `无匹配"${q}"的结果`,
-    perPage: '每页',
-    rowsPerPage: '每页行数',
-    prevPage: '上一页',
-    nextPage: '下一页',
-    of: '/',
-    filteredFrom: (total: number) => `（从 ${total} 条中筛选）`,
-  },
-} as const;
+import { useLocale } from '@/lib/use-locale';
 
 export interface DataTableColumn<T> {
   /** Column header text. */
@@ -97,6 +68,37 @@ const SORT_ICON = {
   none: <ArrowUpDown className="inline size-3 opacity-30" />,
 };
 
+const STRINGS = {
+  en: {
+    noData: 'No data available for the current filters.',
+    search: 'Search...',
+    searchAria: 'Search table',
+    clearSearch: 'Clear search',
+    noResults: 'No results match',
+    of: 'of',
+    filteredFrom: 'filtered from',
+    rowUnit: 'rows',
+    rowsPerPage: 'Rows per page',
+    perPage: 'per page',
+    previousPage: 'Previous page',
+    nextPage: 'Next page',
+  },
+  zh: {
+    noData: '当前筛选条件下没有可用数据。',
+    search: '搜索…',
+    searchAria: '搜索表格',
+    clearSearch: '清除搜索',
+    noResults: '没有结果匹配',
+    of: '共',
+    filteredFrom: '筛选自',
+    rowUnit: '行',
+    rowsPerPage: '每页行数',
+    perPage: '每页',
+    previousPage: '上一页',
+    nextPage: '下一页',
+  },
+} as const;
+
 export function DataTable<T>({
   data,
   columns,
@@ -170,7 +172,7 @@ export function DataTable<T>({
   }
 
   return (
-    <div data-testid={testId} className="mt-3">
+    <div data-testid={testId} className="mt-3 min-w-0 w-full max-w-full">
       {/* Search */}
       <div className="mb-3 max-w-xs relative">
         <Search className="absolute left-2.5 top-1/2 -translate-y-1/2 size-3.5 text-muted-foreground" />
@@ -182,9 +184,9 @@ export function DataTable<T>({
             setSearch(e.target.value);
             setPage(0);
           }}
-          placeholder={t.searchPlaceholder}
+          placeholder={t.search}
           className="w-full h-7 pl-8 pr-7 text-xs bg-transparent border border-border rounded-md focus:outline-none focus:ring-1 focus:ring-ring"
-          aria-label={t.searchLabel}
+          aria-label={t.searchAria}
         />
         {search && (
           <button
@@ -260,7 +262,7 @@ export function DataTable<T>({
                   colSpan={columns.length}
                   className="py-8 text-center text-sm text-muted-foreground"
                 >
-                  {t.noResults(search)}
+                  {t.noResults} &quot;{search}&quot;
                 </td>
               </tr>
             ) : (
@@ -282,38 +284,55 @@ export function DataTable<T>({
       </div>
 
       {/* Pagination controls */}
-      <div className="flex items-center justify-between mt-3 text-xs text-muted-foreground">
-        <div className="flex items-center gap-2">
-          <span>
-            {sorted.length === 0
-              ? '0'
-              : `${safePage * pageSize + 1}–${Math.min((safePage + 1) * pageSize, sorted.length)}`}{' '}
-            {t.of} {sorted.length}
-            {search && ` ${t.filteredFrom(data.length)}`}
+      <div className="flex flex-wrap items-center justify-between gap-2 mt-3 text-xs text-muted-foreground">
+        <div className="flex flex-wrap items-center gap-2">
+          <span data-testid="data-table-pagination-summary">
+            {locale === 'zh' ? (
+              <>
+                {sorted.length === 0
+                  ? `共 0 ${t.rowUnit}`
+                  : `第 ${safePage * pageSize + 1}–${Math.min((safePage + 1) * pageSize, sorted.length)} ${t.rowUnit}，共 ${sorted.length} ${t.rowUnit}`}
+                {search && `（${t.filteredFrom} ${data.length} ${t.rowUnit}）`}
+              </>
+            ) : (
+              <>
+                {sorted.length === 0
+                  ? '0'
+                  : `${safePage * pageSize + 1}–${Math.min((safePage + 1) * pageSize, sorted.length)}`}{' '}
+                {t.of} {sorted.length}
+                {search && ` (${t.filteredFrom} ${data.length})`}
+              </>
+            )}
           </span>
-          <Select
-            value={String(pageSize)}
-            onValueChange={(v) => {
-              const size = Number(v);
-              setPageSize(size);
-              setPage(0);
-              track(`${analyticsPrefix}_page_size_changed`, { size });
-            }}
+          <div
+            data-testid="data-table-page-size"
+            className="flex shrink-0 items-center gap-1 whitespace-nowrap"
           >
-            <SelectTrigger className="h-6 w-auto gap-1 px-2 text-xs" aria-label={t.rowsPerPage}>
-              <SelectValue />
-            </SelectTrigger>
-            <SelectContent>
-              {PAGE_SIZE_OPTIONS.map((size) => (
-                <SelectItem key={size} value={String(size)}>
-                  {size}
-                </SelectItem>
-              ))}
-            </SelectContent>
-          </Select>
-          <span>{t.perPage}</span>
+            {locale === 'zh' && <span>{t.perPage}</span>}
+            <Select
+              value={String(pageSize)}
+              onValueChange={(v) => {
+                const size = Number(v);
+                setPageSize(size);
+                setPage(0);
+                track(`${analyticsPrefix}_page_size_changed`, { size });
+              }}
+            >
+              <SelectTrigger className="h-6 w-auto gap-1 px-2 text-xs" aria-label={t.rowsPerPage}>
+                <SelectValue />
+              </SelectTrigger>
+              <SelectContent>
+                {PAGE_SIZE_OPTIONS.map((size) => (
+                  <SelectItem key={size} value={String(size)}>
+                    {size}
+                  </SelectItem>
+                ))}
+              </SelectContent>
+            </Select>
+            <span>{locale === 'zh' ? t.rowUnit : t.perPage}</span>
+          </div>
         </div>
-        <div className="flex items-center gap-1">
+        <div className="ml-auto flex shrink-0 items-center gap-1">
           <button
             type="button"
             onClick={() => {
@@ -322,7 +341,7 @@ export function DataTable<T>({
             }}
             disabled={safePage === 0}
             className="p-1 rounded hover:bg-muted disabled:opacity-30 disabled:cursor-not-allowed transition-colors"
-            aria-label={t.prevPage}
+            aria-label={t.previousPage}
           >
             <ChevronLeft className="size-4" />
           </button>
diff --git a/packages/app/src/components/ui/searchable-select.test.ts b/packages/app/src/components/ui/searchable-select.test.ts
index 70b2aa8e..275774f3 100644
--- a/packages/app/src/components/ui/searchable-select.test.ts
+++ b/packages/app/src/components/ui/searchable-select.test.ts
@@ -56,7 +56,7 @@ function openMenu() {
 // internal value tracker thinks nothing changed. Use the native HTMLInputElement
 // setter so React picks up the change and fires onChange in jsdom.
 function setSearchValue(value: string) {
-  const input = container.querySelector('input[placeholder="Search..."]') as HTMLInputElement;
+  const input = document.body.querySelector('input[type="text"]') as HTMLInputElement;
   const nativeSetter = Object.getOwnPropertyDescriptor(
     window.HTMLInputElement.prototype,
     'value',
@@ -83,7 +83,7 @@ describe('SearchableSelect', () => {
   it('shows all groups and options when opened', () => {
     render();
     openMenu();
-    const items = container.querySelectorAll('[data-slot="select-item"]');
+    const items = document.body.querySelectorAll('[data-slot="select-item"]');
     expect(items).toHaveLength(3);
   });
 
@@ -91,7 +91,7 @@ describe('SearchableSelect', () => {
     render();
     openMenu();
     setSearchValue('input');
-    const items = container.querySelectorAll('[data-slot="select-item"]');
+    const items = document.body.querySelectorAll('[data-slot="select-item"]');
     expect(items).toHaveLength(1);
     expect(items[0]?.textContent).toContain('Input Token Throughput per GPU');
   });
@@ -100,7 +100,7 @@ describe('SearchableSelect', () => {
     render();
     openMenu();
     setSearchValue('cost');
-    const items = container.querySelectorAll('[data-slot="select-item"]');
+    const items = document.body.querySelectorAll('[data-slot="select-item"]');
     expect(items).toHaveLength(1);
     expect(items[0]?.textContent).toContain('Cost per Million Total Tokens (Hyperscaler)');
   });
@@ -109,22 +109,84 @@ describe('SearchableSelect', () => {
     render();
     openMenu();
     setSearchValue('zzzzz');
-    const items = container.querySelectorAll('[data-slot="select-item"]');
+    const items = document.body.querySelectorAll('[data-slot="select-item"]');
     expect(items).toHaveLength(0);
-    expect(container.textContent).toContain('No results');
+    expect(document.body.textContent).toContain('No results');
+  });
+
+  it('uses localized search controls and empty state labels', () => {
+    render({
+      searchPlaceholder: '搜索队列...',
+      searchAriaLabel: '搜索 CollectiveX 队列',
+      clearSearchLabel: '清除队列搜索',
+      noResultsLabel: '无匹配队列',
+    });
+    openMenu();
+    const input = document.body.querySelector('input[type="text"]') as HTMLInputElement;
+    expect(input.placeholder).toBe('搜索队列...');
+    expect(input.getAttribute('aria-label')).toBe('搜索 CollectiveX 队列');
+    setSearchValue('zzzzz');
+    expect(document.body.textContent).toContain('无匹配队列');
+    expect(document.body.querySelector('button[aria-label="清除队列搜索"]')).not.toBeNull();
+  });
+
+  it('filters the canonical 280-cohort publication scale without truncating it', () => {
+    const groups = [
+      ['Library', 76],
+      ['Platform', 76],
+      ['Reference system', 12],
+      ['Routing', 116],
+    ].map(([label, size]) => ({
+      label: `${label} comparisons`,
+      options: Array.from({ length: Number(size) }, (_, index) => ({
+        value: `${label}-cohort-${index}`,
+        label: `${label} cohort ${index}`,
+      })),
+    }));
+    render({ groups, value: 'Library-cohort-0' });
+    openMenu();
+    expect(document.body.querySelectorAll('[data-slot="select-item"]')).toHaveLength(280);
+    setSearchValue('Routing comparisons');
+    expect(document.body.querySelectorAll('[data-slot="select-item"]')).toHaveLength(116);
+    setSearchValue('Routing cohort 115');
+    const items = document.body.querySelectorAll('[data-slot="select-item"]');
+    expect(items).toHaveLength(1);
+    expect(items[0]?.textContent).toContain('Routing cohort 115');
   });
 
   it('invokes onValueChange and closes the menu when an option is clicked', () => {
     const handle = vi.fn();
     render({ onValueChange: handle });
     openMenu();
-    const items = container.querySelectorAll('[data-slot="select-item"]');
+    const items = document.body.querySelectorAll('[data-slot="select-item"]');
     const target = [...items].find((el) =>
       el.textContent?.includes('Input Token Throughput per GPU'),
     ) as HTMLDivElement;
     act(() => target.click());
     expect(handle).toHaveBeenCalledExactlyOnceWith('y_inputTputPerGpu');
     // Menu closed → no select-item visible
-    expect(container.querySelectorAll('[data-slot="select-item"]')).toHaveLength(0);
+    expect(document.body.querySelectorAll('[data-slot="select-item"]')).toHaveLength(0);
+  });
+
+  it('moves through options and selects from the keyboard', () => {
+    const handle = vi.fn();
+    render({ onValueChange: handle });
+    openMenu();
+    const input = document.body.querySelector('input[type="text"]') as HTMLInputElement;
+    const options = document.body.querySelectorAll<HTMLElement>('[data-slot="select-item"]');
+    expect([...options].every((item) => item.tabIndex === -1)).toBe(true);
+    act(() =>
+      input.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowDown', bubbles: true })),
+    );
+    expect(document.activeElement).toBe(options[0]);
+    act(() =>
+      options[0]?.dispatchEvent(new KeyboardEvent('keydown', { key: 'ArrowDown', bubbles: true })),
+    );
+    expect(document.activeElement).toBe(options[1]);
+    act(() =>
+      options[1]?.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter', bubbles: true })),
+    );
+    expect(handle).toHaveBeenCalledExactlyOnceWith('y_inputTputPerGpu');
+    expect(document.body.querySelectorAll('[data-slot="select-item"]')).toHaveLength(0);
   });
 });
diff --git a/packages/app/src/components/ui/searchable-select.tsx b/packages/app/src/components/ui/searchable-select.tsx
index 3b1a5d25..1c7d80ad 100644
--- a/packages/app/src/components/ui/searchable-select.tsx
+++ b/packages/app/src/components/ui/searchable-select.tsx
@@ -3,6 +3,7 @@
 import { CheckIcon, ChevronDownIcon, SearchIcon, XIcon } from 'lucide-react';
 import * as React from 'react';
 
+import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
 import { track } from '@/lib/analytics';
 import { cn } from '@/lib/utils';
 
@@ -26,11 +27,12 @@ interface SearchableSelectProps {
   triggerTestId?: string;
   disabled?: boolean;
   searchable?: boolean;
-  /** Analytics event prefix, e.g. "yaxis_metric" → "yaxis_metric_searched" */
-  trackPrefix?: string;
   searchPlaceholder?: string;
-  noResultsLabel?: string;
+  searchAriaLabel?: string;
   clearSearchLabel?: string;
+  noResultsLabel?: string;
+  /** Analytics event prefix, e.g. "yaxis_metric" → "yaxis_metric_searched" */
+  trackPrefix?: string;
 }
 
 export function SearchableSelect({
@@ -43,10 +45,11 @@ export function SearchableSelect({
   triggerTestId,
   disabled = false,
   searchable = true,
-  trackPrefix,
   searchPlaceholder = 'Search...',
-  noResultsLabel = 'No results',
+  searchAriaLabel = 'Search options',
   clearSearchLabel = 'Clear search',
+  noResultsLabel = 'No results',
+  trackPrefix,
 }: SearchableSelectProps) {
   const [isOpen, setIsOpen] = React.useState(false);
   const [search, setSearch] = React.useState('');
@@ -56,8 +59,8 @@ export function SearchableSelect({
   // resolve client-side, so SSR would otherwise lock in the default label and
   // leave it stale after hydration.
   const [mounted, setMounted] = React.useState(false);
-  const containerRef = React.useRef<HTMLDivElement>(null);
   const searchRef = React.useRef<HTMLInputElement>(null);
+  const listboxRef = React.useRef<HTMLDivElement>(null);
   const searchUsedRef = React.useRef(false);
 
   React.useEffect(() => {
@@ -65,33 +68,13 @@ export function SearchableSelect({
   }, []);
 
   React.useEffect(() => {
-    const handleClickOutside = (event: MouseEvent) => {
-      if (containerRef.current && !containerRef.current.contains(event.target as Node)) {
-        setIsOpen(false);
-      }
-    };
-    const handleKeyDown = (event: KeyboardEvent) => {
-      if (event.key === 'Escape') {
-        event.stopPropagation();
-        setIsOpen(false);
-      }
-    };
-
-    if (isOpen) {
-      document.addEventListener('mousedown', handleClickOutside);
-      document.addEventListener('keydown', handleKeyDown);
-      searchRef.current?.focus();
-    } else {
+    if (!isOpen) {
       if (searchUsedRef.current && trackPrefix) {
         track(`${trackPrefix}_searched`, { query: search });
         searchUsedRef.current = false;
       }
       setSearch('');
     }
-    return () => {
-      document.removeEventListener('mousedown', handleClickOutside);
-      document.removeEventListener('keydown', handleKeyDown);
-    };
   }, [isOpen, search, trackPrefix]);
 
   const filteredGroups = React.useMemo(() => {
@@ -120,49 +103,79 @@ export function SearchableSelect({
     onValueChange(optionValue);
     setIsOpen(false);
   };
+  const focusOption = (index: number) => {
+    const options = listboxRef.current?.querySelectorAll<HTMLElement>('[role="option"]');
+    options?.[Math.max(0, Math.min(index, options.length - 1))]?.focus();
+  };
+  const handleOptionKeyDown = (event: React.KeyboardEvent<HTMLDivElement>, optionValue: string) => {
+    if (event.key === 'Enter' || event.key === ' ') {
+      event.preventDefault();
+      handleSelect(optionValue);
+      return;
+    }
+    const options = [...(listboxRef.current?.querySelectorAll('[role="option"]') ?? [])];
+    const current = options.indexOf(event.currentTarget);
+    const target =
+      event.key === 'ArrowDown'
+        ? current + 1
+        : event.key === 'ArrowUp'
+          ? current - 1
+          : event.key === 'Home'
+            ? 0
+            : event.key === 'End'
+              ? options.length - 1
+              : null;
+    if (target !== null) {
+      event.preventDefault();
+      focusOption(target);
+    }
+  };
 
   return (
-    <div ref={containerRef} className="relative">
-      <button
-        type="button"
-        id={triggerId}
-        data-testid={triggerTestId}
-        data-slot="select-trigger"
-        data-size="default"
-        role="combobox"
-        aria-expanded={isOpen}
-        aria-haspopup="listbox"
-        aria-controls={listboxId}
-        onClick={() => !disabled && setIsOpen(!isOpen)}
-        disabled={disabled}
-        className={cn(
-          "border-input data-placeholder:text-muted-foreground [&_svg:not([class*='text-'])]:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/50 dark:bg-input/90 dark:hover:bg-input/50 flex w-full items-center justify-between gap-2 rounded-md border bg-transparent px-3 py-2 text-sm shadow-xs transition-[color,box-shadow] outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50 min-h-9",
-          className,
-        )}
-      >
-        <span
-          className={cn(
-            'flex-1 text-left truncate',
-            (!mounted || !selectedLabel) && 'text-muted-foreground',
-          )}
-        >
-          {mounted ? (selectedLabel ?? placeholder) : placeholder}
-        </span>
-        <ChevronDownIcon
-          className={cn(
-            'size-4 opacity-90 shrink-0 transition-transform',
-            isOpen && 'transform rotate-180',
-          )}
-        />
-      </button>
-
-      {isOpen && (
-        <div
+    <Popover open={isOpen} onOpenChange={(open) => !disabled && setIsOpen(open)}>
+      <div className="relative">
+        <PopoverTrigger asChild>
+          <button
+            type="button"
+            id={triggerId}
+            data-testid={triggerTestId}
+            data-slot="select-trigger"
+            data-size="default"
+            role="combobox"
+            aria-expanded={isOpen}
+            aria-haspopup="listbox"
+            aria-controls={listboxId}
+            disabled={disabled}
+            className={cn(
+              "border-input data-placeholder:text-muted-foreground [&_svg:not([class*='text-'])]:text-muted-foreground focus-visible:border-ring focus-visible:ring-ring/50 dark:bg-input/90 dark:hover:bg-input/50 flex w-full items-center justify-between gap-2 rounded-md border bg-transparent px-3 py-2 text-sm shadow-xs transition-[color,box-shadow] outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50 min-h-9",
+              className,
+            )}
+          >
+            <span
+              className={cn(
+                'flex-1 text-left truncate',
+                (!mounted || !selectedLabel) && 'text-muted-foreground',
+              )}
+            >
+              {mounted ? (selectedLabel ?? placeholder) : placeholder}
+            </span>
+            <ChevronDownIcon
+              className={cn(
+                'size-4 opacity-90 shrink-0 transition-transform',
+                isOpen && 'transform rotate-180',
+              )}
+            />
+          </button>
+        </PopoverTrigger>
+        <PopoverContent
           data-slot="select-content"
-          // No enter animations: tailwindcss-animate sets opacity/scale to 0 at
-          // the start of the animation which makes Cypress treat the search
-          // input as not visible and fail cy.type().
-          className="bg-popover text-popover-foreground absolute z-50 mt-1 w-full origin-top overflow-hidden rounded-md border shadow-md"
+          align="start"
+          sideOffset={4}
+          onOpenAutoFocus={(event) => {
+            event.preventDefault();
+            searchRef.current?.focus();
+          }}
+          className="z-[100] w-[var(--radix-popover-trigger-width)] overflow-hidden p-0 data-[state=open]:animate-none data-[state=closed]:animate-none"
         >
           {/* Search header lives outside the scrollable region so it never picks up
            * `sticky` → `position: fixed` resolution that puts it behind the page
@@ -178,7 +191,17 @@ export function SearchableSelect({
                   setSearch(e.target.value);
                   if (e.target.value) searchUsedRef.current = true;
                 }}
+                onKeyDown={(event) => {
+                  if (event.key === 'ArrowDown') {
+                    event.preventDefault();
+                    focusOption(0);
+                  } else if (event.key === 'ArrowUp') {
+                    event.preventDefault();
+                    focusOption(Number.MAX_SAFE_INTEGER);
+                  }
+                }}
                 placeholder={searchPlaceholder}
+                aria-label={searchAriaLabel}
                 className="w-full bg-transparent py-1.5 text-sm outline-none placeholder:text-muted-foreground"
               />
               {search && (
@@ -197,6 +220,7 @@ export function SearchableSelect({
             </div>
           )}
           <div
+            ref={listboxRef}
             id={listboxId}
             role="listbox"
             className="p-1 max-h-72 overflow-y-auto custom-scrollbar"
@@ -217,10 +241,12 @@ export function SearchableSelect({
                     <div
                       key={option.value}
                       role="option"
+                      tabIndex={-1}
                       aria-selected={isSelected}
                       data-slot="select-item"
                       data-value={option.value}
                       onClick={() => handleSelect(option.value)}
+                      onKeyDown={(event) => handleOptionKeyDown(event, option.value)}
                       className={cn(
                         "focus:bg-accent focus:text-accent-foreground [&_svg:not([class*='text-'])]:text-muted-foreground relative flex w-full cursor-pointer items-center gap-2 rounded-sm py-1.5 pr-8 pl-2 text-sm outline-hidden select-none transition-all duration-150 ease-in-out",
                         'hover:bg-primary/20 hover:pl-3 hover:shadow-sm',
@@ -237,8 +263,8 @@ export function SearchableSelect({
               </div>
             ))}
           </div>
-        </div>
-      )}
-    </div>
+        </PopoverContent>
+      </div>
+    </Popover>
   );
 }
diff --git a/packages/app/src/hooks/api/use-collectivex.ts b/packages/app/src/hooks/api/use-collectivex.ts
new file mode 100644
index 00000000..11c27103
--- /dev/null
+++ b/packages/app/src/hooks/api/use-collectivex.ts
@@ -0,0 +1,74 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+
+import {
+  deleteCollectiveXRun,
+  fetchCollectiveX,
+  fetchCollectiveXRun,
+  fetchCollectiveXRunList,
+} from '@/lib/api';
+import {
+  COLLECTIVEX_DEFAULT_VERSION,
+  type CollectiveXVersion,
+} from '@/components/collectivex/types';
+
+/** Latest ingested run's neutral dataset — the default page view. */
+export function useCollectiveX(version: CollectiveXVersion = COLLECTIVEX_DEFAULT_VERSION) {
+  return useQuery({
+    queryKey: ['collectivex', version],
+    queryFn: ({ signal }) => fetchCollectiveX(signal, version),
+    staleTime: 0,
+    refetchOnMount: 'always',
+  });
+}
+
+/**
+ * Ingested runs for a version, backing the run picker. `enabled` gates the
+ * fetch so the list is only pulled when the user opens the picker; refetched on
+ * mount so a reopened picker reflects newly ingested runs without a hard reload.
+ */
+export function useCollectiveXRuns(
+  version: CollectiveXVersion = COLLECTIVEX_DEFAULT_VERSION,
+  enabled = true,
+) {
+  return useQuery({
+    queryKey: ['collectivex-runs', version],
+    queryFn: ({ signal }) => fetchCollectiveXRunList(version, signal),
+    enabled,
+    staleTime: 0,
+    refetchOnMount: 'always',
+  });
+}
+
+/**
+ * Resolve one selected run's neutral dataset by run_id. `enabled` gates the fetch
+ * so the picker only loads a run once the user selects a non-default one; the
+ * default view keeps using the latest run via {@link useCollectiveX}.
+ */
+export function useCollectiveXRun(version: CollectiveXVersion, runId: string | null) {
+  return useQuery({
+    queryKey: ['collectivex-run', version, runId],
+    queryFn: ({ signal }) => fetchCollectiveXRun(version, runId!, signal),
+    enabled: runId !== null,
+    staleTime: 0,
+    refetchOnMount: 'always',
+  });
+}
+
+/**
+ * Admin deletion of an ingested run. Resolves `false` on 401 (stale token —
+ * the caller clears its stored copy); on success every CollectiveX query is
+ * invalidated so the latest view and picker drop the run immediately.
+ */
+export function useDeleteCollectiveXRun() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ runId, token }: { runId: string; token: string }) =>
+      deleteCollectiveXRun(runId, token),
+    onSuccess: (deleted) => {
+      if (!deleted) return;
+      for (const key of ['collectivex', 'collectivex-runs', 'collectivex-run']) {
+        void queryClient.invalidateQueries({ queryKey: [key] });
+      }
+    },
+  });
+}
diff --git a/packages/app/src/lib/allowed-dev-origins.test.ts b/packages/app/src/lib/allowed-dev-origins.test.ts
index 0577e3ce..44e8ae3c 100644
--- a/packages/app/src/lib/allowed-dev-origins.test.ts
+++ b/packages/app/src/lib/allowed-dev-origins.test.ts
@@ -11,7 +11,7 @@ describe('allowedDevOriginsFromEnv', () => {
 
   it('trims whitespace and removes empty entries', () => {
     expect(
-      allowedDevOriginsFromEnv(' 10.112.9.49 , , local-origin.dev , *.local-origin.dev '),
-    ).toEqual(['10.112.9.49', 'local-origin.dev', '*.local-origin.dev']);
+      allowedDevOriginsFromEnv(' dev-machine.local , , local-origin.dev , *.local-origin.dev '),
+    ).toEqual(['dev-machine.local', 'local-origin.dev', '*.local-origin.dev']);
   });
 });
diff --git a/packages/app/src/lib/allowed-dev-origins.ts b/packages/app/src/lib/allowed-dev-origins.ts
index 839a486f..82fac506 100644
--- a/packages/app/src/lib/allowed-dev-origins.ts
+++ b/packages/app/src/lib/allowed-dev-origins.ts
@@ -1,4 +1,4 @@
-/** Comma-separated hostnames or IPs (e.g. `10.112.9.49,192.168.1.10`). Only used in dev. */
+/** Comma-separated dev hostnames (e.g. `dev-a.local,dev-b.local`). */
 export function allowedDevOriginsFromEnv(raw = process.env.NEXT_DEV_ALLOWED_ORIGINS): string[] {
   if (!raw?.trim()) return [];
   return raw
diff --git a/packages/app/src/lib/api-cache.test.ts b/packages/app/src/lib/api-cache.test.ts
index 9b5ac039..c1066162 100644
--- a/packages/app/src/lib/api-cache.test.ts
+++ b/packages/app/src/lib/api-cache.test.ts
@@ -16,7 +16,7 @@ vi.mock('./blob-cache', () => ({
   blobPurge: vi.fn(),
 }));
 
-import { cachedQuery, purgeAll, cachedJson } from './api-cache';
+import { cachedQuery, purgeAll, purgeCollectiveX, cachedJson } from './api-cache';
 import { revalidateTag, unstable_cache } from 'next/cache';
 import { blobGet, blobSet, blobPurge } from './blob-cache';
 
@@ -155,6 +155,14 @@ describe('purgeAll', () => {
     expect(mockBlobPurge).toHaveBeenCalled();
   });
 
+  it('drops the CollectiveX tag too — the blob purge removed its entries', async () => {
+    mockBlobPurge.mockResolvedValue(1);
+
+    await purgeAll();
+
+    expect(mockRevalidateTag).toHaveBeenCalledWith('collectivex', { expire: 0 });
+  });
+
   it('returns 0 when no blobs were deleted', async () => {
     mockBlobPurge.mockResolvedValue(0);
 
@@ -172,6 +180,16 @@ describe('purgeAll', () => {
   });
 });
 
+describe('purgeCollectiveX', () => {
+  it('drops only the collectivex tag — no blobs belong to that scope', () => {
+    purgeCollectiveX();
+
+    expect(mockBlobPurge).not.toHaveBeenCalled();
+    expect(mockRevalidateTag).toHaveBeenCalledWith('collectivex', { expire: 0 });
+    expect(mockRevalidateTag).not.toHaveBeenCalledWith('db', { expire: 0 });
+  });
+});
+
 describe('cachedJson', () => {
   it('sets Cache-Control with max-age=0 and 1 day s-maxage', () => {
     const res = cachedJson({ ok: true });
@@ -183,6 +201,20 @@ describe('cachedJson', () => {
     expect(res.headers.get('Vercel-Cache-Tag')).toBe('db');
   });
 
+  it('carries a custom cache tag when one is passed', () => {
+    const res = cachedJson({ ok: true }, { tag: 'collectivex' });
+    expect(res.headers.get('Vercel-Cache-Tag')).toBe('collectivex');
+    expect(res.headers.get('Cache-Control')).toBe('public, max-age=0, s-maxage=86400');
+  });
+
+  it('honors a custom Cache-Control for lazily-refreshed routes', () => {
+    const res = cachedJson(
+      { ok: true },
+      { tag: 'collectivex', cacheControl: 'public, max-age=0, s-maxage=60' },
+    );
+    expect(res.headers.get('Cache-Control')).toBe('public, max-age=0, s-maxage=60');
+  });
+
   it('sets an environment-scoped Vercel-Cache-Tag', () => {
     process.env.CACHE_NAMESPACE = 'staging';
 
diff --git a/packages/app/src/lib/api-cache.ts b/packages/app/src/lib/api-cache.ts
index 65b0ec26..62738b58 100644
--- a/packages/app/src/lib/api-cache.ts
+++ b/packages/app/src/lib/api-cache.ts
@@ -1,6 +1,23 @@
 import { revalidateTag, unstable_cache } from 'next/cache';
 import { blobGet, blobPurge, blobSet } from './blob-cache';
 
+/**
+ * CollectiveX data lives in its own database and gets its own cache scope:
+ * every CollectiveX response carries this CDN/unstable_cache tag (via
+ * `cachedJson(..., { tag })`), so run deletion can purge the CollectiveX
+ * cache without dropping the main dashboard's. CollectiveX routes read their
+ * DB directly — no blob layer, so the tag is the entire scope.
+ */
+export const COLLECTIVEX_CACHE_SCOPE = 'collectivex';
+
+/**
+ * Short CDN window shared by the CollectiveX latest/runs routes: new sweep
+ * runs are discovered lazily at the origin, so freshness is bounded by this
+ * TTL rather than by an ingest-time purge.
+ */
+export const COLLECTIVEX_CACHE_CONTROL =
+  'public, max-age=0, s-maxage=60, stale-while-revalidate=300';
+
 function cacheNamespace(): string {
   return process.env.CACHE_NAMESPACE?.trim() ?? '';
 }
@@ -18,6 +35,8 @@ function cacheTag(): string {
 interface CachedQueryOptions {
   /** Use blob storage directly, skipping unstable_cache. Use for payloads known to exceed 2MB. */
   blobOnly?: boolean;
+  /** Cache tag for the unstable_cache path (default 'db'). */
+  tag?: string;
 }
 
 /**
@@ -42,7 +61,9 @@ export function cachedQuery<T, Args extends unknown[]>(
     };
   }
 
-  const nextCached = unstable_cache(fn, [cacheKey(keyPrefix)], { tags: [cacheTag()] });
+  const nextCached = unstable_cache(fn, [cacheKey(keyPrefix)], {
+    tags: [options?.tag ?? cacheTag()],
+  });
   return (...args: Args): Promise<T> => nextCached(...args);
 }
 
@@ -50,14 +71,32 @@ export function cachedQuery<T, Args extends unknown[]>(
 export async function purgeAll(): Promise<number> {
   const deleted = await blobPurge();
   revalidateTag(cacheTag(), { expire: 0 });
+  // CollectiveX responses are cached only under their own tag (no blobs), so
+  // a full purge must drop that tag explicitly — this line is the sole
+  // mechanism that clears CollectiveX from the CDN.
+  purgeCollectiveX();
   return deleted;
 }
 
-/** 1 day. Purged on demand via the environment-scoped database cache tag. */
-function cdnHeaders(): Record<string, string> {
+/**
+ * Purge only the CollectiveX cache scope. CollectiveX routes read straight
+ * from their own DB (no blob layer), so this is just the CDN/unstable_cache
+ * tag.
+ */
+export function purgeCollectiveX(): void {
+  revalidateTag(COLLECTIVEX_CACHE_SCOPE, { expire: 0 });
+}
+
+/**
+ * 1 day unless overridden. Purged on demand via revalidateTag with the matching
+ * tag. `tag` defaults to the environment-scoped database tag; CollectiveX routes
+ * pass their own scope (and a shorter cacheControl).
+ */
+function cdnHeaders(tag: string = cacheTag(), cacheControl?: string): Record<string, string> {
   return {
-    'Cache-Control': 'public, max-age=0, s-maxage=86400',
-    'Vercel-Cache-Tag': cacheTag(),
+    'Cache-Control': cacheControl ?? 'public, max-age=0, s-maxage=86400',
+    'Vercel-Cache-Tag': tag,
+    'X-Content-Type-Options': 'nosniff',
   };
 }
 
@@ -75,7 +114,10 @@ export function cachedText(data: string, contentType: string): Response {
 }
 
 /** CDN-cached streamed + gzip-compressed JSON response — supports up to 20 MB on Vercel CDN. */
-export function cachedJson<T>(data: T): Response {
+export function cachedJson<T>(
+  data: T,
+  options?: { tag?: string; cacheControl?: string },
+): Response {
   const bytes = new TextEncoder().encode(JSON.stringify(data));
   const CHUNK = 64 * 1024;
   const raw = new ReadableStream({
@@ -91,7 +133,7 @@ export function cachedJson<T>(data: T): Response {
     headers: {
       'Content-Type': 'application/json',
       'Content-Encoding': 'gzip',
-      ...cdnHeaders(),
+      ...cdnHeaders(options?.tag, options?.cacheControl),
     },
   });
 }
diff --git a/packages/app/src/lib/api.test.ts b/packages/app/src/lib/api.test.ts
index a1f29006..fc9e0552 100644
--- a/packages/app/src/lib/api.test.ts
+++ b/packages/app/src/lib/api.test.ts
@@ -4,9 +4,15 @@ import {
   fetchBenchmarks,
   fetchWorkflowInfo,
   fetchAvailability,
+  deleteCollectiveXRun,
+  fetchCollectiveX,
+  fetchCollectiveXRun,
+  fetchCollectiveXRunList,
   fetchReliability,
   fetchEvaluations,
 } from './api';
+import { buildRunSummary } from '@semianalysisai/inferencex-db/collectivex/reader';
+import { makeCollectiveXDataset } from '@/components/collectivex/test-fixture';
 
 const mockFetch = vi.fn();
 vi.stubGlobal('fetch', mockFetch);
@@ -126,3 +132,73 @@ describe('fetchEvaluations', () => {
     expect(result[0].task).toBe('gsm8k');
   });
 });
+
+describe('CollectiveX API', () => {
+  const dataset = makeCollectiveXDataset();
+
+  function mockJson(payload: unknown) {
+    mockFetch.mockResolvedValueOnce({
+      ok: true,
+      json: () => Promise.resolve(payload),
+    });
+  }
+
+  it('fetches the latest run dataset', async () => {
+    mockJson(dataset);
+
+    const result = await fetchCollectiveX();
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      '/api/v1/collectivex/latest?version=1',
+      expect.objectContaining({}),
+    );
+    expect(result.version).toBe(1);
+    expect(result.run.run_id).toBe(dataset.run.run_id);
+  });
+
+  it('fetches a specific run by id', async () => {
+    mockJson(dataset);
+
+    const result = await fetchCollectiveXRun(1, dataset.run.run_id);
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      `/api/v1/collectivex/runs/${dataset.run.run_id}?version=1`,
+      expect.objectContaining({}),
+    );
+    expect(result.run.run_id).toBe(dataset.run.run_id);
+  });
+
+  it('fetches the run list', async () => {
+    mockJson({ version: 1, runs: [buildRunSummary(dataset)] });
+
+    const runs = await fetchCollectiveXRunList(1);
+
+    expect(mockFetch).toHaveBeenCalledWith(
+      '/api/v1/collectivex/runs?version=1',
+      expect.objectContaining({}),
+    );
+    expect(runs).toHaveLength(1);
+    expect(runs[0].run_id).toBe(dataset.run.run_id);
+  });
+
+  it('sends the bearer token on delete and reports success', async () => {
+    mockFetch.mockResolvedValueOnce({ ok: true, status: 200 });
+
+    await expect(deleteCollectiveXRun('160', 'secret-token')).resolves.toBe(true);
+
+    expect(mockFetch).toHaveBeenCalledWith('/api/v1/collectivex/runs/160', {
+      method: 'DELETE',
+      headers: { Authorization: 'Bearer secret-token' },
+    });
+  });
+
+  it('resolves false on 401 so callers can clear a stale token', async () => {
+    mockFetch.mockResolvedValueOnce({ ok: false, status: 401 });
+    await expect(deleteCollectiveXRun('160', 'stale')).resolves.toBe(false);
+  });
+
+  it('throws on non-auth delete failures', async () => {
+    mockFetch.mockResolvedValueOnce({ ok: false, status: 500 });
+    await expect(deleteCollectiveXRun('160', 'secret-token')).rejects.toThrow(/500/);
+  });
+});
diff --git a/packages/app/src/lib/api.ts b/packages/app/src/lib/api.ts
index 1c8cb5e8..a6a9915d 100644
--- a/packages/app/src/lib/api.ts
+++ b/packages/app/src/lib/api.ts
@@ -3,6 +3,12 @@
  * Each function is a thin fetch wrapper returning typed data.
  */
 
+import {
+  COLLECTIVEX_DEFAULT_VERSION,
+  type CollectiveXDataset,
+  type CollectiveXRunSummary,
+  type CollectiveXVersion,
+} from '@/components/collectivex/types';
 import type { WorkerPower } from '@/components/inference/types';
 
 import type { SubmissionsResponse } from './submissions-types';
@@ -304,6 +310,53 @@ export function fetchSubmissions(signal?: AbortSignal) {
   return fetchJson<SubmissionsResponse>('/api/v1/submissions', signal);
 }
 
+/** Latest ingested sweep run's neutral view dataset (default page view). */
+export function fetchCollectiveX(
+  signal?: AbortSignal,
+  version: CollectiveXVersion = COLLECTIVEX_DEFAULT_VERSION,
+) {
+  return fetchJson<CollectiveXDataset>(`/api/v1/collectivex/latest?version=${version}`, signal);
+}
+
+/** Ingested sweep runs for the run picker, keyed by run_id + attempt. */
+export function fetchCollectiveXRunList(
+  version: CollectiveXVersion = COLLECTIVEX_DEFAULT_VERSION,
+  signal?: AbortSignal,
+) {
+  return fetchJson<{ runs: CollectiveXRunSummary[] }>(
+    `/api/v1/collectivex/runs?version=${version}`,
+    signal,
+  ).then(({ runs }) => runs);
+}
+
+/** Resolve a specific ingested sweep run's neutral view dataset by run_id. */
+export function fetchCollectiveXRun(
+  version: CollectiveXVersion,
+  runId: string,
+  signal?: AbortSignal,
+) {
+  return fetchJson<CollectiveXDataset>(
+    `/api/v1/collectivex/runs/${runId}?version=${version}`,
+    signal,
+  );
+}
+
+/**
+ * Admin deletion of an ingested run. Requires the dedicated CollectiveX admin
+ * Bearer secret (COLLECTIVEX_ADMIN_SECRET — deliberately not the CI-held
+ * INVALIDATE_SECRET); resolves false on 401 so callers can clear a stale
+ * stored token, throws on other failures.
+ */
+export async function deleteCollectiveXRun(runId: string, token: string): Promise<boolean> {
+  const response = await fetch(`/api/v1/collectivex/runs/${runId}`, {
+    method: 'DELETE',
+    headers: { Authorization: `Bearer ${token}` },
+  });
+  if (response.status === 401) return false;
+  if (!response.ok) throw new Error(`CollectiveX delete failed (${response.status}).`);
+  return true;
+}
+
 export interface FeedbackListRow {
   id: string;
   created_at: string;
diff --git a/packages/app/src/lib/collectivex-lazy-ingest.test.ts b/packages/app/src/lib/collectivex-lazy-ingest.test.ts
new file mode 100644
index 00000000..f69aa803
--- /dev/null
+++ b/packages/app/src/lib/collectivex-lazy-ingest.test.ts
@@ -0,0 +1,358 @@
+import AdmZip from 'adm-zip';
+import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { makeRawMatrix, makeRawShard } from '@/components/collectivex/test-fixture';
+
+const { mockGetStates, mockInsert, mockRefresh, mockGetDb, mockGetWriteDb } = vi.hoisted(() => ({
+  mockGetStates: vi.fn(),
+  mockInsert: vi.fn(),
+  mockRefresh: vi.fn(),
+  mockGetDb: vi.fn(() => 'mock-sql'),
+  mockGetWriteDb: vi.fn(() => 'mock-write-sql'),
+}));
+
+vi.mock('@semianalysisai/inferencex-db/connection', () => ({
+  getCollectiveXDb: mockGetDb,
+  getCollectiveXWriteDb: mockGetWriteDb,
+}));
+
+vi.mock('@semianalysisai/inferencex-db/queries/collectivex', () => ({
+  getCollectiveXRunStates: mockGetStates,
+  insertCollectiveXRun: mockInsert,
+  refreshCollectiveXRunAttempt: mockRefresh,
+}));
+
+import {
+  collectiveXSweepErrorCode,
+  ensureCollectiveXRun,
+  ensureCollectiveXRunsList,
+  ensureLatestCollectiveXRun,
+} from './collectivex-lazy-ingest';
+
+const mockFetch = vi.fn();
+vi.stubGlobal('fetch', mockFetch);
+
+// Two current matrix shards: NVIDIA scale-up EP8 + AMD scale-out EP16.
+const shardA = makeRawShard({ backend: 'deepep-v2', ep: 8 });
+const shardB = makeRawShard({
+  sku: 'mi355x',
+  backend: 'mori',
+  implName: 'mori',
+  vendor: 'amd',
+  ep: 16,
+  scaleUpTransport: 'xgmi',
+  scaleOutTransport: 'rdma',
+  topologyClass: 'mi355x-xgmi-rdma',
+  nodes: 2,
+  gpusPerNode: 8,
+  scaleUpDomain: 8,
+});
+
+function requestedOf(shard: Record<string, unknown>) {
+  const identity = shard.identity as Record<string, unknown>;
+  const factors = identity.case_factors as Record<string, unknown>;
+  return {
+    caseId: identity.case_id as string,
+    sku: factors.sku as string,
+    disposition: 'runnable' as const,
+    case: factors.case as Record<string, unknown>,
+  };
+}
+
+const matrix = makeRawMatrix([requestedOf(shardA), requestedOf(shardB)]);
+const matrixV2 = makeRawMatrix([requestedOf(shardA), requestedOf(shardB)], 2);
+
+function zipDocs(...docs: unknown[]): ArrayBuffer {
+  const zip = new AdmZip();
+  docs.forEach((doc, index) => zip.addFile(`doc-${index}.json`, Buffer.from(JSON.stringify(doc))));
+  const bytes = zip.toBuffer();
+  const archive = new ArrayBuffer(bytes.byteLength);
+  new Uint8Array(archive).set(bytes);
+  return archive;
+}
+
+const matrixZip = zipDocs(matrix);
+const matrixZipV2 = zipDocs(matrixV2);
+const shardZip = zipDocs(shardA, shardB);
+
+function runObject(overrides: Record<string, unknown> = {}) {
+  return {
+    id: 160,
+    name: 'CollectiveX Sweep',
+    path: '.github/workflows/collectivex-sweep.yml',
+    // Deliberately a feature branch: lazy ingest accepts runs from ANY branch.
+    head_branch: 'collectivex-fp8-precision',
+    head_sha: 'a'.repeat(40),
+    status: 'completed',
+    conclusion: 'success',
+    run_attempt: 1,
+    updated_at: '2026-07-08T12:20:00Z',
+    ...overrides,
+  };
+}
+
+function artifactsBody(runId = 160, runAttempt = 1) {
+  return {
+    total_count: 2,
+    artifacts: [
+      {
+        id: 1,
+        name: `cxsweep-matrix-${runId}`,
+        archive_download_url: 'https://example.test/matrix.zip',
+        expired: false,
+      },
+      {
+        id: 2,
+        name: `cxshard-cases-${runId}-${runAttempt}`,
+        archive_download_url: 'https://example.test/shards.zip',
+        expired: false,
+      },
+    ],
+  };
+}
+
+beforeEach(() => {
+  mockFetch.mockReset();
+  mockGetStates.mockReset().mockResolvedValue({});
+  mockInsert.mockReset().mockResolvedValue(true);
+  mockRefresh.mockReset().mockResolvedValue(true);
+  process.env.GITHUB_TOKEN = 'test-token';
+});
+
+afterAll(() => {
+  delete process.env.GITHUB_TOKEN;
+  vi.unstubAllGlobals();
+});
+
+describe('ensureLatestCollectiveXRun', () => {
+  it('discovers the newest absent run and persists its raw documents', async () => {
+    mockFetch
+      .mockResolvedValueOnce(Response.json({ total_count: 1, workflow_runs: [runObject()] }))
+      .mockResolvedValueOnce(Response.json(artifactsBody()))
+      .mockResolvedValueOnce(new Response(matrixZip))
+      .mockResolvedValueOnce(new Response(shardZip));
+
+    await ensureLatestCollectiveXRun(1);
+
+    expect(mockInsert).toHaveBeenCalledTimes(1);
+    const [sql, run, docs] = mockInsert.mock.calls[0];
+    expect(sql).toBe('mock-write-sql');
+    expect(run).toMatchObject({
+      run_id: '160',
+      run_attempt: 1,
+      version: 1,
+      source_branch: 'collectivex-fp8-precision',
+      conclusion: 'success',
+      matrix,
+    });
+    expect(run.summary).toMatchObject({ run_id: '160', measured_cases: 2 });
+    expect(docs).toEqual([shardA, shardB]);
+  });
+
+  it('stops without artifact downloads when the newest matching run is live', async () => {
+    mockGetStates.mockResolvedValue({ '160': { state: 'live', version: 1, run_attempt: 1 } });
+    mockFetch.mockResolvedValueOnce(
+      Response.json({ total_count: 1, workflow_runs: [runObject()] }),
+    );
+
+    await ensureLatestCollectiveXRun(1);
+
+    expect(mockInsert).not.toHaveBeenCalled();
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+  });
+
+  it('never re-ingests a tombstoned run — the next candidate wins', async () => {
+    mockGetStates.mockImplementation((_sql: unknown, ids: string[]) =>
+      Promise.resolve(
+        ids[0] === '161' ? { '161': { state: 'deleted', version: 1, run_attempt: 1 } } : {},
+      ),
+    );
+    mockFetch
+      .mockResolvedValueOnce(
+        Response.json({
+          total_count: 2,
+          workflow_runs: [runObject({ id: 161 }), runObject({ id: 160 })],
+        }),
+      )
+      .mockResolvedValueOnce(Response.json(artifactsBody()))
+      .mockResolvedValueOnce(new Response(matrixZip))
+      .mockResolvedValueOnce(new Response(shardZip));
+
+    await ensureLatestCollectiveXRun(1);
+
+    expect(mockInsert).toHaveBeenCalledTimes(1);
+    expect(mockInsert.mock.calls[0][1].run_id).toBe('160');
+  });
+
+  it('skips runs tagged for another version', async () => {
+    mockFetch
+      .mockResolvedValueOnce(
+        Response.json({
+          total_count: 2,
+          workflow_runs: [runObject({ id: 161 }), runObject({ id: 160 })],
+        }),
+      )
+      // Run 161 carries a v2 matrix — requesting v1 must move on.
+      .mockResolvedValueOnce(Response.json(artifactsBody(161)))
+      .mockResolvedValueOnce(new Response(matrixZipV2))
+      .mockResolvedValueOnce(Response.json(artifactsBody()))
+      .mockResolvedValueOnce(new Response(matrixZip))
+      .mockResolvedValueOnce(new Response(shardZip));
+
+    await ensureLatestCollectiveXRun(1);
+
+    expect(mockInsert).toHaveBeenCalledTimes(1);
+    expect(mockInsert.mock.calls[0][1].version).toBe(1);
+    expect(mockInsert.mock.calls[0][1].run_id).toBe('160');
+  });
+
+  it('refreshes a live run when GitHub reports a newer attempt', async () => {
+    mockGetStates.mockResolvedValue({ '160': { state: 'live', version: 1, run_attempt: 1 } });
+    mockFetch
+      .mockResolvedValueOnce(
+        Response.json({ total_count: 1, workflow_runs: [runObject({ run_attempt: 2 })] }),
+      )
+      .mockResolvedValueOnce(Response.json(artifactsBody(160, 2)))
+      .mockResolvedValueOnce(new Response(matrixZip))
+      .mockResolvedValueOnce(new Response(shardZip));
+
+    await ensureLatestCollectiveXRun(1);
+
+    expect(mockInsert).not.toHaveBeenCalled();
+    expect(mockRefresh).toHaveBeenCalledTimes(1);
+    expect(mockRefresh.mock.calls[0][1]).toMatchObject({ run_id: '160', run_attempt: 2 });
+  });
+
+  it('downloads only the highest usable attempt per shard', async () => {
+    const artifacts = {
+      total_count: 3,
+      artifacts: [
+        {
+          id: 1,
+          name: 'cxsweep-matrix-160',
+          archive_download_url: 'https://example.test/matrix.zip',
+          expired: false,
+        },
+        {
+          id: 2,
+          name: 'cxshard-cases-160-1',
+          archive_download_url: 'https://example.test/shard-attempt1.zip',
+          expired: false,
+        },
+        {
+          id: 3,
+          name: 'cxshard-cases-160-2',
+          archive_download_url: 'https://example.test/shard-attempt2.zip',
+          expired: false,
+        },
+      ],
+    };
+    mockFetch
+      .mockResolvedValueOnce(
+        Response.json({ total_count: 1, workflow_runs: [runObject({ run_attempt: 2 })] }),
+      )
+      .mockResolvedValueOnce(Response.json(artifacts))
+      .mockResolvedValueOnce(new Response(matrixZip))
+      .mockResolvedValueOnce(new Response(shardZip));
+
+    await ensureLatestCollectiveXRun(1);
+
+    expect(mockInsert).toHaveBeenCalledTimes(1);
+    // 4 fetches total: runs, artifacts, matrix, ONE shard — the attempt-1
+    // archive is superseded and never downloaded.
+    expect(mockFetch).toHaveBeenCalledTimes(4);
+    expect(mockFetch.mock.calls[3][0]).toBe('https://example.test/shard-attempt2.zip');
+  });
+
+  it('classifies a matrix artifact without a matrix document as invalid', async () => {
+    mockFetch
+      .mockResolvedValueOnce(Response.json({ total_count: 1, workflow_runs: [runObject()] }))
+      .mockResolvedValueOnce(Response.json(artifactsBody()))
+      .mockResolvedValueOnce(new Response(zipDocs({ record_type: 'samples' })));
+
+    const caught = await ensureLatestCollectiveXRun(1).catch((error: unknown) => error);
+    expect(collectiveXSweepErrorCode(caught)).toBe('invalid');
+    expect(mockInsert).not.toHaveBeenCalled();
+  });
+
+  it('reports GitHub outages as unavailable', async () => {
+    mockFetch.mockResolvedValue(new Response(null, { status: 500 }));
+    const caught = await ensureLatestCollectiveXRun(1).catch((error: unknown) => error);
+    expect(collectiveXSweepErrorCode(caught)).toBe('unavailable');
+  });
+
+  it('reports a missing GITHUB_TOKEN as unavailable', async () => {
+    delete process.env.GITHUB_TOKEN;
+    const caught = await ensureLatestCollectiveXRun(1).catch((error: unknown) => error);
+    expect(collectiveXSweepErrorCode(caught)).toBe('unavailable');
+  });
+});
+
+describe('ensureCollectiveXRunsList', () => {
+  it('backfills absent recent runs and counts live ones toward the cap', async () => {
+    mockGetStates.mockImplementation((_sql: unknown, ids: string[]) =>
+      Promise.resolve(
+        ids[0] === '161' ? { '161': { state: 'live', version: 1, run_attempt: 1 } } : {},
+      ),
+    );
+    mockFetch
+      .mockResolvedValueOnce(
+        Response.json({
+          total_count: 2,
+          workflow_runs: [runObject({ id: 161 }), runObject({ id: 160 })],
+        }),
+      )
+      .mockResolvedValueOnce(Response.json(artifactsBody()))
+      .mockResolvedValueOnce(new Response(matrixZip))
+      .mockResolvedValueOnce(new Response(shardZip));
+
+    await ensureCollectiveXRunsList(1);
+
+    expect(mockInsert).toHaveBeenCalledTimes(1);
+    expect(mockInsert.mock.calls[0][1].run_id).toBe('160');
+  });
+});
+
+describe('ensureCollectiveXRun', () => {
+  it('treats tombstoned runs as not found', async () => {
+    mockGetStates.mockResolvedValue({ '160': { state: 'deleted', version: 1, run_attempt: 1 } });
+    const caught = await ensureCollectiveXRun(1, '160').catch((error: unknown) => error);
+    expect(collectiveXSweepErrorCode(caught)).toBe('not-found');
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  it('returns immediately for live matching runs', async () => {
+    mockGetStates.mockResolvedValue({ '160': { state: 'live', version: 1, run_attempt: 1 } });
+    await ensureCollectiveXRun(1, '160');
+    expect(mockFetch).not.toHaveBeenCalled();
+    expect(mockInsert).not.toHaveBeenCalled();
+  });
+
+  it('persists an absent run fetched by id', async () => {
+    mockFetch
+      .mockResolvedValueOnce(Response.json(runObject()))
+      .mockResolvedValueOnce(Response.json(artifactsBody()))
+      .mockResolvedValueOnce(new Response(matrixZip))
+      .mockResolvedValueOnce(new Response(shardZip));
+
+    await ensureCollectiveXRun(1, '160');
+
+    expect(mockInsert).toHaveBeenCalledTimes(1);
+    expect(mockInsert.mock.calls[0][1].run_id).toBe('160');
+  });
+
+  it('rejects runs from other workflows as not found', async () => {
+    mockFetch.mockResolvedValueOnce(
+      Response.json(runObject({ path: '.github/workflows/run-sweep.yml' })),
+    );
+    const caught = await ensureCollectiveXRun(1, '160').catch((error: unknown) => error);
+    expect(collectiveXSweepErrorCode(caught)).toBe('not-found');
+    expect(mockInsert).not.toHaveBeenCalled();
+  });
+
+  it('rejects malformed run ids without touching GitHub', async () => {
+    const caught = await ensureCollectiveXRun(1, 'abc').catch((error: unknown) => error);
+    expect(collectiveXSweepErrorCode(caught)).toBe('not-found');
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+});
diff --git a/packages/app/src/lib/collectivex-lazy-ingest.ts b/packages/app/src/lib/collectivex-lazy-ingest.ts
new file mode 100644
index 00000000..3110f196
--- /dev/null
+++ b/packages/app/src/lib/collectivex-lazy-ingest.ts
@@ -0,0 +1,540 @@
+/**
+ * Lazy CollectiveX ingest: the CollectiveX database is a durable cache of
+ * GitHub Actions, populated on read. Each `ensure*` function checks the DB
+ * first and only then discovers/downloads sweep artifacts from GitHub,
+ * persisting the RAW documents so a run outlives its 14-day artifact
+ * retention once anyone has viewed it.
+ *
+ * Rules encoded here:
+ *  - Sweep runs are accepted from ANY branch (they are launched via `gh api`
+ *    on feature branches); only the workflow identity is checked.
+ *  - Discovery never gates on conclusion — a red or partial run still
+ *    surfaces what it produced.
+ *  - Tombstoned runs (deleted via the dashboard) are never re-ingested.
+ *  - GitHub being down must not take the page down: callers read the DB
+ *    after `ensure*` and serve whatever is there, so these functions only
+ *    matter when the DB has nothing to fall back to.
+ */
+
+import AdmZip from 'adm-zip';
+
+import { GITHUB_API_BASE, GITHUB_OWNER, GITHUB_REPO } from '@semianalysisai/inferencex-constants';
+
+import {
+  buildDatasetFromNeutral,
+  buildRunSummary,
+  isMatrixDoc,
+  matrixVersion,
+} from '@semianalysisai/inferencex-db/collectivex/reader';
+import type { CollectiveXVersion } from '@semianalysisai/inferencex-db/collectivex/types';
+import { getCollectiveXDb, getCollectiveXWriteDb } from '@semianalysisai/inferencex-db/connection';
+import {
+  getCollectiveXRunStates,
+  insertCollectiveXRun,
+  refreshCollectiveXRunAttempt,
+} from '@semianalysisai/inferencex-db/queries/collectivex';
+
+const WORKFLOW_PATH = '.github/workflows/collectivex-sweep.yml';
+const WORKFLOW_FILE = 'collectivex-sweep.yml';
+const WORKFLOW_NAME = 'CollectiveX Sweep';
+const RUNS_PER_PAGE = 100;
+const ARTIFACTS_PER_PAGE = 100;
+
+// Artifact families uploaded by the sweep.
+const MATRIX_PREFIX = 'cxsweep-matrix-';
+const SHARD_PREFIX = 'cxshard-';
+
+const MAX_ARTIFACT_BYTES = 64 * 1024 * 1024;
+const MAX_RUN_BYTES = 256 * 1024 * 1024;
+const REQUEST_TIMEOUT_MS = 30_000;
+const MAX_REQUEST_ATTEMPTS = 3;
+const RETRYABLE_STATUSES = new Set([408, 429, 500, 502, 503, 504]);
+// The picker backfill ingests at most this many recent runs per pass; each
+// costs one artifact-bundle download, and only once — afterwards they're rows.
+const MAX_DISCOVERED_RUNS = 8;
+
+type SweepErrorCode = 'invalid' | 'not-found' | 'unavailable';
+
+interface WorkflowRun {
+  id: number;
+  name: string;
+  path: string;
+  head_branch: string | null;
+  head_sha: string;
+  status: string | null;
+  conclusion: string | null;
+  run_attempt: number;
+  run_started_at?: string | null;
+  updated_at?: string | null;
+  created_at?: string | null;
+}
+
+interface GithubArtifact {
+  id: number;
+  name: string;
+  archive_download_url: string;
+  expired?: boolean;
+  size_in_bytes?: number;
+}
+
+class CollectiveXSweepError extends Error {
+  readonly code: SweepErrorCode;
+
+  constructor(code: SweepErrorCode, message: string, options?: ErrorOptions) {
+    super(message, options);
+    this.name = 'CollectiveXSweepError';
+    this.code = code;
+  }
+}
+
+export function collectiveXSweepErrorCode(error: unknown): SweepErrorCode | null {
+  return error instanceof CollectiveXSweepError ? error.code : null;
+}
+
+/** HTTP status for a sweep-ingest failure; null for unexpected errors. */
+export function collectiveXSweepErrorStatus(error: unknown): 404 | 502 | 503 | null {
+  const code = collectiveXSweepErrorCode(error);
+  if (code === 'not-found') return 404;
+  if (code === 'unavailable') return 503;
+  if (code === 'invalid') return 502;
+  return null;
+}
+
+// Concurrent requests for the same target share one discovery pass; the DB is
+// the cache, so nothing is memoized beyond the in-flight promise.
+const inFlight = new Map<string, Promise<void>>();
+
+function dedupe(key: string, work: () => Promise<void>): Promise<void> {
+  const existing = inFlight.get(key);
+  if (existing) return existing;
+  const promise = work().finally(() => inFlight.delete(key));
+  inFlight.set(key, promise);
+  return promise;
+}
+
+function githubHeaders(token: string) {
+  return {
+    Accept: 'application/vnd.github+json',
+    Authorization: `Bearer ${token}`,
+    'X-GitHub-Api-Version': '2022-11-28',
+  };
+}
+
+async function waitBeforeRetry(attempt: number): Promise<void> {
+  const delay = process.env.NODE_ENV === 'test' ? 0 : Math.min(250 * 2 ** (attempt - 1), 2000);
+  await new Promise((resolve) => {
+    setTimeout(resolve, delay);
+  });
+}
+
+async function githubFetch(url: string, token: string): Promise<Response> {
+  let lastError: unknown;
+  for (let attempt = 1; attempt <= MAX_REQUEST_ATTEMPTS; attempt++) {
+    try {
+      const response = await fetch(url, {
+        cache: 'no-store',
+        headers: githubHeaders(token),
+        signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+      });
+      if (
+        response.ok ||
+        !RETRYABLE_STATUSES.has(response.status) ||
+        attempt === MAX_REQUEST_ATTEMPTS
+      ) {
+        return response;
+      }
+      lastError = new Error(`GitHub returned ${response.status}`);
+    } catch (error) {
+      lastError = error;
+      if (attempt === MAX_REQUEST_ATTEMPTS) break;
+    }
+    await waitBeforeRetry(attempt);
+  }
+  throw new CollectiveXSweepError('unavailable', 'GitHub request failed', { cause: lastError });
+}
+
+function requireToken(): string {
+  const token = process.env.GITHUB_TOKEN;
+  if (!token) throw new CollectiveXSweepError('unavailable', 'GITHUB_TOKEN is not configured');
+  return token;
+}
+
+// Identity check only — never the branch: sweeps run on feature branches.
+function isSweepRun(run: WorkflowRun): boolean {
+  return (
+    run.name === WORKFLOW_NAME &&
+    run.path === WORKFLOW_PATH &&
+    Number.isSafeInteger(run.id) &&
+    run.id > 0 &&
+    Number.isSafeInteger(run.run_attempt) &&
+    run.run_attempt > 0
+  );
+}
+
+function runGeneratedAt(run: WorkflowRun): string {
+  return run.updated_at || run.run_started_at || run.created_at || '';
+}
+
+// Newest-first stream of completed sweep runs across all branches.
+async function* sweepRuns(token: string): AsyncGenerator<WorkflowRun> {
+  let page = 1;
+  let visited = 0;
+  let total: number | null = null;
+  while (total === null || visited < total) {
+    const parameters = new URLSearchParams({
+      status: 'completed',
+      per_page: String(RUNS_PER_PAGE),
+      page: String(page),
+    });
+    const response = await githubFetch(
+      `${GITHUB_API_BASE}/repos/${GITHUB_OWNER}/${GITHUB_REPO}/actions/workflows/${WORKFLOW_FILE}/runs?${parameters}`,
+      token,
+    );
+    if (!response.ok) {
+      throw new CollectiveXSweepError(
+        'unavailable',
+        `GitHub run discovery failed (${response.status})`,
+      );
+    }
+    const payload = (await response.json()) as {
+      total_count?: number;
+      workflow_runs?: WorkflowRun[];
+    };
+    const runs = payload.workflow_runs ?? [];
+    if (
+      total === null &&
+      Number.isSafeInteger(payload.total_count) &&
+      (payload.total_count ?? -1) >= 0
+    ) {
+      total = payload.total_count!;
+    }
+    if (runs.length === 0) break;
+    visited += runs.length;
+    for (const run of runs) if (isSweepRun(run)) yield run;
+    if (runs.length < RUNS_PER_PAGE || (total !== null && visited >= total)) break;
+    page += 1;
+  }
+}
+
+async function listArtifacts(runId: number, token: string): Promise<GithubArtifact[]> {
+  const artifacts: GithubArtifact[] = [];
+  let page = 1;
+  let total: number | null = null;
+  while (total === null || artifacts.length < total) {
+    const response = await githubFetch(
+      `${GITHUB_API_BASE}/repos/${GITHUB_OWNER}/${GITHUB_REPO}/actions/runs/${runId}/artifacts?per_page=${ARTIFACTS_PER_PAGE}&page=${page}`,
+      token,
+    );
+    if (!response.ok) {
+      throw new CollectiveXSweepError(
+        'unavailable',
+        `GitHub artifact discovery failed (${response.status})`,
+      );
+    }
+    const payload = (await response.json()) as {
+      total_count?: number;
+      artifacts?: GithubArtifact[];
+    };
+    const page_artifacts = payload.artifacts ?? [];
+    if (
+      total === null &&
+      Number.isSafeInteger(payload.total_count) &&
+      (payload.total_count ?? -1) >= 0
+    ) {
+      total = payload.total_count!;
+    }
+    if (page_artifacts.length === 0) break;
+    artifacts.push(...page_artifacts);
+    if (page_artifacts.length < ARTIFACTS_PER_PAGE) break;
+    page += 1;
+  }
+  return artifacts.filter((artifact) => !artifact.expired);
+}
+
+function hasMatrixArtifact(artifacts: GithubArtifact[], run: WorkflowRun): boolean {
+  return artifacts.some((artifact) => artifact.name === `${MATRIX_PREFIX}${run.id}`);
+}
+
+async function collectDocs(artifact: GithubArtifact, token: string): Promise<unknown[]> {
+  if (artifact.size_in_bytes !== undefined && artifact.size_in_bytes > MAX_ARTIFACT_BYTES) {
+    throw new CollectiveXSweepError('invalid', `artifact ${artifact.name} is oversized`);
+  }
+  const response = await githubFetch(artifact.archive_download_url, token);
+  if (!response.ok) {
+    throw new CollectiveXSweepError(
+      'unavailable',
+      `GitHub artifact download failed (${response.status})`,
+    );
+  }
+  const archive = Buffer.from(await response.arrayBuffer());
+  if (archive.byteLength > MAX_ARTIFACT_BYTES) {
+    throw new CollectiveXSweepError('invalid', `artifact ${artifact.name} archive is oversized`);
+  }
+  let zip: AdmZip;
+  try {
+    zip = new AdmZip(archive);
+  } catch (error) {
+    throw new CollectiveXSweepError('invalid', `artifact ${artifact.name} is not a ZIP`, {
+      cause: error,
+    });
+  }
+  const docs: unknown[] = [];
+  for (const entry of zip.getEntries()) {
+    if (entry.isDirectory || !entry.entryName.endsWith('.json')) continue;
+    let text: string;
+    try {
+      text = new TextDecoder('utf-8', { fatal: true }).decode(entry.getData());
+    } catch (error) {
+      throw new CollectiveXSweepError('invalid', `artifact ${artifact.name} has non-UTF-8 entry`, {
+        cause: error,
+      });
+    }
+    try {
+      docs.push(JSON.parse(text));
+    } catch (error) {
+      throw new CollectiveXSweepError('invalid', `artifact ${artifact.name} has invalid JSON`, {
+        cause: error,
+      });
+    }
+  }
+  return docs;
+}
+
+// A run's validated matrix, its version tag, and the artifacts that feed
+// persistence. Kept separate so discovery can read the version tag cheaply
+// (matrix docs are tiny) before committing to a full download.
+interface MatrixCandidate {
+  matrixDoc: unknown;
+  version: number;
+  matrixArtifacts: GithubArtifact[];
+  resultArtifacts: GithubArtifact[];
+}
+
+function resultArtifactsForRun(artifacts: GithubArtifact[], run: WorkflowRun): GithubArtifact[] {
+  const suffix = new RegExp(`^${SHARD_PREFIX}(.+)-${run.id}-([1-9][0-9]*)$`, 'u');
+  const selected = new Map<string, { artifact: GithubArtifact; attempt: number }>();
+  for (const artifact of artifacts) {
+    const match = suffix.exec(artifact.name);
+    if (!match) continue;
+    const attempt = Number(match[2]);
+    if (attempt > run.run_attempt) continue;
+    const previous = selected.get(match[1]);
+    if (
+      !previous ||
+      attempt > previous.attempt ||
+      (attempt === previous.attempt && artifact.id > previous.artifact.id)
+    ) {
+      selected.set(match[1], { artifact, attempt });
+    }
+  }
+  return [...selected.values()]
+    .map(({ artifact }) => artifact)
+    .toSorted((left, right) => left.name.localeCompare(right.name));
+}
+
+async function loadMatrixCandidate(
+  artifacts: GithubArtifact[],
+  token: string,
+  run: WorkflowRun,
+): Promise<MatrixCandidate> {
+  const matrixArtifacts = artifacts
+    .filter((artifact) => artifact.name === `${MATRIX_PREFIX}${run.id}`)
+    .toSorted((left, right) => right.id - left.id)
+    .slice(0, 1);
+  if (matrixArtifacts.length === 0) {
+    throw new CollectiveXSweepError('not-found', 'sweep run has no matrix artifact');
+  }
+  const matrixDocs: unknown[] = [];
+  for (const artifact of matrixArtifacts) matrixDocs.push(...(await collectDocs(artifact, token)));
+  const matrixCandidates = matrixDocs.filter((doc) => isMatrixDoc(doc));
+  if (matrixCandidates.length !== 1) {
+    throw new CollectiveXSweepError('invalid', 'sweep run must carry exactly one matrix document');
+  }
+  const version = matrixVersion(matrixCandidates[0]);
+  if (version === null) {
+    throw new CollectiveXSweepError('invalid', 'matrix document has no valid version tag');
+  }
+  const resultArtifacts = resultArtifactsForRun(artifacts, run);
+  return { matrixDoc: matrixCandidates[0], version, matrixArtifacts, resultArtifacts };
+}
+
+/**
+ * Download a candidate's result docs, validate assembly, persist raw.
+ * `refresh` replaces an already-live row whose GitHub attempt is newer (a
+ * re-run of failed shards); plain inserts are conflict-safe no-ops.
+ */
+async function persistRun(
+  run: WorkflowRun,
+  candidate: MatrixCandidate,
+  token: string,
+  refresh = false,
+): Promise<void> {
+  const generatedAt = runGeneratedAt(run);
+  if (!generatedAt) {
+    throw new CollectiveXSweepError('invalid', 'sweep run is missing a timestamp');
+  }
+
+  let totalBytes = 0;
+  for (const artifact of [...candidate.matrixArtifacts, ...candidate.resultArtifacts]) {
+    totalBytes += artifact.size_in_bytes ?? 0;
+    if (totalBytes > MAX_RUN_BYTES) {
+      throw new CollectiveXSweepError('invalid', 'sweep run artifacts exceed the size budget');
+    }
+  }
+
+  const docs: unknown[] = [];
+  for (const artifact of candidate.resultArtifacts) {
+    docs.push(...(await collectDocs(artifact, token)));
+  }
+
+  const meta = {
+    run_id: String(run.id),
+    run_attempt: run.run_attempt,
+    generated_at: generatedAt,
+    conclusion: run.conclusion,
+    source_sha: run.head_sha,
+  };
+
+  // Assemble once to validate the bundle and precompute the picker summary;
+  // only the raw documents are stored.
+  let summary;
+  try {
+    summary = buildRunSummary(buildDatasetFromNeutral(candidate.matrixDoc, docs, meta));
+  } catch (error) {
+    throw new CollectiveXSweepError('invalid', 'sweep run artifacts failed validation', {
+      cause: error,
+    });
+  }
+
+  const row = {
+    ...meta,
+    version: candidate.version,
+    source_branch: run.head_branch,
+    matrix: candidate.matrixDoc,
+    summary,
+  };
+  await (refresh
+    ? refreshCollectiveXRunAttempt(getCollectiveXWriteDb(), row, docs)
+    : insertCollectiveXRun(getCollectiveXWriteDb(), row, docs));
+}
+
+/** Download and version-check a candidate's matrix; null when not ingestible. */
+async function matrixCandidateFor(
+  run: WorkflowRun,
+  version: CollectiveXVersion,
+  token: string,
+): Promise<MatrixCandidate | null> {
+  const artifacts = await listArtifacts(run.id, token);
+  if (!hasMatrixArtifact(artifacts, run)) return null;
+  const candidate = await loadMatrixCandidate(artifacts, token, run);
+  return candidate.version === version ? candidate : null;
+}
+
+/**
+ * Handle one discovery candidate — the single walker step shared by the
+ * latest and runs-list paths: persist absent requested-version runs, refresh
+ * live ones whose GitHub attempt is newer (re-run of failed shards), skip
+ * everything else. Returns 'match' when the candidate is a live
+ * requested-version run in the DB after this call; tombstoned runs are
+ * 'skip' — they are invisible to readers and must not satisfy the walk.
+ */
+async function considerCandidate(
+  run: WorkflowRun,
+  version: CollectiveXVersion,
+  token: string,
+): Promise<'match' | 'skip'> {
+  const states = await getCollectiveXRunStates(getCollectiveXDb(), [String(run.id)]);
+  const known = states[String(run.id)];
+  if (known) {
+    if (known.version !== version || known.state !== 'live') return 'skip';
+    if (run.run_attempt > known.run_attempt) {
+      const candidate = await matrixCandidateFor(run, version, token);
+      if (candidate) await persistRun(run, candidate, token, true);
+    }
+    return 'match';
+  }
+  const candidate = await matrixCandidateFor(run, version, token);
+  if (!candidate) return 'skip';
+  await persistRun(run, candidate, token);
+  return 'match';
+}
+
+/**
+ * Make sure the newest requested-version sweep run on GitHub is in the DB.
+ * Completes silently when GitHub has nothing new; throws only on GitHub or
+ * artifact failures (callers fall back to whatever the DB already holds).
+ */
+export function ensureLatestCollectiveXRun(version: CollectiveXVersion): Promise<void> {
+  return dedupe(`latest:${version}`, async () => {
+    const token = requireToken();
+    for await (const run of sweepRuns(token)) {
+      if ((await considerCandidate(run, version, token)) === 'match') return;
+    }
+  });
+}
+
+/**
+ * Backfill up to MAX_DISCOVERED_RUNS recent requested-version runs into the
+ * DB so the picker lists recent sweeps even before anyone viewed them. Only
+ * live matches count toward the cap — tombstoned runs never fill a slot.
+ */
+export function ensureCollectiveXRunsList(version: CollectiveXVersion): Promise<void> {
+  return dedupe(`list:${version}`, async () => {
+    const token = requireToken();
+    let matched = 0;
+    for await (const run of sweepRuns(token)) {
+      if ((await considerCandidate(run, version, token)) === 'match') matched += 1;
+      if (matched >= MAX_DISCOVERED_RUNS) return;
+    }
+  });
+}
+
+/**
+ * Make sure one specific run is in the DB. Throws 'not-found' for absent,
+ * non-sweep, cross-version, or tombstoned runs.
+ */
+export function ensureCollectiveXRun(version: CollectiveXVersion, runId: string): Promise<void> {
+  return dedupe(`run:${version}:${runId}`, async () => {
+    const numericId = Number(runId);
+    if (!Number.isSafeInteger(numericId) || numericId <= 0) {
+      throw new CollectiveXSweepError('not-found', 'invalid run id');
+    }
+    const states = await getCollectiveXRunStates(getCollectiveXDb(), [runId]);
+    const known = states[runId];
+    if (known) {
+      // Tombstoned or cross-version rows both read as absent to the caller.
+      if (known.state === 'live' && known.version === version) return;
+      throw new CollectiveXSweepError('not-found', 'run is not available');
+    }
+    const token = requireToken();
+    const response = await githubFetch(
+      `${GITHUB_API_BASE}/repos/${GITHUB_OWNER}/${GITHUB_REPO}/actions/runs/${numericId}`,
+      token,
+    );
+    if (response.status === 404) {
+      throw new CollectiveXSweepError('not-found', 'sweep run not found');
+    }
+    if (!response.ok) {
+      throw new CollectiveXSweepError(
+        'unavailable',
+        `GitHub run lookup failed (${response.status})`,
+      );
+    }
+    const run = (await response.json()) as WorkflowRun;
+    if (!isSweepRun(run)) {
+      throw new CollectiveXSweepError('not-found', 'run is not a CollectiveX sweep');
+    }
+    // Persisting an in-progress run would freeze a partial snapshot forever
+    // (the run_id is then "known" and never re-fetched). Discovery only sees
+    // completed runs; hold fetch-by-id to the same bar.
+    if (run.status !== 'completed') {
+      throw new CollectiveXSweepError('not-found', 'sweep run has not completed');
+    }
+    const artifacts = await listArtifacts(run.id, token);
+    const candidate = await loadMatrixCandidate(artifacts, token, run);
+    if (candidate.version !== version) {
+      throw new CollectiveXSweepError('not-found', 'run does not match the requested version');
+    }
+    await persistRun(run, candidate, token);
+  });
+}
diff --git a/packages/app/src/lib/d3-chart/D3Chart/types.ts b/packages/app/src/lib/d3-chart/D3Chart/types.ts
index 9bb3f5c1..9aff5161 100644
--- a/packages/app/src/lib/d3-chart/D3Chart/types.ts
+++ b/packages/app/src/lib/d3-chart/D3Chart/types.ts
@@ -126,6 +126,8 @@ export interface AxisConfig {
   label?: string;
   tickFormat?: (d: d3.AxisDomain) => string;
   tickCount?: number;
+  /** Explicit ticks or a domain-aware generator, useful for geometric and sparse log axes. */
+  tickValues?: (number | Date)[] | ((scale: AnyScale) => (number | Date)[]);
   /** Post-render callback for custom axis label formatting (e.g., multi-line tspan). */
   customize?: (axisGroup: d3.Selection<SVGGElement, unknown, null, undefined>) => void;
 }
diff --git a/packages/app/src/lib/d3-chart/D3Chart/useD3ChartRenderer.ts b/packages/app/src/lib/d3-chart/D3Chart/useD3ChartRenderer.ts
index c6402c91..20caf29f 100644
--- a/packages/app/src/lib/d3-chart/D3Chart/useD3ChartRenderer.ts
+++ b/packages/app/src/lib/d3-chart/D3Chart/useD3ChartRenderer.ts
@@ -8,7 +8,7 @@ import type { ChartLayout, ContinuousScale } from '../types';
 
 import { buildScale, isBandScale, type BuiltScale } from './scale-builders';
 import { renderLayer, updateLayerOnZoom } from './layer-renderer';
-import type { D3ChartProps, RenderContext, ZoomContext } from './types';
+import type { AxisConfig, D3ChartProps, RenderContext, ZoomContext } from './types';
 
 interface RendererDeps {
   svgRef: React.RefObject<SVGSVGElement | null>;
@@ -51,6 +51,14 @@ interface RendererDeps {
   ) => void;
 }
 
+function resolveTickValues(
+  tickValues: AxisConfig['tickValues'],
+  scale: AnyScale,
+): (number | Date)[] | undefined {
+  if (!tickValues) return undefined;
+  return typeof tickValues === 'function' ? tickValues(scale) : tickValues;
+}
+
 /**
  * Core render effect for D3Chart. Builds scales, renders structure/axes/grid/layers,
  * wires up tooltip and zoom handlers.
@@ -97,7 +105,14 @@ export function useD3ChartRenderer<T>(props: D3ChartProps<T>, deps: RendererDeps
   // preventing a frame where dots and lines are out of sync during y-axis metric changes.
   useLayoutEffect(() => {
     if (!svgRef.current || !tooltipRef.current || dimensions.width === 0) return;
-    if (data.length === 0 && layers.every((l) => l.type !== 'custom')) return;
+    if (data.length === 0 && layers.every((layer) => layer.type !== 'custom')) {
+      d3.select(svgRef.current).selectAll('*').remove();
+      scalesRef.current = null;
+      layoutRef.current = null;
+      dismissTooltip(true);
+      prevDataRef.current = data;
+      return;
+    }
 
     // Animate when data or scale domains changed (but not on resize/theme changes)
     const dataChanged = data !== prevDataRef.current;
@@ -162,12 +177,24 @@ export function useD3ChartRenderer<T>(props: D3ChartProps<T>, deps: RendererDeps
 
       // ── Grid + Axes (skip when no scale configs) ──
       if (hasScales) {
-        renderGrid(layout, xScale as AnyScale, yScale as any, yAxisConfig?.tickCount ?? 5);
+        const xTickValues = resolveTickValues(xAxisConfig?.tickValues, xScale as AnyScale);
+        const yTickValues = resolveTickValues(yAxisConfig?.tickValues, yScale as AnyScale);
+        renderGrid(
+          layout,
+          xScale as AnyScale,
+          yScale as any,
+          yAxisConfig?.tickCount ?? 5,
+          0,
+          xTickValues,
+          yTickValues,
+        );
         renderAxes(layout, xScale as AnyScale, yScale as any, {
           xTickFormat: xAxisConfig?.tickFormat,
           yTickFormat: yAxisConfig?.tickFormat,
           xTickCount: xAxisConfig?.tickCount,
           yTickCount: yAxisConfig?.tickCount,
+          xTickValues,
+          yTickValues,
         });
 
         // Custom axis formatting callbacks
@@ -409,11 +436,15 @@ export function useD3ChartRenderer<T>(props: D3ChartProps<T>, deps: RendererDeps
               }
 
               // Update axes + grid
+              const xTickValues = resolveTickValues(xAxisConfig?.tickValues, newXScale as AnyScale);
+              const yTickValues = resolveTickValues(yAxisConfig?.tickValues, newYScale as AnyScale);
               renderAxes(layout, newXScale as AnyScale, newYScale as any, {
                 xTickFormat: xAxisConfig?.tickFormat,
                 yTickFormat: yAxisConfig?.tickFormat,
                 xTickCount: xAxisConfig?.tickCount,
                 yTickCount: yAxisConfig?.tickCount,
+                xTickValues,
+                yTickValues,
               });
               if (xAxisConfig?.customize) {
                 xAxisConfig.customize(layout.xAxisGroup);
@@ -426,6 +457,9 @@ export function useD3ChartRenderer<T>(props: D3ChartProps<T>, deps: RendererDeps
                 newXScale as AnyScale,
                 newYScale as any,
                 yAxisConfig?.tickCount ?? 5,
+                0,
+                xTickValues,
+                yTickValues,
               );
 
               // Update layers
diff --git a/packages/app/src/lib/d3-chart/chart-update.test.ts b/packages/app/src/lib/d3-chart/chart-update.test.ts
index a4a52b85..a8b3d012 100644
--- a/packages/app/src/lib/d3-chart/chart-update.test.ts
+++ b/packages/app/src/lib/d3-chart/chart-update.test.ts
@@ -51,6 +51,23 @@ describe('renderAxes', () => {
       expect(tickCount).toBeLessThanOrEqual(8);
     });
 
+    it('renders only explicit x tick values within the visible domain', () => {
+      const layout = makeLayout();
+      const xScale = d3.scaleLinear().domain([2, 10]).range([0, layout.width]);
+      const yScale = d3.scaleLinear().domain([0, 50]).range([layout.height, 0]);
+
+      renderAxes(layout, xScale, yScale, {
+        xTickValues: [1, 2, 4, 16],
+        xTickFormat: String,
+      });
+
+      const labels: string[] = [];
+      layout.xAxisGroup.selectAll('.tick text').each(function () {
+        labels.push(d3.select(this).text());
+      });
+      expect(labels).toEqual(['2', '4']);
+    });
+
     it('respects yTickCount', () => {
       const layout = makeLayout();
       const xScale = d3.scaleLinear().domain([0, 100]).range([0, layout.width]);
@@ -130,6 +147,26 @@ describe('renderAxes', () => {
     });
   });
 
+  describe('with log scales', () => {
+    it('uses measured geometric sweep values instead of generated log subdivisions', () => {
+      const layout = makeLayout();
+      const xScale = d3.scaleLog().base(2).domain([0.9, 70]).range([0, layout.width]);
+      const yScale = d3.scaleLinear().domain([0, 50]).range([layout.height, 0]);
+      const measuredValues = [1, 2, 4, 8, 16, 32, 64];
+
+      renderAxes(layout, xScale, yScale, {
+        xTickValues: measuredValues,
+        xTickFormat: String,
+      });
+
+      const labels: string[] = [];
+      layout.xAxisGroup.selectAll('.tick text').each(function () {
+        labels.push(d3.select(this).text());
+      });
+      expect(labels).toEqual(measuredValues.map(String));
+    });
+  });
+
   describe('with band scales', () => {
     it('renders band scale on x-axis', () => {
       const layout = makeLayout();
@@ -281,6 +318,24 @@ describe('renderGrid', () => {
       expect(vLines).toBeGreaterThan(0);
     });
 
+    it('uses explicit x tick values for vertical grid lines', () => {
+      const layout = makeLayout();
+      const xScale = d3.scaleLog().base(2).domain([1, 64]).range([0, layout.width]);
+      const yScale = d3.scaleLinear().domain([0, 50]).range([layout.height, 0]);
+      const measuredValues = [1, 4, 16, 64];
+
+      renderGrid(layout, xScale, yScale, 5, 0, measuredValues);
+
+      const positions: number[] = [];
+      layout.gridGroup
+        .select('.grid-v')
+        .selectAll('line')
+        .each(function () {
+          positions.push(Number(d3.select(this).attr('x1')));
+        });
+      expect(positions).toEqual(measuredValues.map((value) => xScale(value)));
+    });
+
     it('creates horizontal grid lines matching y-scale ticks', () => {
       const layout = makeLayout();
       const xScale = d3.scaleLinear().domain([0, 100]).range([0, layout.width]);
diff --git a/packages/app/src/lib/d3-chart/chart-update.ts b/packages/app/src/lib/d3-chart/chart-update.ts
index 45c458c7..fb79ac27 100644
--- a/packages/app/src/lib/d3-chart/chart-update.ts
+++ b/packages/app/src/lib/d3-chart/chart-update.ts
@@ -10,6 +10,8 @@ export interface AxisUpdateConfig {
   yTickFormat?: (d: d3.AxisDomain) => string;
   xTickCount?: number;
   yTickCount?: number;
+  xTickValues?: (number | Date)[];
+  yTickValues?: (number | Date)[];
   /** Override tick size for Y axis (default: 6, use 0 for band scales). */
   yTickSize?: number;
   /** When set, axes animate to new positions over this duration (ms). */
@@ -23,8 +25,16 @@ export function renderAxes(
   yScale: ContinuousScale | d3.ScaleBand<string>,
   config: AxisUpdateConfig,
 ): void {
-  const { xTickFormat, yTickFormat, xTickCount, yTickCount, yTickSize, transitionDuration } =
-    config;
+  const {
+    xTickFormat,
+    yTickFormat,
+    xTickCount,
+    yTickCount,
+    xTickValues,
+    yTickValues,
+    yTickSize,
+    transitionDuration,
+  } = config;
   const dur = transitionDuration ?? 0;
 
   // X axis
@@ -36,6 +46,9 @@ export function renderAxes(
   } else {
     const gen = d3.axisBottom(xScale as ContinuousScale).tickSize(6);
     if (xTickCount) gen.ticks(xTickCount);
+    if (xTickValues) {
+      gen.tickValues(visibleTickValues(xScale, xTickValues) as Iterable<d3.NumberValue>);
+    }
     if (xTickFormat) gen.tickFormat(xTickFormat as any);
     xAxisGen = gen as unknown as d3.Axis<d3.AxisDomain>;
   }
@@ -54,6 +67,9 @@ export function renderAxes(
   } else {
     const yAxisGen = d3.axisLeft(yScale as ContinuousScale).tickSize(yTickSize ?? 6);
     if (yTickCount) yAxisGen.ticks(yTickCount);
+    if (yTickValues) {
+      yAxisGen.tickValues(visibleTickValues(yScale, yTickValues) as Iterable<d3.NumberValue>);
+    }
     if (yTickFormat) yAxisGen.tickFormat(yTickFormat as any);
     const yTarget = dur > 0 ? layout.yAxisGroup.transition().duration(dur) : layout.yAxisGroup;
     (yTarget as any).call(yAxisGen as any);
@@ -67,6 +83,8 @@ export function renderGrid(
   yScale: ContinuousScale | d3.ScaleBand<string>,
   yTickCount?: number,
   transitionDuration = 0,
+  xTickValues?: (number | Date)[],
+  yTickValues?: (number | Date)[],
 ): void {
   const { width, height, gridGroup } = layout;
   const dur = transitionDuration;
@@ -87,7 +105,9 @@ export function renderGrid(
       .attr('y2', height);
   } else {
     const tickScale = xScale as { ticks: (count?: number) => number[]; (v: number): number };
-    const xTicks = tickScale.ticks();
+    const xTicks = xTickValues
+      ? (visibleTickValues(xScale, xTickValues) as number[])
+      : tickScale.ticks();
     const vJoin = vGroup
       .selectAll<SVGLineElement, number>('line')
       .data(xTicks)
@@ -126,7 +146,9 @@ export function renderGrid(
       .attr('y2', (d) => (bandScale(d) || 0) + bandScale.bandwidth() / 2)
       .style('stroke-width', 0.5);
   } else {
-    const yTicks = yScale.ticks(yTickCount ?? 5);
+    const yTicks = yTickValues
+      ? (visibleTickValues(yScale, yTickValues) as number[])
+      : yScale.ticks(yTickCount ?? 5);
     const hJoin = hGroup
       .selectAll<SVGLineElement, number>('line')
       .data(yTicks)
@@ -149,3 +171,18 @@ export function renderGrid(
       .attr('y2', (d: number) => yScale(d));
   }
 }
+
+function visibleTickValues(
+  scale: ContinuousScale | d3.ScaleTime<number, number>,
+  values: (number | Date)[],
+): (number | Date)[] {
+  const domain = scale.domain();
+  const start = Number(domain[0]);
+  const end = Number(domain.at(-1));
+  const min = Math.min(start, end);
+  const max = Math.max(start, end);
+  return values.filter((value) => {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) && numeric >= min && numeric <= max;
+  });
+}
diff --git a/packages/app/src/lib/dynamic-colors.test.ts b/packages/app/src/lib/dynamic-colors.test.ts
new file mode 100644
index 00000000..52550a09
--- /dev/null
+++ b/packages/app/src/lib/dynamic-colors.test.ts
@@ -0,0 +1,48 @@
+import { describe, expect, it } from 'vitest';
+
+import { VENDOR_OKLCH_ZONES } from '@semianalysisai/inferencex-constants';
+
+import { generateVendorColors, getVendor } from './dynamic-colors';
+
+function hueOf(color: string): number {
+  const match = /^oklch\([\d.]+ [\d.]+ (?<hue>[\d.]+)\)$/.exec(color);
+  expect(match, `expected oklch color, got ${color}`).not.toBeNull();
+  return Number(match!.groups!.hue);
+}
+
+describe('getVendor', () => {
+  it('classifies registered GPU base keys through GPU_VENDORS', () => {
+    expect(getVendor('h100_vllm')).toBe('nvidia');
+    expect(getVendor('mi300x_sglang')).toBe('amd');
+  });
+
+  it('classifies keys that lead with a literal vendor token', () => {
+    // CollectiveX series keys carry the dataset's explicit vendor rather than a
+    // registered GPU key (their SKUs, e.g. "h200-dgxc", are not registry keys).
+    expect(getVendor('nvidia_h200-dgxc_normal_ep8')).toBe('nvidia');
+    expect(getVendor('amd_mi355x-oam_normal_ep8')).toBe('amd');
+  });
+
+  it('falls back to unknown for unclassifiable keys', () => {
+    expect(getVendor('h200-dgxc_normal_ep8')).toBe('unknown');
+  });
+});
+
+describe('generateVendorColors', () => {
+  it('places vendor-prefixed keys in their vendor hue zones', () => {
+    const colors = generateVendorColors(['nvidia_series-a', 'amd_series-b'], 'light');
+    const nvidia = VENDOR_OKLCH_ZONES.nvidia;
+    const amd = VENDOR_OKLCH_ZONES.amd;
+    expect(hueOf(colors['nvidia_series-a'])).toBeGreaterThanOrEqual(nvidia.start);
+    expect(hueOf(colors['nvidia_series-a'])).toBeLessThanOrEqual(nvidia.end);
+    expect(hueOf(colors['amd_series-b'])).toBeGreaterThanOrEqual(amd.start);
+    expect(hueOf(colors['amd_series-b'])).toBeLessThanOrEqual(amd.end);
+  });
+
+  it('keeps unclassifiable keys in the unknown zone', () => {
+    const colors = generateVendorColors(['mystery_series'], 'dark');
+    const unknown = VENDOR_OKLCH_ZONES.unknown;
+    expect(hueOf(colors['mystery_series'])).toBeGreaterThanOrEqual(unknown.start);
+    expect(hueOf(colors['mystery_series'])).toBeLessThanOrEqual(unknown.end);
+  });
+});
diff --git a/packages/app/src/lib/dynamic-colors.ts b/packages/app/src/lib/dynamic-colors.ts
index 38b9e10e..d788c8fd 100644
--- a/packages/app/src/lib/dynamic-colors.ts
+++ b/packages/app/src/lib/dynamic-colors.ts
@@ -20,6 +20,9 @@ export type Vendor = 'nvidia' | 'amd' | 'unknown';
 export function getVendor(hwKey: string): Vendor {
   // hwKey may have a framework suffix (e.g. "h100_vllm") — strip it to get the GPU base key
   const base = hwKey.split('_')[0];
+  // Keys whose dataset carries an explicit vendor (e.g. CollectiveX series) lead
+  // with the vendor name itself rather than a registered GPU key.
+  if (base === 'nvidia' || base === 'amd') return base;
   const vendor = GPU_VENDORS[base];
   if (vendor === 'NVIDIA') return 'nvidia';
   if (vendor === 'AMD') return 'amd';
diff --git a/packages/app/src/lib/i18n.test.ts b/packages/app/src/lib/i18n.test.ts
index 36a9fde3..7d89f66b 100644
--- a/packages/app/src/lib/i18n.test.ts
+++ b/packages/app/src/lib/i18n.test.ts
@@ -42,6 +42,7 @@ describe('hasZhSibling', () => {
     expect(hasZhSibling('/inference')).toBe(true);
     expect(hasZhSibling('/overview')).toBe(true);
     expect(hasZhSibling('/about')).toBe(true);
+    expect(hasZhSibling('/collectivex')).toBe(true);
   });
 
   it('matches blog and compare child paths', () => {
@@ -73,6 +74,7 @@ describe('switchLocalePath', () => {
   it('switches English pages to their zh sibling', () => {
     expect(switchLocalePath('/')).toBe('/zh');
     expect(switchLocalePath('/inference')).toBe('/zh/inference');
+    expect(switchLocalePath('/collectivex')).toBe('/zh/collectivex');
     expect(switchLocalePath('/overview')).toBe('/zh/overview');
     expect(switchLocalePath('/blog/some-post')).toBe('/zh/blog/some-post');
   });
@@ -80,6 +82,7 @@ describe('switchLocalePath', () => {
   it('switches zh pages back to English', () => {
     expect(switchLocalePath('/zh')).toBe('/');
     expect(switchLocalePath('/zh/quotes')).toBe('/quotes');
+    expect(switchLocalePath('/zh/collectivex')).toBe('/collectivex');
     expect(switchLocalePath('/zh/overview')).toBe('/overview');
     expect(switchLocalePath('/zh/blog/some-post')).toBe('/blog/some-post');
   });
diff --git a/packages/app/src/lib/i18n.ts b/packages/app/src/lib/i18n.ts
index 7577353b..5740981d 100644
--- a/packages/app/src/lib/i18n.ts
+++ b/packages/app/src/lib/i18n.ts
@@ -45,6 +45,7 @@ export const ZH_MIRRORED_ROUTES: readonly { path: string; exact?: boolean }[] =
   { path: '/reliability', exact: true },
   { path: '/gpu-specs', exact: true },
   { path: '/gpu-metrics', exact: true },
+  { path: '/collectivex', exact: true },
   { path: '/submissions', exact: true },
   { path: '/ai-chart', exact: true },
   { path: '/current-inferencex-image', exact: true },
diff --git a/packages/app/src/lib/tab-meta-zh.ts b/packages/app/src/lib/tab-meta-zh.ts
index 3c50362d..69014c1d 100644
--- a/packages/app/src/lib/tab-meta-zh.ts
+++ b/packages/app/src/lib/tab-meta-zh.ts
@@ -17,6 +17,7 @@ export const ZH_TAB_KEYS = [
   'reliability',
   'gpu-specs',
   'gpu-metrics',
+  'collectivex',
   'submissions',
   'ai-chart',
   'current-inferencex-image',
@@ -62,6 +63,11 @@ export const TAB_META_ZH: Record<ZhTabKey, { title: string; description: string
     title: 'GPU 功耗与能效指标',
     description: 'AI 推理负载下的 GPU 功耗与能效指标。跨硬件对比每瓦 token 数。',
   },
+  collectivex: {
+    title: 'CollectiveX 通信基准测试',
+    description:
+      '跨 NVIDIA 与 AMD GPU 平台对比专家并行（EP）通信性能，包括混合专家（MoE）分发（dispatch）、合并（combine）延迟与逻辑载荷速率。',
+  },
   submissions: {
     title: '基准测试提交记录',
     description:
@@ -102,6 +108,8 @@ export const TAB_INTRO_ZH: Record<ZhTabKey, string> = {
     '本页面提供 GPU 规格对比：NVIDIA、AMD 等厂商加速器的显存容量、显存带宽、FLOPS、互连拓扑与功耗规格。',
   'gpu-metrics':
     '本页面展示 GPU 功耗与能效指标（PowerX）：推理负载下的实测功耗、每瓦 token 数与每兆瓦 token 产出。',
+  collectivex:
+    '本页面展示 CollectiveX 专家并行（EP）通信基准测试结果：在统一工作负载、正确性校验与采样协议下，对比 DeepEP、MoRI、UCCL 及 NCCL/RCCL 参考实现的分发（dispatch）、合并（combine）与完整往返延迟。跨芯片速率均按逻辑载荷计算；只有发布器确认完整且稳定的官方队列才会生成排名与推荐。',
   submissions:
     '本页面列出提交到 InferenceX 的全部基准测试配置：按 GPU 厂商查看提交历史、活动趋势与数据点数量。',
   'ai-chart':
@@ -122,6 +130,7 @@ export const TAB_LABELS_ZH: Record<string, string> = {
   reliability: '可靠性',
   'gpu-specs': 'GPU 规格',
   'gpu-metrics': 'GPU 功耗',
+  collectivex: 'CollectiveX 通信',
   submissions: '提交记录',
   'ai-chart': 'AI 图表',
   'current-inferencex-image': '镜像',
diff --git a/packages/app/src/lib/tab-meta.ts b/packages/app/src/lib/tab-meta.ts
index b312a6e7..5d641b23 100644
--- a/packages/app/src/lib/tab-meta.ts
+++ b/packages/app/src/lib/tab-meta.ts
@@ -16,6 +16,7 @@ export const VALID_TABS = [
   'calculator',
   'reliability',
   'gpu-specs',
+  'collectivex',
   'ai-chart',
   'gpu-metrics',
   'submissions',
@@ -56,6 +57,11 @@ export const TAB_META: Record<TabKey, { title: string; description: string }> =
     description:
       'Detailed GPU specifications for AI inference. Compare NVIDIA, AMD, and Intel GPUs — memory bandwidth, FLOPS, interconnects, and topology.',
   },
+  collectivex: {
+    title: 'CollectiveX Communication Benchmarks',
+    description:
+      'Experimental cross-vendor expert-parallel communication benchmarks. Compare MoE dispatch and combine latency across NVIDIA and AMD GPU platforms.',
+  },
   'ai-chart': {
     title: 'AI-Powered Chart Generation',
     description:
diff --git a/packages/db/migrations-collectivex/001_initial_schema.sql b/packages/db/migrations-collectivex/001_initial_schema.sql
new file mode 100644
index 00000000..71bc5397
--- /dev/null
+++ b/packages/db/migrations-collectivex/001_initial_schema.sql
@@ -0,0 +1,38 @@
+-- CollectiveX sweep runs, stored as RAW artifact documents.
+--
+-- The sweep JSON contract is expected to change; the shared reader
+-- (packages/db/src/collectivex/reader.ts) is the single transform point and
+-- runs at API-read time, so rows here are the artifacts' documents verbatim.
+-- `summary` is the one precomputed column (CollectiveXRunSummary) so the run
+-- picker can list runs without loading their documents.
+
+create table cx_runs (
+  run_id        bigint      primary key,
+  run_attempt   int         not null,
+  version       int         not null,
+  generated_at  timestamptz not null,
+  source_sha    text        not null,
+  source_branch text,
+  conclusion    text,
+  matrix        jsonb       not null,
+  summary       jsonb       not null,
+  ingested_at   timestamptz not null default now(),
+  -- Tombstone: runs are discovered lazily from GitHub on read, so a deleted
+  -- run must leave a marker or the next discovery would re-ingest it.
+  -- Deletion clears cx_run_docs but keeps this row with deleted_at set.
+  deleted_at    timestamptz
+);
+
+-- "Latest run per version" ordering: run_id desc. GitHub run ids increase
+-- monotonically with run creation, so this matches lazy discovery's
+-- newest-first walk — unlike completion time (generated_at), where a
+-- long-failing older run can outlast a newer successful one.
+create index cx_runs_version_latest on cx_runs (version, run_id desc);
+
+create table cx_run_docs (
+  id     bigserial primary key,
+  run_id bigint    not null references cx_runs(run_id) on delete cascade,
+  doc    jsonb     not null
+);
+
+create index cx_run_docs_run on cx_run_docs (run_id);
diff --git a/packages/db/migrations-collectivex/002_docs_attempt.sql b/packages/db/migrations-collectivex/002_docs_attempt.sql
new file mode 100644
index 00000000..443c5d94
--- /dev/null
+++ b/packages/db/migrations-collectivex/002_docs_attempt.sql
@@ -0,0 +1,17 @@
+-- Stamp each raw document with the run attempt that produced it.
+--
+-- Readers join docs on the cx_runs row's CURRENT attempt, which makes both
+-- refresh races harmless: a concurrent pair of attempt-refreshes can leave
+-- superseded docs behind (single-snapshot CTE deletes can miss rows written
+-- after the statement's snapshot), and a reader can straddle a refresh across
+-- its row/doc reads — in both cases the attempt filter hides stale documents.
+-- Leftover superseded docs are garbage-collected by the next refresh's DELETE.
+
+alter table cx_run_docs add column run_attempt int;
+
+update cx_run_docs d
+set run_attempt = r.run_attempt
+from cx_runs r
+where r.run_id = d.run_id and d.run_attempt is null;
+
+alter table cx_run_docs alter column run_attempt set not null;
diff --git a/packages/db/package.json b/packages/db/package.json
index aaeb17c5..ae929456 100644
--- a/packages/db/package.json
+++ b/packages/db/package.json
@@ -5,6 +5,7 @@
   "type": "module",
   "sideEffects": false,
   "exports": {
+    "./collectivex/*": "./src/collectivex/*.ts",
     "./connection": "./src/connection.ts",
     "./etl/*": "./src/etl/*.ts",
     "./lib/*": "./src/lib/*.ts",
@@ -14,10 +15,12 @@
   "scripts": {
     "db:prepare:ci": "tsx src/prepare-ci-artifacts.ts",
     "db:ingest:ci": "tsx src/ingest-ci-run.ts",
+    "db:ingest:collectivex": "dotenv -e ../../.env -- tsx src/ingest-collectivex.ts --download",
     "db:ingest:run": "dotenv -e ../../.env -- tsx src/ingest-ci-run.ts --download",
     "db:ingest:gcs": "dotenv -e ../../.env -- tsx src/ingest-gcs-backup.ts",
     "db:ingest:supplemental": "dotenv -e ../../.env -- tsx src/ingest-supplemental.ts",
     "db:migrate": "dotenv -e ../../.env -- tsx src/migrate.ts",
+    "db:migrate:collectivex": "dotenv -e ../../.env -- tsx src/migrate-collectivex.ts",
     "db:apply-overrides": "dotenv -e ../../.env -- tsx src/apply-overrides.ts",
     "db:backfill-aggregate-stats": "dotenv -e ../../.env -- tsx src/backfill-aggregate-stats.ts",
     "db:backfill-chart-series": "dotenv -e ../../.env -- tsx src/backfill-chart-series.ts",
diff --git a/packages/db/src/collectivex/artifact-selection.test.ts b/packages/db/src/collectivex/artifact-selection.test.ts
new file mode 100644
index 00000000..3c6d8321
--- /dev/null
+++ b/packages/db/src/collectivex/artifact-selection.test.ts
@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest';
+
+import { matrixArtifactName, selectShardArtifactNames } from './artifact-selection';
+
+describe('selectShardArtifactNames', () => {
+  it('selects one artifact per cell, sorted by name', () => {
+    expect(
+      selectShardArtifactNames(
+        ['cxshard-b-160-1', 'cxshard-a-160-1', 'cxsweep-matrix-160'],
+        '160',
+        1,
+      ),
+    ).toEqual(['cxshard-a-160-1', 'cxshard-b-160-1']);
+  });
+
+  it('prefers the highest attempt not above the run attempt', () => {
+    const names = ['cxshard-a-160-1', 'cxshard-a-160-2', 'cxshard-a-160-3', 'cxshard-b-160-1'];
+    expect(selectShardArtifactNames(names, '160', 2)).toEqual([
+      'cxshard-a-160-2',
+      'cxshard-b-160-1',
+    ]);
+  });
+
+  it('keeps cells with hyphenated names intact across run-id collisions', () => {
+    // A cell name may itself contain "-<digits>" fragments; only the trailing
+    // "-{runId}-{attempt}" is structural.
+    const names = ['cxshard-h200-ep8-160-1', 'cxshard-h200-ep8-161-1'];
+    expect(selectShardArtifactNames(names, '160', 1)).toEqual(['cxshard-h200-ep8-160-1']);
+  });
+
+  it('ignores foreign names and zero attempts', () => {
+    expect(
+      selectShardArtifactNames(['cxshard-a-160-0', 'other-160-1', 'cxshard-a-999-1'], '160', 1),
+    ).toEqual([]);
+  });
+});
+
+describe('matrixArtifactName', () => {
+  it('derives the per-run matrix artifact name', () => {
+    expect(matrixArtifactName('160')).toBe('cxsweep-matrix-160');
+  });
+});
diff --git a/packages/db/src/collectivex/artifact-selection.ts b/packages/db/src/collectivex/artifact-selection.ts
new file mode 100644
index 00000000..5f94faea
--- /dev/null
+++ b/packages/db/src/collectivex/artifact-selection.ts
@@ -0,0 +1,41 @@
+/**
+ * CollectiveX sweep artifact naming and selection. Pure helpers shared by the
+ * ingest script and its tests.
+ *
+ * The sweep uploads two artifact families per run:
+ *   cxsweep-matrix-{run_id}            — one matrix document
+ *   cxshard-{cell}-{run_id}-{attempt}  — case-attempt documents per matrix cell
+ */
+
+export const MATRIX_PREFIX = 'cxsweep-matrix-';
+export const SHARD_PREFIX = 'cxshard-';
+
+export function matrixArtifactName(runId: string): string {
+  return `${MATRIX_PREFIX}${runId}`;
+}
+
+/**
+ * Pick the shard artifact names to ingest: keep the highest attempt ≤ the
+ * run's current attempt per cell (a re-run attempt supersedes its
+ * predecessors; attempts above the run's own attempt cannot legitimately
+ * exist and are ignored).
+ */
+export function selectShardArtifactNames(
+  names: readonly string[],
+  runId: string,
+  runAttempt: number,
+): string[] {
+  const pattern = new RegExp(`^${SHARD_PREFIX}(?<cell>.+)-${runId}-(?<attempt>[1-9][0-9]*)$`, 'u');
+  const selected = new Map<string, { name: string; attempt: number }>();
+  for (const name of names) {
+    const match = pattern.exec(name);
+    if (!match) continue;
+    const attempt = Number(match.groups!.attempt);
+    if (attempt > runAttempt) continue;
+    const previous = selected.get(match.groups!.cell);
+    if (!previous || attempt > previous.attempt) {
+      selected.set(match.groups!.cell, { name, attempt });
+    }
+  }
+  return [...selected.values()].map((entry) => entry.name).toSorted();
+}
diff --git a/packages/db/src/collectivex/reader.test.ts b/packages/db/src/collectivex/reader.test.ts
new file mode 100644
index 00000000..59e097b6
--- /dev/null
+++ b/packages/db/src/collectivex/reader.test.ts
@@ -0,0 +1,200 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildDatasetFromNeutral } from './reader';
+import {
+  buildDataset,
+  makeCollectiveXDataset,
+  makeCollectiveXSeries,
+  makeInvalidCaseAttempt,
+  makeRawMatrix,
+  makeRawShard,
+  makeRunMeta,
+} from './test-fixture';
+
+function requestedOf(shard: Record<string, unknown>) {
+  const identity = shard.identity as {
+    case_id: string;
+    case_factors: { sku: string; case: Record<string, unknown> };
+  };
+  return {
+    caseId: identity.case_id,
+    sku: identity.case_factors.sku,
+    disposition: 'runnable' as const,
+    case: identity.case_factors.case,
+  };
+}
+
+describe('CollectiveX artifact assembly', () => {
+  it('builds the current view from matrix cases and result shards', () => {
+    const dataset = makeCollectiveXDataset();
+    expect(dataset.version).toBe(1);
+    expect(dataset.series).toHaveLength(3);
+    expect(dataset.coverage).toHaveLength(5);
+    expect(dataset.run).toMatchObject({
+      requested_cases: 5,
+      measured_cases: 3,
+      unsupported_cases: 1,
+      terminal_cases: 4,
+      measured_points: 30,
+      terminal_points: 40,
+      requested_points: 50,
+    });
+  });
+
+  it('maps series identity and points', () => {
+    const series = makeCollectiveXSeries();
+    expect(series.series_id).toBe('h200-dgxc-deepep-v2-deepseek-v3-normal-decode-ep8-uniform-bf16');
+    expect(series.backend).toBe('deepep-v2');
+    expect(series.precision).toBe('bf16');
+    expect(series.points).toHaveLength(10);
+  });
+
+  it('keeps bf16 and fp8 measurements of one cell as distinct labeled cases', () => {
+    const dataset = makeCollectiveXDataset();
+    const h200 = dataset.series.filter((series) => series.system.sku === 'h200-dgxc');
+    expect(h200.map((series) => series.precision).toSorted()).toEqual(['bf16', 'fp8']);
+    expect(new Set(h200.map((series) => series.series_id)).size).toBe(2);
+    expect(dataset.coverage.find((row) => row.precision === 'fp8')).toMatchObject({
+      case_id: 'h200-dgxc-deepep-v2-deepseek-v3-normal-decode-ep8-uniform-fp8',
+      label: 'h200-dgxc · deepep-v2 · normal · decode · EP8 · fp8',
+    });
+    expect(
+      dataset.coverage.find(
+        (row) => row.case_id === 'h200-dgxc-deepep-v2-deepseek-v3-normal-decode-ep8-uniform-bf16',
+      ),
+    ).toMatchObject({
+      precision: 'bf16',
+      label: 'h200-dgxc · deepep-v2 · normal · decode · EP8 · bf16',
+    });
+  });
+
+  it('defaults pre-FP8 artifacts without a precision field to bf16', () => {
+    const dataset = buildDataset({ shards: [makeRawShard({ precision: null })] });
+    expect(dataset.series[0].series_id).toBe(
+      'h200-dgxc-deepep-v2-deepseek-v3-normal-decode-ep8-uniform',
+    );
+    expect(dataset.series[0].precision).toBe('bf16');
+    expect(dataset.coverage[0]).toMatchObject({
+      precision: 'bf16',
+      label: 'h200-dgxc · deepep-v2 · normal · decode · EP8 · bf16',
+    });
+  });
+
+  it('keeps normal and low-latency measurements of one cell as distinct labeled cases', () => {
+    const dataset = buildDataset({
+      shards: [makeRawShard(), makeRawShard({ mode: 'low-latency' })],
+    });
+    expect(new Set(dataset.series.map((series) => series.series_id)).size).toBe(2);
+    expect(dataset.series.map((series) => series.mode).toSorted()).toEqual([
+      'low-latency',
+      'normal',
+    ]);
+    expect(dataset.coverage.find((row) => row.mode === 'low-latency')).toMatchObject({
+      case_id: 'h200-dgxc-deepep-v2-deepseek-v3-low-latency-decode-ep8-uniform-bf16',
+      label: 'h200-dgxc · deepep-v2 · low-latency · decode · EP8 · bf16',
+    });
+  });
+
+  it('defaults pre-LL artifacts without a mode field to normal kernels', () => {
+    const dataset = buildDataset({ shards: [makeRawShard({ mode: null })] });
+    expect(dataset.series[0].mode).toBe('normal');
+    expect(dataset.coverage[0].mode).toBe('normal');
+  });
+
+  it('ignores non-result documents', () => {
+    const shard = makeRawShard();
+    const dataset = buildDatasetFromNeutral(
+      makeRawMatrix([requestedOf(shard)]),
+      [shard, { record_type: 'samples', rows: [] }],
+      makeRunMeta(),
+    );
+    expect(dataset.series).toHaveLength(1);
+  });
+
+  it('normalizes in-band failure reasons', () => {
+    const dataset = buildDataset({
+      shards: [
+        makeInvalidCaseAttempt({ reasons: ['semantic correctness or routing identity failed'] }),
+      ],
+    });
+    expect(dataset.series).toHaveLength(0);
+    expect(dataset.coverage[0]).toMatchObject({
+      outcome: 'invalid',
+      reason: 'semantic-correctness-or-routing-identity-failed',
+    });
+  });
+
+  it('keeps capacity-limited points omitted by a successful backend', () => {
+    const dataset = buildDataset({
+      shards: [
+        makeRawShard({
+          phase: 'prefill',
+          rows: [{ tokensPerRank: 256 }, { tokensPerRank: 512 }],
+        }),
+      ],
+    });
+    expect(dataset.coverage[0].points.map((point) => point.terminal_status)).toEqual([
+      'measured',
+      'measured',
+      'unsupported',
+      'unsupported',
+    ]);
+    expect(dataset.coverage[0].points.at(-1)).toMatchObject({
+      tokens_per_rank: 2048,
+      reason: 'backend-token-capacity',
+    });
+  });
+
+  it('keeps unsupported and pending cases distinct', () => {
+    const dataset = makeCollectiveXDataset();
+    expect(dataset.coverage.find((row) => row.sku === 'b300')).toMatchObject({
+      outcome: 'unsupported',
+      reason: 'backend-platform-unsupported',
+      detail: 'unsupported by the selected backend/platform',
+    });
+    expect(dataset.coverage.find((row) => row.sku === 'b200-dgxc')).toMatchObject({
+      outcome: 'pending',
+      reason: 'pending',
+    });
+  });
+
+  it('maps an nccl-ep backend series (the 4th pluggable backend)', () => {
+    const series = makeCollectiveXSeries({ backend: 'nccl-ep', implName: 'nccl-ep' });
+    expect(series.backend).toBe('nccl-ep');
+    expect(series.series_id).toContain('nccl-ep');
+    expect(series.points).toHaveLength(10);
+  });
+
+  it('derives a per-GPU payload bandwidth from total_logical_bytes', () => {
+    const dispatch = makeCollectiveXSeries().points[0].components.dispatch;
+    // total_logical_bytes (400000000) / ep (8) / p50 latency (417 µs) → GB/s.
+    expect(dispatch?.payload_data_rate_gbps_at_latency_percentile?.p50).toBeCloseTo(
+      (400000000 / 8 / 417) * 1e-3,
+      3,
+    );
+    // Distinct from the aggregate activation rate (activation bytes, no ep split):
+    // the payload rate reads total_logical_bytes and divides by the EP world size.
+    expect(dispatch?.payload_data_rate_gbps_at_latency_percentile?.p50).not.toBeCloseTo(
+      dispatch?.activation_data_rate_gbps_at_latency_percentile?.p50 ?? 0,
+      1,
+    );
+  });
+
+  it('does not invent rates for zero-byte or unavailable components', () => {
+    const zeroStage = makeCollectiveXSeries({ rows: [{ stageZeroBytes: true }] }).points[0]
+      .components.stage;
+    expect(zeroStage?.activation_data_rate_gbps_at_latency_percentile?.p50).toBe(0);
+    expect(
+      makeCollectiveXSeries({ rows: [{ stageUnavailable: true }] }).points[0].components.stage,
+    ).toBeNull();
+  });
+
+  it('rejects malformed and cross-version artifacts', () => {
+    expect(() => buildDatasetFromNeutral({}, [], makeRunMeta())).toThrow(/matrix/);
+    const shard = makeRawShard();
+    shard.version = 2;
+    expect(() =>
+      buildDatasetFromNeutral(makeRawMatrix([requestedOf(shard)]), [shard], makeRunMeta()),
+    ).toThrow(/version/);
+  });
+});
diff --git a/packages/db/src/collectivex/reader.ts b/packages/db/src/collectivex/reader.ts
new file mode 100644
index 00000000..5cec68a0
--- /dev/null
+++ b/packages/db/src/collectivex/reader.ts
@@ -0,0 +1,390 @@
+/**
+ * CollectiveX neutral-contract reader: assembles the dashboard dataset from a
+ * sweep run's raw matrix + case-attempt docs. Shared by the ingest script
+ * (validation + summary precompute) and the app's API routes (assembly at
+ * read time), so the transform can never drift between the two.
+ *
+ * The sweep JSON contract is expected to change; when it does, update this
+ * reader (and bump the `version` tag in the harness's sweep config). Raw docs
+ * are stored untouched in the DB, so reader fixes retroactively apply to
+ * already-ingested runs.
+ */
+
+import type {
+  CollectiveXComponent,
+  CollectiveXCoverage,
+  CollectiveXCoveragePoint,
+  CollectiveXDataset,
+  CollectiveXMode,
+  CollectiveXOutcome,
+  CollectiveXPercentiles,
+  CollectiveXPoint,
+  CollectiveXPrecision,
+  CollectiveXRunSummary,
+  CollectiveXSeries,
+  CollectiveXTerminalStatus,
+} from './types';
+
+interface RawCase {
+  case_id?: string;
+  backend: string;
+  ep: number;
+  gpus_per_node: number;
+  ladder: string;
+  nodes: number;
+  mode?: string;
+  phase: string;
+  precision?: string;
+  topology_class: string;
+  scale_up_domain: number;
+  scale_up_transport: string;
+  scale_out_transport: string | null;
+}
+
+interface RawComponent {
+  availability: string;
+  percentiles_us: CollectiveXPercentiles | null;
+}
+
+interface RawRow {
+  tokens_per_rank: number;
+  global_tokens: number;
+  token_rate_at_latency_percentile: CollectiveXPercentiles;
+  components: Record<string, RawComponent | null>;
+  byte_provenance: Record<string, { activation_data_bytes: number; total_logical_bytes?: number }>;
+}
+
+interface RawShard {
+  version: number;
+  record_type: 'case-attempt';
+  identity: {
+    case_id: string;
+    case_factors: { sku: string; case: RawCase };
+  };
+  implementation: { name: string };
+  runtime: { vendor: string };
+  measurement: { rows: RawRow[] };
+  outcome: { status: string; reasons?: string[] };
+}
+
+interface RawMatrix {
+  version: number;
+  requested_cases: {
+    case: RawCase;
+    sku: string;
+    disposition: 'runnable' | 'unsupported';
+    reason?: string | null;
+    detail?: string | null;
+  }[];
+}
+
+export interface CollectiveXNeutralRunMeta {
+  run_id: string;
+  run_attempt: number;
+  generated_at: string;
+  conclusion: string | null;
+  source_sha: string;
+}
+
+function matrixOf(value: unknown): RawMatrix {
+  const matrix = value as RawMatrix;
+  if (!Number.isSafeInteger(matrix?.version) || !Array.isArray(matrix?.requested_cases)) {
+    throw new TypeError('invalid CollectiveX matrix');
+  }
+  return matrix;
+}
+
+function shardOf(value: unknown): RawShard | null {
+  if ((value as RawShard | null)?.record_type !== 'case-attempt') return null;
+  const shard = value as RawShard;
+  if (!shard.identity?.case_id || !Array.isArray(shard.measurement?.rows)) {
+    throw new TypeError('invalid CollectiveX shard');
+  }
+  return shard;
+}
+
+function toOutcome(status: string): CollectiveXOutcome {
+  return ['success', 'unsupported', 'failed', 'invalid', 'diagnostic', 'pending'].includes(status)
+    ? (status as CollectiveXOutcome)
+    : 'failed';
+}
+
+function toTerminalStatus(outcome: CollectiveXOutcome): CollectiveXTerminalStatus {
+  return outcome === 'success' ? 'measured' : outcome;
+}
+
+// Artifacts predating the FP8 dispatch dimension carry no precision field and
+// were all measured in bf16.
+function toPrecision(raw: string | undefined): CollectiveXPrecision {
+  return raw === 'fp8' ? 'fp8' : 'bf16';
+}
+
+// Artifacts predating the low-latency kernel dimension carry no mode field
+// and were all measured with the normal (throughput) kernels.
+function toMode(raw: string | undefined): CollectiveXMode {
+  return raw === 'low-latency' ? 'low-latency' : 'normal';
+}
+
+// GB/s = bytes / (latency_us * 1e-6) / 1e9 = (bytes / latency_us) * 1e-3. `divisor`
+// splits an aggregate world byte count into a per-GPU figure (divisor = ep_size).
+function ratesFrom(
+  bytes: number,
+  latency: CollectiveXPercentiles,
+  divisor = 1,
+): CollectiveXPercentiles {
+  const rate = (us: number) => (bytes / divisor / us) * 1e-3;
+  return {
+    p50: rate(latency.p50),
+    p90: rate(latency.p90),
+    p95: rate(latency.p95),
+    p99: rate(latency.p99),
+  };
+}
+
+function mapComponent(
+  raw: RawComponent | null | undefined,
+  bytes: { activation_data_bytes: number; total_logical_bytes?: number } | undefined,
+  ep: number,
+): CollectiveXComponent | null {
+  if (!raw?.percentiles_us || raw.availability === 'unavailable') return null;
+  // Byte counts are aggregate across the EP world (routed_copies = fanout.sum()).
+  // Activation rate stays aggregate (unchanged); payload rate is per-GPU over the
+  // full logical payload, falling back to activation bytes for pre-provenance
+  // artifacts that carry no total_logical_bytes.
+  const payloadBytes = bytes ? (bytes.total_logical_bytes ?? bytes.activation_data_bytes) : null;
+  return {
+    latency_us: raw.percentiles_us,
+    activation_data_rate_gbps_at_latency_percentile: bytes
+      ? ratesFrom(bytes.activation_data_bytes, raw.percentiles_us)
+      : null,
+    payload_data_rate_gbps_at_latency_percentile:
+      payloadBytes === null ? null : ratesFrom(payloadBytes, raw.percentiles_us, Math.max(1, ep)),
+    payload_bytes: payloadBytes,
+  };
+}
+
+function mapPoint(row: RawRow, ep: number): CollectiveXPoint {
+  const component = (name: string) =>
+    mapComponent(row.components[name], row.byte_provenance[name], ep);
+  return {
+    tokens_per_rank: row.tokens_per_rank,
+    global_tokens: row.global_tokens,
+    components: {
+      dispatch: component('dispatch'),
+      stage: component('stage'),
+      combine: component('combine'),
+      roundtrip: component('roundtrip'),
+    },
+    roundtrip_token_rate_at_latency_percentile: row.token_rate_at_latency_percentile,
+  };
+}
+
+function topologyOf(kase: RawCase) {
+  return {
+    ep_size: kase.ep,
+    nodes: kase.nodes,
+    gpus_per_node: kase.gpus_per_node,
+    scale_up_domain: kase.scale_up_domain,
+    scale_up_transport: kase.scale_up_transport,
+    scale_out_transport: kase.scale_out_transport,
+    topology_class: kase.topology_class,
+  };
+}
+
+function buildSeries(shard: RawShard): CollectiveXSeries {
+  const kase = shard.identity.case_factors.case;
+  return {
+    series_id: shard.identity.case_id,
+    phase: kase.phase === 'prefill' ? 'prefill' : 'decode',
+    mode: toMode(kase.mode),
+    precision: toPrecision(kase.precision),
+    backend: shard.implementation.name,
+    system: {
+      ...topologyOf(kase),
+      sku: shard.identity.case_factors.sku,
+      vendor: shard.runtime.vendor === 'amd' ? 'amd' : 'nvidia',
+    },
+    points: shard.measurement.rows.map((row) => mapPoint(row, kase.ep)),
+  };
+}
+
+function ladderTokens(kase: RawCase): number[] {
+  const values = kase.ladder
+    .split(/\s+/)
+    .map(Number)
+    .filter((value) => Number.isSafeInteger(value) && value > 0);
+  return values.length > 0 ? values : [kase.ep];
+}
+
+function reasonId(value: string): string {
+  return (
+    value
+      .toLowerCase()
+      .replaceAll(/[^a-z0-9.-]+/g, '-')
+      .replace(/^[^a-z0-9]+/, '')
+      .slice(0, 96) || 'unknown'
+  );
+}
+
+function measuredPoints(shard: RawShard, kase: RawCase): CollectiveXCoveragePoint[] {
+  const rows = new Map(shard.measurement.rows.map((row) => [row.tokens_per_rank, row]));
+  const largestMeasured = Math.max(...rows.keys());
+  return ladderTokens(kase).map((tokens) => {
+    const row = rows.get(tokens);
+    return row
+      ? {
+          tokens_per_rank: tokens,
+          global_tokens: row.global_tokens,
+          terminal_status: 'measured',
+          reason: null,
+        }
+      : {
+          tokens_per_rank: tokens,
+          global_tokens: tokens * kase.ep,
+          terminal_status: tokens > largestMeasured ? 'unsupported' : 'pending',
+          reason: tokens > largestMeasured ? 'backend-token-capacity' : 'not-measured',
+        };
+  });
+}
+
+function terminalPoints(
+  kase: RawCase,
+  status: CollectiveXTerminalStatus,
+  reason: string,
+): CollectiveXCoveragePoint[] {
+  return ladderTokens(kase).map((tokens) => ({
+    tokens_per_rank: tokens,
+    global_tokens: tokens * kase.ep,
+    terminal_status: status,
+    reason,
+  }));
+}
+
+export function buildDatasetFromNeutral(
+  matrixRaw: unknown,
+  docs: unknown[],
+  run: CollectiveXNeutralRunMeta,
+): CollectiveXDataset {
+  const matrix = matrixOf(matrixRaw);
+  const shards = docs.flatMap((doc) => {
+    const shard = shardOf(doc);
+    if (!shard) return [];
+    if (shard.version !== matrix.version) throw new Error('CollectiveX version mismatch');
+    return [shard];
+  });
+  const successful = new Map<string, RawShard>();
+  const terminal = new Map<string, RawShard>();
+  for (const shard of shards) {
+    const target = shard.outcome.status === 'success' ? successful : terminal;
+    if (!target.has(shard.identity.case_id)) target.set(shard.identity.case_id, shard);
+  }
+
+  const coverage: CollectiveXCoverage[] = matrix.requested_cases.flatMap((requested) => {
+    const kase = requested.case;
+    const caseId = kase.case_id;
+    if (!caseId) return [];
+    const measured = successful.get(caseId);
+    const failed = terminal.get(caseId);
+    let outcome: CollectiveXOutcome;
+    let reason: string | null;
+    let points: CollectiveXCoveragePoint[];
+    if (measured) {
+      outcome = 'success';
+      reason = null;
+      points = measuredPoints(measured, kase);
+    } else if (failed) {
+      outcome = toOutcome(failed.outcome.status);
+      reason = reasonId(failed.outcome.reasons?.[0] ?? outcome);
+      points = terminalPoints(kase, toTerminalStatus(outcome), reason);
+    } else if (requested.disposition === 'unsupported') {
+      outcome = 'unsupported';
+      reason = reasonId(requested.reason ?? outcome);
+      points = terminalPoints(kase, 'unsupported', reason);
+    } else {
+      outcome = 'pending';
+      reason = 'pending';
+      points = terminalPoints(kase, 'pending', reason);
+    }
+    const mode = toMode(kase.mode);
+    const precision = toPrecision(kase.precision);
+    return [
+      {
+        case_id: caseId,
+        label: `${requested.sku} · ${kase.backend} · ${mode} · ${kase.phase} · EP${kase.ep} · ${precision}`,
+        disposition: requested.disposition,
+        sku: requested.sku,
+        backend: kase.backend,
+        phase: kase.phase === 'prefill' ? 'prefill' : 'decode',
+        mode,
+        precision,
+        topology: topologyOf(kase),
+        points,
+        outcome,
+        reason,
+        detail: requested.detail ?? null,
+      },
+    ];
+  });
+  const points = coverage.flatMap((item) => item.points);
+  return {
+    version: matrix.version,
+    run: {
+      ...run,
+      requested_cases: coverage.length,
+      terminal_cases: coverage.filter((item) =>
+        item.points.every((point) => point.terminal_status !== 'pending'),
+      ).length,
+      measured_cases: coverage.filter((item) => item.outcome === 'success').length,
+      unsupported_cases: coverage.filter((item) => item.outcome === 'unsupported').length,
+      failed_cases: coverage.filter((item) =>
+        ['failed', 'invalid', 'diagnostic'].includes(item.outcome),
+      ).length,
+      requested_points: points.length,
+      terminal_points: points.filter((point) => point.terminal_status !== 'pending').length,
+      measured_points: points.filter((point) => point.terminal_status === 'measured').length,
+      covered_skus: [...new Set(coverage.map((item) => item.sku))].toSorted(),
+    },
+    coverage,
+    series: [...successful.values()].map(buildSeries),
+  };
+}
+
+export function buildRunSummary(dataset: CollectiveXDataset): CollectiveXRunSummary {
+  const { run } = dataset;
+  return {
+    run_id: run.run_id,
+    run_attempt: run.run_attempt,
+    generated_at: run.generated_at,
+    conclusion: run.conclusion,
+    covered_skus: run.covered_skus,
+    requested_cases: run.requested_cases,
+    measured_cases: run.measured_cases,
+    requested_points: run.requested_points,
+    terminal_points: run.terminal_points,
+    terminal_counts: {
+      measured: run.measured_cases,
+      unsupported: run.unsupported_cases,
+      failed: run.failed_cases,
+    },
+  };
+}
+
+/**
+ * Structural identity check for the matrix document (it carries no
+ * `record_type` tag): requested_cases[] + include[] arrays plus a valid
+ * numeric `version` — the content axis the frontend selects on.
+ */
+export function isMatrixDoc(doc: unknown): boolean {
+  const candidate = doc as { requested_cases?: unknown; include?: unknown } | null;
+  return (
+    Array.isArray(candidate?.requested_cases) &&
+    Array.isArray(candidate?.include) &&
+    matrixVersion(doc) !== null
+  );
+}
+
+/** Read the matrix doc's numeric version tag; null when absent or invalid. */
+export function matrixVersion(doc: unknown): number | null {
+  const value = (doc as { version?: unknown } | null)?.version;
+  return typeof value === 'number' && Number.isSafeInteger(value) && value > 0 ? value : null;
+}
diff --git a/packages/db/src/collectivex/test-fixture.ts b/packages/db/src/collectivex/test-fixture.ts
new file mode 100644
index 00000000..d627bb93
--- /dev/null
+++ b/packages/db/src/collectivex/test-fixture.ts
@@ -0,0 +1,253 @@
+import { buildDatasetFromNeutral, type CollectiveXNeutralRunMeta } from './reader';
+import type { CollectiveXDataset, CollectiveXSeries } from './types';
+
+type Json = Record<string, unknown>;
+
+const SOURCE_SHA = 'c'.repeat(40);
+const TOKEN_LADDERS = {
+  decode: '1 2 4 8 16 32 64 128 256 512',
+  prefill: '256 512 1024 2048',
+} as const;
+
+export interface RowOverrides {
+  tokensPerRank?: number;
+  globalTokens?: number;
+  stageUnavailable?: boolean;
+  stageZeroBytes?: boolean;
+}
+
+export interface ShardOverrides {
+  caseId?: string;
+  variant?: string;
+  sku?: string;
+  backend?: string;
+  implName?: string;
+  ep?: number;
+  phase?: string;
+  /** null models a pre-LL artifact: no mode field (the case_id keeps `normal`). */
+  mode?: string | null;
+  /** null models a pre-FP8 artifact: no precision field and no case_id suffix. */
+  precision?: string | null;
+  scaleUpTransport?: string;
+  scaleOutTransport?: string | null;
+  topologyClass?: string;
+  nodes?: number;
+  gpusPerNode?: number;
+  scaleUpDomain?: number;
+  vendor?: string;
+  workload?: string;
+  ladder?: string;
+  status?: string;
+  reasons?: string[];
+  rows?: RowOverrides[];
+}
+
+function percentiles(base: number): Json {
+  return { p50: base, p90: base * 1.08, p95: base * 1.12, p99: base * 1.2 };
+}
+
+function component(base: number): Json {
+  return { availability: 'measured', percentiles_us: percentiles(base) };
+}
+
+// `total` defaults to the activation count (the bf16 case, where there are no
+// scale bytes). Dispatch under FP8 carries extra scale bytes, so its total
+// exceeds activation — the fixture models that so tests can prove the payload
+// rate reads total_logical_bytes rather than activation_data_bytes.
+function bytes(activation: number, total: number = activation): Json {
+  return { activation_data_bytes: activation, total_logical_bytes: total };
+}
+
+function makeRawRow(index: number, row: RowOverrides, worldSize: number): Json {
+  const tokensPerRank = row.tokensPerRank ?? 128 * (index + 1);
+  const components: Json = {
+    dispatch: component(417 + index),
+    combine: component(392 + index),
+    roundtrip: component(921 + index),
+    stage: row.stageUnavailable
+      ? { availability: 'unavailable', percentiles_us: null }
+      : component(120 + index),
+  };
+  // Dispatch total exceeds activation (models FP8 scale bytes); combine is
+  // always bf16 (total == activation); roundtrip total is their sum.
+  const byteProvenance: Json = {
+    dispatch: bytes(384763904, 400000000),
+    combine: bytes(384763904),
+    roundtrip: bytes(769527808, 784763904),
+  };
+  if (!row.stageUnavailable) {
+    byteProvenance.stage = bytes(row.stageZeroBytes ? 0 : 192381952);
+  }
+  return {
+    tokens_per_rank: tokensPerRank,
+    global_tokens: row.globalTokens ?? tokensPerRank * worldSize,
+    token_rate_at_latency_percentile: percentiles(8_338_218),
+    components,
+    byte_provenance: byteProvenance,
+  };
+}
+
+function makeRawCase(options: ShardOverrides, caseId: string): Json {
+  const phase = options.phase === 'prefill' ? 'prefill' : 'decode';
+  return {
+    case_id: caseId,
+    backend: options.backend ?? 'deepep-v2',
+    ep: options.ep ?? 8,
+    gpus_per_node: options.gpusPerNode ?? 8,
+    ladder: options.ladder ?? TOKEN_LADDERS[phase],
+    nodes: options.nodes ?? 1,
+    ...(options.mode === null ? {} : { mode: options.mode ?? 'normal' }),
+    phase,
+    ...(options.precision === null ? {} : { precision: options.precision ?? 'bf16' }),
+    topology_class: options.topologyClass ?? 'h200-nvlink-island',
+    scale_up_domain: options.scaleUpDomain ?? 8,
+    scale_up_transport: options.scaleUpTransport ?? 'nvlink',
+    scale_out_transport: options.scaleOutTransport ?? null,
+  };
+}
+
+export function caseIdOf(options: ShardOverrides = {}): string {
+  if (options.caseId) return options.caseId;
+  const tail = options.variant ? `-${options.variant}` : '';
+  // Pre-LL artifacts (mode: null) still carried `normal` in their case_ids.
+  const mode = options.mode === null ? 'normal' : (options.mode ?? 'normal');
+  const precision = options.precision === null ? '' : `-${options.precision ?? 'bf16'}`;
+  return `${options.sku ?? 'h200-dgxc'}-${options.backend ?? 'deepep-v2'}-${options.workload ?? 'deepseek-v3'}-${mode}-${options.phase ?? 'decode'}-ep${options.ep ?? 8}-uniform${precision}${tail}`;
+}
+
+export function makeRawShard(options: ShardOverrides = {}): Json {
+  const caseId = caseIdOf(options);
+  const sku = options.sku ?? 'h200-dgxc';
+  const backend = options.backend ?? 'deepep-v2';
+  const phase = options.phase === 'prefill' ? 'prefill' : 'decode';
+  const ladder = options.ladder ?? TOKEN_LADDERS[phase];
+  const worldSize = (options.nodes ?? 1) * (options.gpusPerNode ?? 8);
+  const rows =
+    options.rows ?? ladder.split(/\s+/).map((tokens) => ({ tokensPerRank: Number(tokens) }));
+  return {
+    version: 1,
+    record_type: 'case-attempt',
+    identity: {
+      case_id: caseId,
+      case_factors: { sku, case: makeRawCase({ ...options, backend }, caseId) },
+    },
+    implementation: { name: options.implName ?? backend },
+    runtime: { vendor: options.vendor ?? 'nvidia' },
+    measurement: { rows: rows.map((row, index) => makeRawRow(index, row, worldSize)) },
+    outcome: {
+      status: options.status ?? 'success',
+      ...(options.reasons ? { reasons: options.reasons } : {}),
+    },
+  };
+}
+
+export function makeInvalidCaseAttempt(options: ShardOverrides = {}): Json {
+  return makeRawShard({ status: 'invalid', reasons: ['capability-gate'], ...options });
+}
+
+interface RequestedCaseSpec {
+  caseId: string;
+  sku: string;
+  disposition?: 'runnable' | 'unsupported';
+  reason?: string;
+  case: Json;
+}
+
+function requestedFromShard(shard: Json): RequestedCaseSpec {
+  const identity = shard.identity as Json;
+  const factors = identity.case_factors as Json;
+  return {
+    caseId: identity.case_id as string,
+    sku: factors.sku as string,
+    case: factors.case as Json,
+  };
+}
+
+export function makeRawMatrix(requested: RequestedCaseSpec[], version = 1): Json {
+  return {
+    version,
+    include: [],
+    requested_cases: requested.map((entry) => ({
+      case: entry.case,
+      sku: entry.sku,
+      disposition: entry.disposition ?? 'runnable',
+      reason: entry.reason ?? null,
+      detail: entry.reason ? 'unsupported by the selected backend/platform' : null,
+    })),
+  };
+}
+
+export function makeRunMeta(
+  overrides: Partial<CollectiveXNeutralRunMeta> = {},
+): CollectiveXNeutralRunMeta {
+  return {
+    run_id: '160',
+    run_attempt: 1,
+    generated_at: '2026-07-08T12:20:00Z',
+    conclusion: 'success',
+    source_sha: SOURCE_SHA,
+    ...overrides,
+  };
+}
+
+export function buildDataset(
+  options: {
+    shards?: Json[];
+    requestedCases?: RequestedCaseSpec[];
+    meta?: Partial<CollectiveXNeutralRunMeta>;
+  } = {},
+): CollectiveXDataset {
+  const shards = options.shards ?? [makeRawShard()];
+  const requested = [...shards.map(requestedFromShard), ...(options.requestedCases ?? [])];
+  return buildDatasetFromNeutral(makeRawMatrix(requested), shards, makeRunMeta(options.meta));
+}
+
+export function makeCollectiveXSeries(overrides: ShardOverrides = {}): CollectiveXSeries {
+  return buildDataset({ shards: [makeRawShard(overrides)] }).series[0];
+}
+
+export function makeCollectiveXDataset(): CollectiveXDataset {
+  const shardA = makeRawShard();
+  const shardB = makeRawShard({
+    sku: 'mi355x',
+    backend: 'mori',
+    implName: 'mori',
+    vendor: 'amd',
+    ep: 16,
+    scaleUpTransport: 'xgmi',
+    scaleOutTransport: 'rdma',
+    topologyClass: 'mi355x-xgmi-rdma',
+    nodes: 2,
+  });
+  // The same cell as shardA measured with FP8 dispatch, so consumers exercise
+  // the bf16/fp8 split of an otherwise identical configuration.
+  const shardC = makeRawShard({ precision: 'fp8' });
+  const unsupportedId = 'b300-deepep-v2-deepseek-v3-normal-decode-ep16-uniform-bf16';
+  const pendingId = 'b200-dgxc-deepep-v2-deepseek-v3-normal-decode-ep8-uniform-bf16';
+  return buildDataset({
+    shards: [shardA, shardB, shardC],
+    requestedCases: [
+      {
+        caseId: unsupportedId,
+        sku: 'b300',
+        disposition: 'unsupported',
+        reason: 'backend-platform-unsupported',
+        case: makeRawCase(
+          {
+            backend: 'deepep-v2',
+            ep: 16,
+            nodes: 2,
+            scaleOutTransport: 'rdma',
+            topologyClass: 'b300-nvlink-rdma',
+          },
+          unsupportedId,
+        ),
+      },
+      {
+        caseId: pendingId,
+        sku: 'b200-dgxc',
+        case: makeRawCase({ backend: 'deepep-v2', topologyClass: 'b200-nvlink-island' }, pendingId),
+      },
+    ],
+  });
+}
diff --git a/packages/db/src/collectivex/types.ts b/packages/db/src/collectivex/types.ts
new file mode 100644
index 00000000..9bc2d2e3
--- /dev/null
+++ b/packages/db/src/collectivex/types.ts
@@ -0,0 +1,146 @@
+/**
+ * CollectiveX neutral contract — the version-tagged shape shared by the sweep
+ * artifacts' reader, the ingest script, and the dashboard frontend.
+ *
+ * This module is pure TypeScript (no Node/DB imports) so it is safe to import
+ * from client components. UI-only types (chart points, axis modes, display
+ * label helpers) live in `packages/app/src/components/collectivex/types.ts`.
+ */
+
+export type CollectiveXPhase = 'decode' | 'prefill';
+export type CollectiveXPrecision = 'bf16' | 'fp8';
+/** Kernel mode: throughput-oriented `normal`, or decode-only `low-latency`. */
+export type CollectiveXMode = 'normal' | 'low-latency';
+export const COLLECTIVEX_VERSIONS = [1] as const;
+export type CollectiveXVersion = (typeof COLLECTIVEX_VERSIONS)[number];
+export const COLLECTIVEX_DEFAULT_VERSION: CollectiveXVersion = COLLECTIVEX_VERSIONS.at(-1)!;
+
+export function parseCollectiveXVersion(raw: string): CollectiveXVersion | null {
+  const version = Number(raw);
+  return (COLLECTIVEX_VERSIONS as readonly number[]).includes(version)
+    ? (version as CollectiveXVersion)
+    : null;
+}
+
+export type CollectiveXOperation = 'dispatch' | 'stage' | 'combine' | 'roundtrip';
+export type CollectiveXPercentile = 'p50' | 'p90' | 'p95' | 'p99';
+export type CollectiveXOutcome =
+  | 'success'
+  | 'unsupported'
+  | 'failed'
+  | 'invalid'
+  | 'diagnostic'
+  | 'pending';
+export type CollectiveXTerminalStatus = Exclude<CollectiveXOutcome, 'success'> | 'measured';
+
+export type CollectiveXPercentiles = Record<CollectiveXPercentile, number>;
+
+export interface CollectiveXComponent {
+  latency_us: CollectiveXPercentiles;
+  activation_data_rate_gbps_at_latency_percentile: CollectiveXPercentiles | null;
+  /**
+   * Per-GPU bandwidth over the FULL logical payload (activation bytes plus any
+   * FP8 scale bytes), i.e. `total_logical_bytes / ep_size / latency`. Distinct
+   * from `activation_data_rate_gbps_at_latency_percentile`, which is aggregate
+   * and excludes scale bytes. Null when the component carries no byte
+   * provenance (e.g. an unavailable component).
+   */
+  payload_data_rate_gbps_at_latency_percentile: CollectiveXPercentiles | null;
+  /**
+   * Aggregate total logical payload bytes for this component at this point
+   * (the numerator behind `payload_data_rate_*`). Carried raw so a consumer can
+   * fit latency vs bytes across the ladder (bandwidth-vs-overhead decomposition)
+   * without reconstructing bytes from a rate. Null when no byte provenance.
+   */
+  payload_bytes: number | null;
+}
+
+export interface CollectiveXPoint {
+  tokens_per_rank: number;
+  global_tokens: number;
+  components: Record<CollectiveXOperation, CollectiveXComponent | null>;
+  roundtrip_token_rate_at_latency_percentile: CollectiveXPercentiles;
+}
+
+export interface CollectiveXTopology {
+  ep_size: number;
+  nodes: number;
+  gpus_per_node: number;
+  scale_up_domain: number;
+  scale_up_transport: string;
+  scale_out_transport: string | null;
+  topology_class: string;
+}
+
+export interface CollectiveXSeries {
+  series_id: string;
+  phase: CollectiveXPhase;
+  mode: CollectiveXMode;
+  precision: CollectiveXPrecision;
+  backend: string;
+  system: CollectiveXTopology & {
+    sku: string;
+    vendor: 'nvidia' | 'amd';
+  };
+  points: CollectiveXPoint[];
+}
+
+export interface CollectiveXCoveragePoint {
+  tokens_per_rank: number;
+  global_tokens: number;
+  terminal_status: CollectiveXTerminalStatus;
+  reason: string | null;
+}
+
+export interface CollectiveXCoverage {
+  case_id: string;
+  label: string;
+  disposition: 'runnable' | 'unsupported';
+  sku: string;
+  backend: string;
+  phase: CollectiveXPhase;
+  mode: CollectiveXMode;
+  precision: CollectiveXPrecision;
+  topology: CollectiveXTopology;
+  points: CollectiveXCoveragePoint[];
+  outcome: CollectiveXOutcome;
+  reason: string | null;
+  detail: string | null;
+}
+
+export interface CollectiveXRun {
+  run_id: string;
+  run_attempt: number;
+  generated_at: string;
+  conclusion: string | null;
+  source_sha: string;
+  requested_cases: number;
+  terminal_cases: number;
+  measured_cases: number;
+  unsupported_cases: number;
+  failed_cases: number;
+  requested_points: number;
+  terminal_points: number;
+  measured_points: number;
+  covered_skus: string[];
+}
+
+export interface CollectiveXDataset {
+  version: number;
+  run: CollectiveXRun;
+  coverage: CollectiveXCoverage[];
+  series: CollectiveXSeries[];
+}
+
+export interface CollectiveXRunSummary {
+  run_id: string;
+  run_attempt: number;
+  generated_at: string;
+  conclusion: string | null;
+  covered_skus: string[];
+  requested_cases: number;
+  measured_cases: number;
+  requested_points: number;
+  terminal_points: number;
+  terminal_counts: { measured: number; unsupported: number; failed: number };
+}
diff --git a/packages/db/src/connection.ts b/packages/db/src/connection.ts
index a1a37bb7..23721d10 100644
--- a/packages/db/src/connection.ts
+++ b/packages/db/src/connection.ts
@@ -76,7 +76,7 @@ function wrapPostgres(sql: postgres.Sql): DbClient {
 
 // Survive Next.js HMR — without globalThis the module re-evaluates on each
 // hot reload, leaking the previous postgres.js TCP connection pool.
-const g = globalThis as unknown as { __dbClient?: DbClient; __dbWriteClient?: DbClient };
+const g = globalThis as unknown as { __dbClients?: Map<string, DbClient> };
 
 function makeDbClient(url: string): DbClient {
   return shouldUseNeon(url)
@@ -84,20 +84,39 @@ function makeDbClient(url: string): DbClient {
     : wrapPostgres(postgres(url, postgresOptionsForUrl(url)));
 }
 
+/** One memoized client per connection env var; throws when the var is unset. */
+function memoizedClient(envVar: string): DbClient {
+  g.__dbClients ??= new Map();
+  const cached = g.__dbClients.get(envVar);
+  if (cached) return cached;
+  const url = process.env[envVar];
+  if (!url) throw new Error(`${envVar} is not set`);
+  const client = makeDbClient(url);
+  g.__dbClients.set(envVar, client);
+  return client;
+}
+
 /** Read-only SQL client for API routes. Requires DATABASE_READONLY_URL. */
 export function getDb(): DbClient {
-  if (g.__dbClient) return g.__dbClient;
-  const url = process.env.DATABASE_READONLY_URL;
-  if (!url) throw new Error('DATABASE_READONLY_URL is not set');
-  g.__dbClient = makeDbClient(url);
-  return g.__dbClient;
+  return memoizedClient('DATABASE_READONLY_URL');
 }
 
 /** Write-capable SQL client for API routes that need to insert (e.g. user feedback). */
 export function getWriteDb(): DbClient {
-  if (g.__dbWriteClient) return g.__dbWriteClient;
-  const url = process.env.DATABASE_WRITE_URL;
-  if (!url) throw new Error('DATABASE_WRITE_URL is not set');
-  g.__dbWriteClient = makeDbClient(url);
-  return g.__dbWriteClient;
+  return memoizedClient('DATABASE_WRITE_URL');
+}
+
+/**
+ * Read-only SQL client for the CollectiveX database — a separate Neon
+ * instance from the main benchmark DB, holding raw sweep-run documents.
+ * Must point at the same primary as the write URL (not a lagging replica):
+ * the lazy-ingest routes read their own writes within a single request.
+ */
+export function getCollectiveXDb(): DbClient {
+  return memoizedClient('DATABASE_COLLECTIVEX_READONLY_URL');
+}
+
+/** Write-capable SQL client for the CollectiveX database (lazy ingest + run deletion). */
+export function getCollectiveXWriteDb(): DbClient {
+  return memoizedClient('DATABASE_COLLECTIVEX_WRITE_URL');
 }
diff --git a/packages/db/src/etl/compute-chart-series.test.ts b/packages/db/src/etl/compute-chart-series.test.ts
index 3f088cd6..74924171 100644
--- a/packages/db/src/etl/compute-chart-series.test.ts
+++ b/packages/db/src/etl/compute-chart-series.test.ts
@@ -269,23 +269,23 @@ describe('computeChartSeries', () => {
       metrics: {
         'vllm:prompt_tokens': {
           series: [
-            buildDynamoSeries('10.30.1.56:7500', 'prefill', 'prefill-a', 100),
-            buildDynamoSeries('10.30.1.36:7508', 'prefill', 'prefill-b', 200),
-            buildDynamoSeries('10.30.1.206:7516', 'backend', 'decode-a', 300),
+            buildDynamoSeries('prefill-a.internal.test:7500', 'prefill', 'prefill-a', 100),
+            buildDynamoSeries('prefill-b.internal.test:7508', 'prefill', 'prefill-b', 200),
+            buildDynamoSeries('decode-a.internal.test:7516', 'backend', 'decode-a', 300),
           ],
         },
         'vllm:generation_tokens': {
           series: [
-            buildDynamoSeries('10.30.1.56:7500', 'prefill', 'prefill-a', 1),
-            buildDynamoSeries('10.30.1.36:7508', 'prefill', 'prefill-b', 2),
-            buildDynamoSeries('10.30.1.206:7516', 'backend', 'decode-a', 400),
+            buildDynamoSeries('prefill-a.internal.test:7500', 'prefill', 'prefill-a', 1),
+            buildDynamoSeries('prefill-b.internal.test:7508', 'prefill', 'prefill-b', 2),
+            buildDynamoSeries('decode-a.internal.test:7516', 'backend', 'decode-a', 400),
           ],
         },
         'vllm:num_requests_running': {
           series: [
-            buildDynamoSeries('10.30.1.56:7500', 'prefill', 'prefill-a', 3, 'avg'),
-            buildDynamoSeries('10.30.1.36:7508', 'prefill', 'prefill-b', 4, 'avg'),
-            buildDynamoSeries('10.30.1.206:7516', 'backend', 'decode-a', 5, 'avg'),
+            buildDynamoSeries('prefill-a.internal.test:7500', 'prefill', 'prefill-a', 3, 'avg'),
+            buildDynamoSeries('prefill-b.internal.test:7508', 'prefill', 'prefill-b', 4, 'avg'),
+            buildDynamoSeries('decode-a.internal.test:7516', 'backend', 'decode-a', 5, 'avg'),
           ],
         },
       },
@@ -299,8 +299,8 @@ describe('computeChartSeries', () => {
 
     expect(result?.metricSources).toHaveLength(3);
     expect(result?.metricSources.map(({ source: s }) => [s.role, s.workerId, s.engine])).toEqual([
-      ['prefill', 'prefill-b', '0'],
       ['prefill', 'prefill-a', '0'],
+      ['prefill', 'prefill-b', '0'],
       ['decode', 'decode-a', '0'],
     ]);
     const prefillA = result?.metricSources.find(({ source: s }) => s.workerId === 'prefill-a');
@@ -322,7 +322,7 @@ describe('computeChartSeries', () => {
         'vllm:prompt_tokens': {
           series: [
             {
-              endpoint_url: '10.30.1.56:7500',
+              endpoint_url: 'prefill-a.internal.test:7500',
               labels: { dynamo_component: 'prefill', worker_id: 'prefill-a', engine: '0' },
               timeslices: [{ start_ns: 0, end_ns: 1e9, rate: 100 }],
             },
diff --git a/packages/db/src/etl/db-utils.ts b/packages/db/src/etl/db-utils.ts
index adc6c1cd..6ff1678d 100644
--- a/packages/db/src/etl/db-utils.ts
+++ b/packages/db/src/etl/db-utils.ts
@@ -9,16 +9,18 @@ export type Sql = ReturnType<typeof postgres>;
 /**
  * Create a postgres client for admin scripts.
  * Reads DATABASE_WRITE_URL by default, or DATABASE_READONLY_URL with `readonly: true`.
+ * Pass `envVar` to target another database (e.g. DATABASE_COLLECTIVEX_WRITE_URL).
  * Pass `noSsl: true` to disable TLS for local Postgres.
  */
 export function createAdminSql(
   opts: Omit<Options<Record<string, postgres.PostgresType>>, 'ssl'> & {
     readonly?: boolean;
     noSsl?: boolean;
+    envVar?: string;
   } = {},
 ): Sql {
-  const { readonly, noSsl, ...pgOpts } = opts;
-  const envVar = readonly ? 'DATABASE_READONLY_URL' : 'DATABASE_WRITE_URL';
+  const { readonly, noSsl, envVar: envVarOverride, ...pgOpts } = opts;
+  const envVar = envVarOverride ?? (readonly ? 'DATABASE_READONLY_URL' : 'DATABASE_WRITE_URL');
   const url = process.env[envVar];
   if (!url) {
     console.error(`${envVar} is required`);
diff --git a/packages/db/src/ingest-collectivex.ts b/packages/db/src/ingest-collectivex.ts
new file mode 100644
index 00000000..c11a7eb5
--- /dev/null
+++ b/packages/db/src/ingest-collectivex.ts
@@ -0,0 +1,247 @@
+/**
+ * Ingest a CollectiveX sweep run's artifacts into the CollectiveX database.
+ *
+ * Stores the RAW matrix + case-attempt documents (the sweep JSON contract is
+ * expected to change; the shared reader in src/collectivex/reader.ts is the
+ * single transform point and runs at API-read time). The reader IS executed
+ * once here — to validate the bundle assembles and to precompute the
+ * `summary` column that backs the dashboard's run picker.
+ *
+ * Sweep runs are accepted from ANY branch of the source repo (they are
+ * launched via `gh api` on feature branches); only the workflow identity is
+ * checked, never head_branch.
+ *
+ * The dashboard ingests runs lazily on read; this CLI exists to pre-warm runs
+ * before their GitHub artifacts expire, backfill older runs into the picker,
+ * and force-refresh a run. Re-ingesting a run the dashboard deleted clears
+ * its tombstone (deliberate operator override).
+ *
+ * Two modes:
+ *   --download <run-url-or-id> [repo]  Download artifacts from GitHub then ingest
+ *   (no flag)                          Read pre-downloaded artifacts from INGEST_ARTIFACTS_PATH
+ *
+ * Usage:
+ *   pnpm admin:db:ingest:collectivex https://github.com/SemiAnalysisAI/InferenceX/actions/runs/123
+ *   pnpm admin:db:ingest:collectivex 123
+ *
+ * Environment variables:
+ *   DATABASE_COLLECTIVEX_WRITE_URL — Postgres connection string (direct, non-pooled)
+ *   GITHUB_TOKEN                   — GitHub PAT for run metadata + artifact download
+ *   INGEST_RUN_ID                  — (env mode) Workflow run ID
+ *   INGEST_ARTIFACTS_PATH          — (env mode) Local path to pre-downloaded artifacts
+ *   INGEST_REPO                    — (env mode) Source repo slug (owner/name)
+ */
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { hasNoSslFlag } from './cli-utils';
+import { createAdminSql } from './etl/db-utils';
+import {
+  downloadArtifact,
+  fetchRunMeta,
+  listRunArtifacts,
+  type RunMeta,
+} from './lib/github-artifacts';
+import { matrixArtifactName, selectShardArtifactNames } from './collectivex/artifact-selection';
+import {
+  buildDatasetFromNeutral,
+  buildRunSummary,
+  isMatrixDoc,
+  matrixVersion,
+  type CollectiveXNeutralRunMeta,
+} from './collectivex/reader';
+
+const DEFAULT_REPO = 'SemiAnalysisAI/InferenceX';
+const SWEEP_WORKFLOW_PATH = '.github/workflows/collectivex-sweep.yml';
+const DOCS_INSERT_CHUNK = 200;
+
+// ── Argument / env parsing ──────────────────────────────────────────────────
+
+const isDownloadMode = process.argv[2] === '--download';
+
+let artifactsDir: string;
+let runIdStr: string;
+let REPO: string;
+let tempDir: string | null = null;
+
+if (isDownloadMode) {
+  // Positional args only: drop the '--' injected by pnpm arg passthrough and
+  // option flags like --no-ssl (read from argv by their own helpers).
+  const args = process.argv.slice(3).filter((a) => !a.startsWith('--'));
+  const input = args[0];
+  if (!input) {
+    console.error('Usage: pnpm admin:db:ingest:collectivex <run-url-or-id> [repo]');
+    process.exit(1);
+  }
+  const match = input.match(/\/runs\/(?<runId>\d+)/u);
+  const parsedId = match ? match.groups!.runId : /^\d+$/u.test(input) ? input : null;
+  if (!parsedId) {
+    console.error(`Could not parse run ID from: ${input}`);
+    process.exit(1);
+  }
+  runIdStr = parsedId;
+  REPO = args[1] ?? DEFAULT_REPO;
+  tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'cx-ingest-'));
+  artifactsDir = tempDir;
+} else {
+  const runId = process.env.INGEST_RUN_ID;
+  const artifactsPath = process.env.INGEST_ARTIFACTS_PATH;
+  if (!runId || !artifactsPath) {
+    console.error('INGEST_RUN_ID and INGEST_ARTIFACTS_PATH are required without --download');
+    process.exit(1);
+  }
+  runIdStr = runId;
+  REPO = process.env.INGEST_REPO ?? DEFAULT_REPO;
+  artifactsDir = artifactsPath;
+}
+
+// The repo slug reaches shell-interpolated `gh api` calls — reject metachars.
+if (!/^[\w.-]+\/[\w.-]+$/u.test(REPO)) {
+  console.error(`Invalid repo slug: ${REPO}`);
+  process.exit(1);
+}
+
+// ── Artifact reading ────────────────────────────────────────────────────────
+
+/** Parse every `*.json` file in an artifact directory. */
+function readDocsDir(dir: string): unknown[] {
+  const docs: unknown[] = [];
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      docs.push(...readDocsDir(full));
+      continue;
+    }
+    if (!entry.name.endsWith('.json')) continue;
+    docs.push(JSON.parse(fs.readFileSync(full, 'utf8')));
+  }
+  return docs;
+}
+
+function runGeneratedAt(run: RunMeta): string {
+  return run.updated_at || run.run_started_at || run.created_at || '';
+}
+
+// ── Main ────────────────────────────────────────────────────────────────────
+
+async function main(): Promise<void> {
+  console.log(`=== db:ingest:collectivex — run ${runIdStr} (${REPO}) ===`);
+
+  const run = fetchRunMeta(REPO, runIdStr);
+  // Identity check only — never the branch: sweeps run on feature branches.
+  if (run.path !== SWEEP_WORKFLOW_PATH) {
+    throw new Error(`run ${runIdStr} is not a CollectiveX sweep (workflow: ${run.path})`);
+  }
+  const generatedAt = runGeneratedAt(run);
+  if (!generatedAt) throw new Error(`run ${runIdStr} is missing a timestamp`);
+  console.log(
+    `  workflow: ${run.name}  branch: ${run.head_branch ?? '?'}  attempt: ${run.run_attempt}  conclusion: ${run.conclusion ?? 'in-progress'}`,
+  );
+
+  const matrixDirName = matrixArtifactName(runIdStr);
+
+  if (isDownloadMode) {
+    const artifacts = listRunArtifacts(REPO, runIdStr);
+    // Keep the newest per name — retried uploads can duplicate a name.
+    const byName = new Map<string, (typeof artifacts)[number]>();
+    for (const artifact of artifacts) {
+      const existing = byName.get(artifact.name);
+      if (!existing || artifact.created_at > existing.created_at) {
+        byName.set(artifact.name, artifact);
+      }
+    }
+    const wanted = [
+      matrixDirName,
+      ...selectShardArtifactNames([...byName.keys()], runIdStr, run.run_attempt),
+    ];
+    for (const name of wanted) {
+      const artifact = byName.get(name);
+      if (!artifact) continue;
+      console.log(`  downloading ${name}`);
+      downloadArtifact(artifact, artifactsDir);
+    }
+  }
+
+  const availableDirs = fs
+    .readdirSync(artifactsDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name);
+
+  if (!availableDirs.includes(matrixDirName)) {
+    throw new Error(`run ${runIdStr} has no ${matrixDirName} artifact`);
+  }
+  const matrixDocs = readDocsDir(path.join(artifactsDir, matrixDirName)).filter((doc) =>
+    isMatrixDoc(doc),
+  );
+  if (matrixDocs.length !== 1) {
+    throw new Error(`expected exactly one matrix document, found ${matrixDocs.length}`);
+  }
+  const matrix = matrixDocs[0];
+  const version = matrixVersion(matrix);
+  if (version === null) throw new Error('matrix document has no valid version tag');
+
+  const shardDirs = selectShardArtifactNames(availableDirs, runIdStr, run.run_attempt);
+  console.log(`  matrix version: ${version}  shard artifacts: ${shardDirs.length}`);
+  const docs = shardDirs.flatMap((dir) => readDocsDir(path.join(artifactsDir, dir)));
+
+  // Assemble once: validates the bundle and precomputes the picker summary.
+  const meta: CollectiveXNeutralRunMeta = {
+    run_id: runIdStr,
+    run_attempt: run.run_attempt,
+    generated_at: generatedAt,
+    conclusion: run.conclusion,
+    source_sha: run.head_sha,
+  };
+  const dataset = buildDatasetFromNeutral(matrix, docs, meta);
+  const summary = buildRunSummary(dataset);
+  console.log(
+    `  assembled: ${summary.requested_cases} cases (${summary.measured_cases} measured), ${summary.requested_points} points`,
+  );
+
+  const sql = createAdminSql({
+    envVar: 'DATABASE_COLLECTIVEX_WRITE_URL',
+    noSsl: hasNoSslFlag(),
+    max: 1,
+    onnotice: () => {},
+  });
+  try {
+    await sql.begin(async (tx) => {
+      // Re-ingest = refresh: replace the run and its documents wholesale.
+      await tx`DELETE FROM cx_runs WHERE run_id = ${runIdStr}`;
+      // The ::jsonb casts type the parameters as jsonb, so postgres.js
+      // serializes the raw objects itself — pre-stringifying here would
+      // double-encode them into jsonb strings.
+      await tx`
+        INSERT INTO cx_runs
+          (run_id, run_attempt, version, generated_at, source_sha, source_branch, conclusion, matrix, summary)
+        VALUES
+          (${runIdStr}, ${run.run_attempt}, ${version}, ${generatedAt}, ${run.head_sha},
+           ${run.head_branch}, ${run.conclusion}, ${matrix as never}::jsonb,
+           ${summary as never}::jsonb)
+      `;
+      for (let i = 0; i < docs.length; i += DOCS_INSERT_CHUNK) {
+        const chunk = docs.slice(i, i + DOCS_INSERT_CHUNK).map((doc) => JSON.stringify(doc));
+        await tx`
+          INSERT INTO cx_run_docs (run_id, run_attempt, doc)
+          SELECT ${runIdStr}, ${run.run_attempt}, unnest(${tx.array(chunk)}::jsonb[])
+        `;
+      }
+    });
+    console.log(`  stored run ${runIdStr} (version ${version}, ${docs.length} docs)`);
+  } finally {
+    await sql.end();
+  }
+
+  console.log('=== db:ingest:collectivex complete ===');
+}
+
+main()
+  .catch((error) => {
+    console.error('db:ingest:collectivex failed:', error);
+    process.exitCode = 1;
+  })
+  .finally(() => {
+    if (tempDir) fs.rmSync(tempDir, { recursive: true, force: true });
+  });
diff --git a/packages/db/src/lib/github-artifacts.ts b/packages/db/src/lib/github-artifacts.ts
index 39f143bd..b9e6ef4b 100644
--- a/packages/db/src/lib/github-artifacts.ts
+++ b/packages/db/src/lib/github-artifacts.ts
@@ -86,3 +86,26 @@ export function fetchRunAttempt(repo: string, runId: string): number {
   }).trim();
   return parseInt(attemptStr || '1', 10);
 }
+
+export interface RunMeta {
+  id: number;
+  name: string;
+  path: string;
+  run_attempt: number;
+  head_sha: string;
+  head_branch: string | null;
+  conclusion: string | null;
+  status: string | null;
+  updated_at?: string | null;
+  run_started_at?: string | null;
+  created_at?: string | null;
+}
+
+/** Fetch a workflow run's metadata via `gh api`. */
+export function fetchRunMeta(repo: string, runId: string): RunMeta {
+  const json = execSync(`gh api "repos/${repo}/actions/runs/${runId}"`, {
+    encoding: 'utf8',
+    maxBuffer: 10 * 1024 * 1024,
+  });
+  return JSON.parse(json) as RunMeta;
+}
diff --git a/packages/db/src/lib/migration-runner.test.ts b/packages/db/src/lib/migration-runner.test.ts
new file mode 100644
index 00000000..4affed65
--- /dev/null
+++ b/packages/db/src/lib/migration-runner.test.ts
@@ -0,0 +1,88 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+
+import { runMigrations } from './migration-runner';
+
+interface Executed {
+  text: string;
+  params?: unknown[];
+}
+
+/**
+ * Minimal stand-in for the postgres.js client surface runMigrations uses:
+ * tagged-template select on schema_migrations + begin(tx.unsafe).
+ */
+function fakeSql(applied: string[]) {
+  const executed: Executed[] = [];
+  const sql = (strings: TemplateStringsArray) => {
+    const text = strings.join('');
+    executed.push({ text });
+    if (text.includes('select filename')) {
+      return Promise.resolve(applied.map((filename) => ({ filename })));
+    }
+    return Promise.resolve([]);
+  };
+  sql.begin = async (
+    fn: (tx: { unsafe: (text: string, params?: unknown[]) => Promise<void> }) => Promise<void>,
+  ) => {
+    await fn({
+      unsafe: (text: string, params?: unknown[]) => {
+        executed.push({ text, params });
+        return Promise.resolve();
+      },
+    });
+  };
+  return { sql: sql as never, executed };
+}
+
+let dir: string;
+
+beforeEach(() => {
+  dir = fs.mkdtempSync(path.join(os.tmpdir(), 'migration-runner-'));
+});
+
+afterEach(() => {
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+describe('runMigrations', () => {
+  it('applies pending .sql files in filename order and records them', async () => {
+    fs.writeFileSync(path.join(dir, '002_second.sql'), 'create table two ();');
+    fs.writeFileSync(path.join(dir, '001_first.sql'), 'create table one ();');
+    fs.writeFileSync(path.join(dir, 'notes.txt'), 'not a migration');
+    const { sql, executed } = fakeSql([]);
+
+    const ran = await runMigrations(sql, dir);
+
+    expect(ran).toBe(2);
+    const applied = executed.filter((e) => e.text.startsWith('create table'));
+    expect(applied.map((e) => e.text)).toEqual(['create table one ();', 'create table two ();']);
+    const recorded = executed.filter((e) => e.text.includes('insert into schema_migrations'));
+    expect(recorded.map((e) => e.params)).toEqual([['001_first.sql'], ['002_second.sql']]);
+  });
+
+  it('skips migrations already recorded in schema_migrations', async () => {
+    fs.writeFileSync(path.join(dir, '001_first.sql'), 'create table one ();');
+    fs.writeFileSync(path.join(dir, '002_second.sql'), 'create table two ();');
+    const { sql, executed } = fakeSql(['001_first.sql']);
+
+    const ran = await runMigrations(sql, dir);
+
+    expect(ran).toBe(1);
+    const applied = executed.filter((e) => e.text.startsWith('create table'));
+    expect(applied.map((e) => e.text)).toEqual(['create table two ();']);
+  });
+
+  it('returns 0 when everything is already applied', async () => {
+    fs.writeFileSync(path.join(dir, '001_first.sql'), 'create table one ();');
+    const { sql, executed } = fakeSql(['001_first.sql']);
+
+    const ran = await runMigrations(sql, dir);
+
+    expect(ran).toBe(0);
+    expect(executed.some((e) => e.text.startsWith('create table'))).toBe(false);
+  });
+});
diff --git a/packages/db/src/lib/migration-runner.ts b/packages/db/src/lib/migration-runner.ts
new file mode 100644
index 00000000..3ef4e213
--- /dev/null
+++ b/packages/db/src/lib/migration-runner.ts
@@ -0,0 +1,56 @@
+/**
+ * Shared SQL-file migration loop used by `migrate.ts` (main DB) and
+ * `migrate-collectivex.ts` (CollectiveX DB). Applies pending `*.sql` files
+ * from a directory in filename order, tracking them in a `schema_migrations`
+ * table on the target database.
+ */
+
+import fs from 'fs';
+import path from 'path';
+
+import type { Sql } from '../etl/db-utils';
+
+export async function runMigrations(sql: Sql, migrationsDir: string): Promise<number> {
+  // Create migrations tracking table if it doesn't exist
+  await sql`
+    create table if not exists schema_migrations (
+      filename   text        primary key,
+      applied_at timestamptz not null default now()
+    )
+  `;
+
+  const migrations = await sql<{ filename: string }[]>`select filename from schema_migrations`;
+  const applied = new Set(migrations.map((r) => r.filename));
+
+  const files = fs
+    .readdirSync(migrationsDir)
+    .filter((f) => f.endsWith('.sql'))
+    .toSorted();
+
+  let ran = 0;
+  for (const file of files) {
+    if (applied.has(file)) {
+      console.log(`  skip  ${file}`);
+      continue;
+    }
+
+    console.log(`  apply ${file} ...`);
+    const sql_text = fs.readFileSync(path.join(migrationsDir, file), 'utf8');
+
+    await sql.begin(async (tx) => {
+      await tx.unsafe(sql_text);
+      await tx.unsafe('insert into schema_migrations (filename) values ($1)', [file]);
+    });
+
+    console.log(`  done  ${file}`);
+    ran++;
+  }
+
+  if (ran === 0) {
+    console.log('  all migrations already applied');
+  } else {
+    console.log(`\n  applied ${ran} migration(s)`);
+  }
+
+  return ran;
+}
diff --git a/packages/db/src/migrate-collectivex.ts b/packages/db/src/migrate-collectivex.ts
new file mode 100644
index 00000000..74864009
--- /dev/null
+++ b/packages/db/src/migrate-collectivex.ts
@@ -0,0 +1,50 @@
+/**
+ * Run CollectiveX database migrations. Targets the separate CollectiveX Neon
+ * instance via DATABASE_COLLECTIVEX_WRITE_URL (direct, non-pooled connection —
+ * migrations must not go through PgBouncer's transaction pooling mode).
+ *
+ * Usage:
+ *   pnpm admin:db:migrate:collectivex
+ */
+
+import path from 'path';
+
+import { confirm, hasNoSslFlag, hasYesFlag } from './cli-utils';
+import { createAdminSql } from './etl/db-utils';
+import { runMigrations } from './lib/migration-runner';
+
+const MIGRATIONS_DIR = path.join(import.meta.dirname, '..', 'migrations-collectivex');
+
+const sql = createAdminSql({
+  envVar: 'DATABASE_COLLECTIVEX_WRITE_URL',
+  noSsl: hasNoSslFlag(),
+  max: 1,
+  onnotice: () => {}, // suppress "relation already exists" notices
+});
+
+async function migrate(): Promise<void> {
+  console.log('=== db:migrate:collectivex ===');
+  console.log(
+    'This will apply any pending SQL migrations from migrations-collectivex/ to the\n' +
+      'CollectiveX database. Already-applied migrations are skipped.\n',
+  );
+
+  if (!hasYesFlag()) {
+    const ok = await confirm('Continue? (y/N) ');
+    if (!ok) {
+      console.log('Aborted.');
+      return;
+    }
+  }
+
+  await runMigrations(sql, MIGRATIONS_DIR);
+
+  console.log('\n=== db:migrate:collectivex complete ===');
+}
+
+migrate()
+  .catch((error) => {
+    console.error('db:migrate:collectivex failed:', error);
+    process.exitCode = 1;
+  })
+  .finally(() => sql.end());
diff --git a/packages/db/src/migrate.ts b/packages/db/src/migrate.ts
index 382511ff..97577468 100644
--- a/packages/db/src/migrate.ts
+++ b/packages/db/src/migrate.ts
@@ -8,11 +8,11 @@
  *   pnpm admin:db:migrate
  */
 
-import fs from 'fs';
 import path from 'path';
 
 import { confirm, hasNoSslFlag, hasYesFlag } from './cli-utils';
 import { createAdminSql } from './etl/db-utils';
+import { runMigrations } from './lib/migration-runner';
 
 const MIGRATIONS_DIR = path.join(import.meta.dirname, '..', 'migrations');
 
@@ -37,46 +37,7 @@ async function migrate(): Promise<void> {
     }
   }
 
-  // Create migrations tracking table if it doesn't exist
-  await sql`
-    create table if not exists schema_migrations (
-      filename   text        primary key,
-      applied_at timestamptz not null default now()
-    )
-  `;
-
-  const migrations = await sql<{ filename: string }[]>`select filename from schema_migrations`;
-  const applied = new Set(migrations.map((r) => r.filename));
-
-  const files = fs
-    .readdirSync(MIGRATIONS_DIR)
-    .filter((f) => f.endsWith('.sql'))
-    .toSorted();
-
-  let ran = 0;
-  for (const file of files) {
-    if (applied.has(file)) {
-      console.log(`  skip  ${file}`);
-      continue;
-    }
-
-    console.log(`  apply ${file} ...`);
-    const sql_text = fs.readFileSync(path.join(MIGRATIONS_DIR, file), 'utf8');
-
-    await sql.begin(async (tx) => {
-      await tx.unsafe(sql_text);
-      await tx.unsafe('insert into schema_migrations (filename) values ($1)', [file]);
-    });
-
-    console.log(`  done  ${file}`);
-    ran++;
-  }
-
-  if (ran === 0) {
-    console.log('  all migrations already applied');
-  } else {
-    console.log(`\n  applied ${ran} migration(s)`);
-  }
+  await runMigrations(sql, MIGRATIONS_DIR);
 
   console.log('\n=== db:migrate complete ===');
   console.log('  Invalidate API cache: pnpm admin:cache:invalidate');
diff --git a/packages/db/src/queries/collectivex.test.ts b/packages/db/src/queries/collectivex.test.ts
new file mode 100644
index 00000000..d64fbdfe
--- /dev/null
+++ b/packages/db/src/queries/collectivex.test.ts
@@ -0,0 +1,167 @@
+import { describe, expect, it } from 'vitest';
+
+import { makeRawMatrix, makeRawShard, makeRunMeta } from '../collectivex/test-fixture';
+import type { DbClient } from '../connection.js';
+import {
+  collectiveXDatasetFromRow,
+  deleteCollectiveXRun,
+  getCollectiveXRunStates,
+  insertCollectiveXRun,
+  listCollectiveXRuns,
+  refreshCollectiveXRunAttempt,
+  type CollectiveXRunInsert,
+} from './collectivex';
+
+interface Captured {
+  text: string;
+  values: unknown[];
+}
+
+/** Tagged-template stub: records each query, replays queued row sets. */
+function fakeSql(rowsQueue: Record<string, unknown>[][]) {
+  const calls: Captured[] = [];
+  const sql = ((strings: TemplateStringsArray, ...values: unknown[]) => {
+    calls.push({ text: strings.join('?'), values });
+    return Promise.resolve(rowsQueue.shift() ?? []);
+  }) as DbClient;
+  return { sql, calls };
+}
+
+const runInsert: CollectiveXRunInsert = {
+  run_id: '160',
+  run_attempt: 2,
+  version: 1,
+  generated_at: '2026-07-08T12:20:00Z',
+  source_sha: 'a'.repeat(40),
+  source_branch: 'collectivex',
+  conclusion: 'success',
+  matrix: { version: 1, requested_cases: [], include: [] },
+  summary: {
+    run_id: '160',
+    run_attempt: 2,
+    generated_at: '2026-07-08T12:20:00Z',
+    conclusion: 'success',
+    covered_skus: [],
+    requested_cases: 0,
+    measured_cases: 0,
+    requested_points: 0,
+    terminal_points: 0,
+    terminal_counts: { measured: 0, unsupported: 0, failed: 0 },
+  },
+};
+
+describe('getCollectiveXRunStates', () => {
+  it('maps deleted flags to tombstone states with version and attempt', async () => {
+    const { sql } = fakeSql([
+      [
+        { run_id: '160', version: 1, run_attempt: 2, deleted: false },
+        { run_id: '161', version: 2, run_attempt: 1, deleted: true },
+      ],
+    ]);
+    const states = await getCollectiveXRunStates(sql, ['160', '161']);
+    expect(states).toEqual({
+      '160': { state: 'live', version: 1, run_attempt: 2 },
+      '161': { state: 'deleted', version: 2, run_attempt: 1 },
+    });
+  });
+
+  it('skips the query entirely for an empty id list', async () => {
+    const { sql, calls } = fakeSql([]);
+    expect(await getCollectiveXRunStates(sql, [])).toEqual({});
+    expect(calls).toHaveLength(0);
+  });
+});
+
+describe('read queries', () => {
+  it('excludes tombstoned rows and orders newest-created first', async () => {
+    const { sql, calls } = fakeSql([[]]);
+    await listCollectiveXRuns(sql, 1);
+    expect(calls[0].text).toContain('deleted_at IS NULL');
+    expect(calls[0].text).toContain('ORDER BY run_id DESC');
+  });
+});
+
+describe('insertCollectiveXRun', () => {
+  it('binds raw objects (never pre-stringified JSON) and reports insertion', async () => {
+    const { sql, calls } = fakeSql([[{ runs_inserted: 1 }]]);
+    const docs = [{ record_type: 'case-attempt' }];
+
+    await expect(insertCollectiveXRun(sql, runInsert, docs)).resolves.toBe(true);
+
+    expect(calls[0].text).toContain('ON CONFLICT (run_id) DO NOTHING');
+    // Raw objects: a pre-stringified value would double-encode under
+    // postgres.js; a bare array would become a PG array literal under neon.
+    expect(calls[0].values).toContainEqual(runInsert.matrix);
+    expect(calls[0].values).toContainEqual({ docs });
+    expect(
+      calls[0].values.every((value) => typeof value !== 'string' || !value.startsWith('{')),
+    ).toBe(true);
+  });
+
+  it('reports a conflict no-op as not inserted', async () => {
+    const { sql } = fakeSql([[{ runs_inserted: 0 }]]);
+    await expect(insertCollectiveXRun(sql, runInsert, [])).resolves.toBe(false);
+  });
+});
+
+describe('refreshCollectiveXRunAttempt', () => {
+  it('guards on a strictly newer attempt and reports replacement', async () => {
+    const { sql, calls } = fakeSql([[{ runs_updated: 1 }]]);
+    await expect(refreshCollectiveXRunAttempt(sql, runInsert, [])).resolves.toBe(true);
+    expect(calls[0].text).toContain('run_attempt < ');
+    expect(calls[0].text).toContain('deleted_at IS NULL');
+    expect(calls[0].text).toContain('FOR UPDATE');
+  });
+
+  it('reports a guarded no-op (older or equal attempt, or tombstoned) as false', async () => {
+    const { sql } = fakeSql([[{ runs_updated: 0 }]]);
+    await expect(refreshCollectiveXRunAttempt(sql, runInsert, [])).resolves.toBe(false);
+  });
+});
+
+describe('deleteCollectiveXRun', () => {
+  it('tombstones the run and frees its documents in one atomic statement', async () => {
+    const { sql, calls } = fakeSql([[{ runs_deleted: 1 }]]);
+    await expect(deleteCollectiveXRun(sql, '160')).resolves.toBe(true);
+    expect(calls).toHaveLength(1);
+    expect(calls[0].text).toContain('SET deleted_at = now()');
+    expect(calls[0].text).toContain('deleted_at IS NULL');
+    expect(calls[0].text).toContain('DELETE FROM cx_run_docs');
+  });
+
+  it('reports absent or already-tombstoned runs as false', async () => {
+    const { sql } = fakeSql([[{ runs_deleted: 0 }]]);
+    await expect(deleteCollectiveXRun(sql, '160')).resolves.toBe(false);
+  });
+});
+
+describe('collectiveXDatasetFromRow', () => {
+  it('assembles a stored row through the shared reader', () => {
+    const shard = makeRawShard();
+    const identity = (
+      shard as { identity: { case_id: string; case_factors: { sku: string; case: unknown } } }
+    ).identity;
+    const meta = makeRunMeta();
+    const dataset = collectiveXDatasetFromRow({
+      run_id: meta.run_id,
+      run_attempt: meta.run_attempt,
+      version: 1,
+      generated_at: meta.generated_at,
+      source_sha: meta.source_sha,
+      source_branch: 'collectivex',
+      conclusion: meta.conclusion,
+      matrix: makeRawMatrix([
+        {
+          caseId: identity.case_id,
+          sku: identity.case_factors.sku,
+          disposition: 'runnable',
+          case: identity.case_factors.case as Record<string, unknown>,
+        },
+      ]),
+      docs: [shard],
+    });
+    expect(dataset.run.run_id).toBe(meta.run_id);
+    expect(dataset.series).toHaveLength(1);
+    expect(dataset.run.measured_cases).toBe(1);
+  });
+});
diff --git a/packages/db/src/queries/collectivex.ts b/packages/db/src/queries/collectivex.ts
new file mode 100644
index 00000000..be0b943a
--- /dev/null
+++ b/packages/db/src/queries/collectivex.ts
@@ -0,0 +1,265 @@
+import type { DbClient } from '../connection.js';
+import { buildDatasetFromNeutral } from '../collectivex/reader';
+import type { CollectiveXDataset, CollectiveXRunSummary } from '../collectivex/types';
+
+/** One cx_runs row with its raw documents, ready for reader assembly. */
+export interface CollectiveXRunRow {
+  run_id: string;
+  run_attempt: number;
+  version: number;
+  generated_at: string;
+  source_sha: string;
+  source_branch: string | null;
+  conclusion: string | null;
+  matrix: unknown;
+  docs: unknown[];
+}
+
+/** Row metadata + raw docs as written by the lazy ingest. */
+export interface CollectiveXRunInsert {
+  run_id: string;
+  run_attempt: number;
+  version: number;
+  generated_at: string;
+  source_sha: string;
+  source_branch: string | null;
+  conclusion: string | null;
+  matrix: unknown;
+  summary: CollectiveXRunSummary;
+}
+
+/**
+ * Known-run state. Runs are discovered lazily from GitHub on read, so a
+ * deleted run keeps a tombstoned cx_runs row — otherwise the next discovery
+ * pass would re-ingest it.
+ */
+export type CollectiveXRunState = 'live' | 'deleted';
+
+export interface CollectiveXRunStateRow {
+  state: CollectiveXRunState;
+  version: number;
+  run_attempt: number;
+}
+
+/** Run summaries capped at this many rows — deletion keeps the list curated. */
+const MAX_LISTED_RUNS = 50;
+
+function toRunRow(row: Record<string, unknown>): CollectiveXRunRow {
+  const { docs, ...rest } = row as unknown as Omit<CollectiveXRunRow, 'docs'> & { docs: unknown };
+  return { ...rest, docs: Array.isArray(docs) ? docs : [] };
+}
+
+/**
+ * The most recent live run for a version. Ordered by run_id — GitHub run ids
+ * increase monotonically with creation, matching lazy discovery's
+ * newest-first walk (completion time would let a long-failing older run
+ * shadow a newer successful one).
+ *
+ * Row and documents come back in ONE query, with docs filtered to the row's
+ * CURRENT run_attempt: a reader can never observe one attempt's metadata with
+ * another attempt's documents, even while a refresh commits concurrently.
+ */
+export async function getLatestCollectiveXRun(
+  sql: DbClient,
+  version: number,
+): Promise<CollectiveXRunRow | null> {
+  const rows = await sql`
+    SELECT r.run_id::text, r.run_attempt, r.version,
+      to_char(r.generated_at at time zone 'utc', 'YYYY-MM-DD"T"HH24:MI:SS"Z"') as generated_at,
+      r.source_sha, r.source_branch, r.conclusion, r.matrix,
+      COALESCE(d.docs, '[]'::jsonb) AS docs
+    FROM cx_runs r
+    LEFT JOIN LATERAL (
+      SELECT jsonb_agg(doc ORDER BY id) AS docs
+      FROM cx_run_docs
+      WHERE run_id = r.run_id AND run_attempt = r.run_attempt
+    ) d ON true
+    WHERE r.version = ${version} AND r.deleted_at IS NULL
+    ORDER BY r.run_id DESC
+    LIMIT 1
+  `;
+  return rows.length === 0 ? null : toRunRow(rows[0]);
+}
+
+/** One specific live run by id, or null when absent, tombstoned, or on another version. */
+export async function getCollectiveXRun(
+  sql: DbClient,
+  version: number,
+  runId: string,
+): Promise<CollectiveXRunRow | null> {
+  const rows = await sql`
+    SELECT r.run_id::text, r.run_attempt, r.version,
+      to_char(r.generated_at at time zone 'utc', 'YYYY-MM-DD"T"HH24:MI:SS"Z"') as generated_at,
+      r.source_sha, r.source_branch, r.conclusion, r.matrix,
+      COALESCE(d.docs, '[]'::jsonb) AS docs
+    FROM cx_runs r
+    LEFT JOIN LATERAL (
+      SELECT jsonb_agg(doc ORDER BY id) AS docs
+      FROM cx_run_docs
+      WHERE run_id = r.run_id AND run_attempt = r.run_attempt
+    ) d ON true
+    WHERE r.version = ${version} AND r.run_id = ${runId} AND r.deleted_at IS NULL
+  `;
+  return rows.length === 0 ? null : toRunRow(rows[0]);
+}
+
+/**
+ * Newest-first live run summaries for the picker, straight from the
+ * precomputed `summary` column — no document loading.
+ */
+export async function listCollectiveXRuns(
+  sql: DbClient,
+  version: number,
+): Promise<CollectiveXRunSummary[]> {
+  const rows = await sql`
+    SELECT summary
+    FROM cx_runs
+    WHERE version = ${version} AND deleted_at IS NULL
+    ORDER BY run_id DESC
+    LIMIT ${MAX_LISTED_RUNS}
+  `;
+  return rows.map((row) => row.summary as CollectiveXRunSummary);
+}
+
+/** State of each known run id (live or tombstoned); absent ids are omitted. */
+export async function getCollectiveXRunStates(
+  sql: DbClient,
+  runIds: readonly string[],
+): Promise<Record<string, CollectiveXRunStateRow>> {
+  if (runIds.length === 0) return {};
+  const rows = await sql`
+    SELECT run_id::text, version, run_attempt, (deleted_at IS NOT NULL) AS deleted
+    FROM cx_runs
+    WHERE run_id = ANY(${runIds as string[]}::bigint[])
+  `;
+  return Object.fromEntries(
+    rows.map((row) => [
+      row.run_id as string,
+      {
+        state: row.deleted ? 'deleted' : 'live',
+        version: row.version as number,
+        run_attempt: row.run_attempt as number,
+      },
+    ]),
+  );
+}
+
+/**
+ * Atomically persist one run and its raw documents in a single statement
+ * (data-modifying CTEs), so concurrent lazy ingests can race safely:
+ * `ON CONFLICT DO NOTHING` turns the loser into a clean no-op, and a partial
+ * run can never become visible. Returns true when this call inserted the run.
+ *
+ * The `::jsonb`-cast parameters must be raw objects: both drivers
+ * JSON-serialize objects exactly once, while pre-stringified values get
+ * double-encoded by postgres.js. `docs` is wrapped in an object because the
+ * neon driver would serialize a bare JS array as a Postgres array literal.
+ */
+export async function insertCollectiveXRun(
+  sql: DbClient,
+  run: CollectiveXRunInsert,
+  docs: unknown[],
+): Promise<boolean> {
+  const rows = await sql`
+    WITH new_run AS (
+      INSERT INTO cx_runs
+        (run_id, run_attempt, version, generated_at, source_sha, source_branch, conclusion, matrix, summary)
+      VALUES
+        (${run.run_id}, ${run.run_attempt}, ${run.version}, ${run.generated_at},
+         ${run.source_sha}, ${run.source_branch}, ${run.conclusion},
+         ${run.matrix as never}::jsonb, ${run.summary as never}::jsonb)
+      ON CONFLICT (run_id) DO NOTHING
+      RETURNING run_id
+    ),
+    new_docs AS (
+      INSERT INTO cx_run_docs (run_id, run_attempt, doc)
+      SELECT new_run.run_id, ${run.run_attempt}, entries.value
+      FROM new_run, jsonb_array_elements((${{ docs } as never}::jsonb)->'docs') AS entries(value)
+      RETURNING id
+    )
+    SELECT (SELECT count(*)::int FROM new_run) AS runs_inserted
+  `;
+  return (rows[0]?.runs_inserted as number) > 0;
+}
+
+/**
+ * Replace a live run's contents when GitHub reports a NEWER attempt (a re-run
+ * of failed shards after the run was already ingested). Single statement with
+ * `FOR UPDATE` + an attempt guard: concurrent refreshers serialize on the row
+ * lock and the loser re-evaluates the guard to a no-op. Readers filter docs
+ * by the row's current run_attempt, so any superseded docs this statement's
+ * snapshot could not see (and therefore could not DELETE) stay invisible until
+ * the next refresh garbage-collects them. Tombstoned runs are never refreshed.
+ * Returns true when replaced.
+ */
+export async function refreshCollectiveXRunAttempt(
+  sql: DbClient,
+  run: CollectiveXRunInsert,
+  docs: unknown[],
+): Promise<boolean> {
+  const rows = await sql`
+    WITH target AS (
+      SELECT run_id FROM cx_runs
+      WHERE run_id = ${run.run_id} AND deleted_at IS NULL AND run_attempt < ${run.run_attempt}
+      FOR UPDATE
+    ),
+    removed AS (
+      DELETE FROM cx_run_docs WHERE run_id IN (SELECT run_id FROM target)
+    ),
+    updated AS (
+      UPDATE cx_runs SET
+        run_attempt = ${run.run_attempt},
+        generated_at = ${run.generated_at},
+        source_sha = ${run.source_sha},
+        source_branch = ${run.source_branch},
+        conclusion = ${run.conclusion},
+        matrix = ${run.matrix as never}::jsonb,
+        summary = ${run.summary as never}::jsonb,
+        ingested_at = now()
+      WHERE run_id IN (SELECT run_id FROM target)
+      RETURNING run_id
+    ),
+    new_docs AS (
+      INSERT INTO cx_run_docs (run_id, run_attempt, doc)
+      SELECT updated.run_id, ${run.run_attempt}, entries.value
+      FROM updated, jsonb_array_elements((${{ docs } as never}::jsonb)->'docs') AS entries(value)
+      RETURNING id
+    )
+    SELECT (SELECT count(*)::int FROM updated) AS runs_updated
+  `;
+  return (rows[0]?.runs_updated as number) > 0;
+}
+
+/**
+ * Tombstone a run: mark it deleted (so lazy discovery never re-ingests it)
+ * and drop its documents to free space — one atomic statement, so a partial
+ * failure can never tombstone the run while leaving its documents orphaned
+ * behind an unretryable 404. Returns false when the run is absent or already
+ * tombstoned. Re-ingesting via the CLI intentionally clears the tombstone
+ * (operator override; its hard DELETE also cascades any leftover docs).
+ */
+export async function deleteCollectiveXRun(sql: DbClient, runId: string): Promise<boolean> {
+  const rows = await sql`
+    WITH tombstoned AS (
+      UPDATE cx_runs SET deleted_at = now()
+      WHERE run_id = ${runId} AND deleted_at IS NULL
+      RETURNING run_id
+    ),
+    removed AS (
+      DELETE FROM cx_run_docs WHERE run_id IN (SELECT run_id FROM tombstoned)
+    )
+    SELECT (SELECT count(*)::int FROM tombstoned) AS runs_deleted
+  `;
+  return (rows[0]?.runs_deleted as number) > 0;
+}
+
+/** Assemble a stored run's raw documents into the dashboard dataset. */
+export function collectiveXDatasetFromRow(row: CollectiveXRunRow): CollectiveXDataset {
+  return buildDatasetFromNeutral(row.matrix, row.docs, {
+    run_id: row.run_id,
+    run_attempt: row.run_attempt,
+    generated_at: row.generated_at,
+    conclusion: row.conclusion,
+    source_sha: row.source_sha,
+  });
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 8e8fa430..b3db2927 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -51,6 +51,9 @@ importers:
       '@noble/ciphers':
         specifier: ^2.2.0
         version: 2.2.0
+      '@noble/hashes':
+        specifier: ^2.2.0
+        version: 2.2.0
       '@posthog/nextjs-config':
         specifier: ^1.9.68
         version: 1.9.68(next@16.2.10(@babel/core@8.0.1)(@opentelemetry/api@1.9.1)(react-dom@19.2.7(react@19.2.7))(react@19.2.7))(webpack@5.106.2(esbuild@0.28.1)(postcss@8.5.16))
@@ -165,6 +168,9 @@ importers:
       three:
         specifier: ^0.185.1
         version: 0.185.1
+      zod:
+        specifier: ^4.4.3
+        version: 4.4.3
     devDependencies:
       '@bahmutov/cypress-esbuild-preprocessor':
         specifier: ^2.2.8
@@ -216,7 +222,7 @@ importers:
         version: 6.2.5
       jsdom:
         specifier: ^29.1.1
-        version: 29.1.1
+        version: 29.1.1(@noble/hashes@2.2.0)
       tailwindcss:
         specifier: ^4.3.2
         version: 4.3.2
@@ -231,7 +237,7 @@ importers:
         version: 6.0.3
       vitest:
         specifier: ^4.1.10
-        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/coverage-v8@4.1.10)(jsdom@29.1.1)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/coverage-v8@4.1.10)(jsdom@29.1.1(@noble/hashes@2.2.0))(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
 
   packages/constants:
     devDependencies:
@@ -240,7 +246,7 @@ importers:
         version: 4.1.10(vitest@4.1.10)
       vitest:
         specifier: ^4.1.10
-        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/coverage-v8@4.1.10)(jsdom@29.1.1)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/coverage-v8@4.1.10)(jsdom@29.1.1(@noble/hashes@2.2.0))(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
 
   packages/db:
     dependencies:
@@ -289,7 +295,7 @@ importers:
         version: 6.0.3
       vitest:
         specifier: ^4.1.10
-        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/coverage-v8@4.1.10)(jsdom@29.1.1)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/coverage-v8@4.1.10)(jsdom@29.1.1(@noble/hashes@2.2.0))(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
 
   packages/mcp:
     dependencies:
@@ -323,7 +329,7 @@ importers:
         version: 6.0.3
       vitest:
         specifier: ^4.1.10
-        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/coverage-v8@4.1.10)(jsdom@29.1.1)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+        version: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/coverage-v8@4.1.10)(jsdom@29.1.1(@noble/hashes@2.2.0))(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
 
 packages:
 
@@ -985,6 +991,10 @@ packages:
     resolution: {integrity: sha512-Z6pjIZ/8IJcCGzb2S/0Px5J81yij85xASuk1teLNeg75bfT07MV3a/O2Mtn1I2se43k3lkVEcFaR10N4cgQcZA==}
     engines: {node: '>= 20.19.0'}
 
+  '@noble/hashes@2.2.0':
+    resolution: {integrity: sha512-IYqDGiTXab6FniAgnSdZwgWbomxpy9FtYvLKs7wCUs2a8RkITG+DFGO1DM9cr+E3/RgADRpFjrKVaJ1z6sjtEg==}
+    engines: {node: '>= 20.19.0'}
+
   '@nodelib/fs.scandir@2.1.5':
     resolution: {integrity: sha512-vq24Bq3ym5HEQm2NKCr3yXDwjc7vTsEThRDnkp2DK9p1uqLR+DHurm/NOTo0KG7HYHU7eppKZj3MyqYuMBf62g==}
     engines: {node: '>= 8'}
@@ -5824,7 +5834,9 @@ snapshots:
   '@esbuild/win32-x64@0.28.1':
     optional: true
 
-  '@exodus/bytes@1.15.1': {}
+  '@exodus/bytes@1.15.1(@noble/hashes@2.2.0)':
+    optionalDependencies:
+      '@noble/hashes': 2.2.0
 
   '@floating-ui/core@1.7.5':
     dependencies:
@@ -6065,6 +6077,8 @@ snapshots:
 
   '@noble/ciphers@2.2.0': {}
 
+  '@noble/hashes@2.2.0': {}
+
   '@nodelib/fs.scandir@2.1.5':
     dependencies:
       '@nodelib/fs.stat': 2.0.5
@@ -7131,7 +7145,7 @@ snapshots:
       obug: 2.1.3
       std-env: 4.2.0
       tinyrainbow: 3.1.0
-      vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/coverage-v8@4.1.10)(jsdom@29.1.1)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
+      vitest: 4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/coverage-v8@4.1.10)(jsdom@29.1.1(@noble/hashes@2.2.0))(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
 
   '@vitest/expect@4.1.10':
     dependencies:
@@ -7841,10 +7855,10 @@ snapshots:
     dependencies:
       assert-plus: 1.0.0
 
-  data-urls@7.0.0:
+  data-urls@7.0.0(@noble/hashes@2.2.0):
     dependencies:
       whatwg-mimetype: 5.0.0
-      whatwg-url: 16.0.1
+      whatwg-url: 16.0.1(@noble/hashes@2.2.0)
     transitivePeerDependencies:
       - '@noble/hashes'
 
@@ -8604,9 +8618,9 @@ snapshots:
 
   hono@4.12.25: {}
 
-  html-encoding-sniffer@6.0.0:
+  html-encoding-sniffer@6.0.0(@noble/hashes@2.2.0):
     dependencies:
-      '@exodus/bytes': 1.15.1
+      '@exodus/bytes': 1.15.1(@noble/hashes@2.2.0)
     transitivePeerDependencies:
       - '@noble/hashes'
 
@@ -8850,17 +8864,17 @@ snapshots:
 
   jsbn@0.1.1: {}
 
-  jsdom@29.1.1:
+  jsdom@29.1.1(@noble/hashes@2.2.0):
     dependencies:
       '@asamuzakjp/css-color': 5.1.11
       '@asamuzakjp/dom-selector': 7.1.1
       '@bramus/specificity': 2.4.2
       '@csstools/css-syntax-patches-for-csstree': 1.1.6(css-tree@3.2.1)
-      '@exodus/bytes': 1.15.1
+      '@exodus/bytes': 1.15.1(@noble/hashes@2.2.0)
       css-tree: 3.2.1
-      data-urls: 7.0.0
+      data-urls: 7.0.0(@noble/hashes@2.2.0)
       decimal.js: 10.6.0
-      html-encoding-sniffer: 6.0.0
+      html-encoding-sniffer: 6.0.0(@noble/hashes@2.2.0)
       is-potential-custom-element-name: 1.0.1
       lru-cache: 11.5.2
       parse5: 8.0.1
@@ -8871,7 +8885,7 @@ snapshots:
       w3c-xmlserializer: 5.0.0
       webidl-conversions: 8.0.1
       whatwg-mimetype: 5.0.0
-      whatwg-url: 16.0.1
+      whatwg-url: 16.0.1(@noble/hashes@2.2.0)
       xml-name-validator: 5.0.0
     transitivePeerDependencies:
       - '@noble/hashes'
@@ -10710,7 +10724,7 @@ snapshots:
       tsx: 4.23.0
       yaml: 2.9.0
 
-  vitest@4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/coverage-v8@4.1.10)(jsdom@29.1.1)(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)):
+  vitest@4.1.10(@opentelemetry/api@1.9.1)(@types/node@26.1.1)(@vitest/coverage-v8@4.1.10)(jsdom@29.1.1(@noble/hashes@2.2.0))(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0)):
     dependencies:
       '@vitest/expect': 4.1.10
       '@vitest/mocker': 4.1.10(vite@8.1.4(@types/node@26.1.1)(esbuild@0.28.1)(jiti@2.7.0)(terser@5.49.0)(tsx@4.23.0)(yaml@2.9.0))
@@ -10736,7 +10750,7 @@ snapshots:
       '@opentelemetry/api': 1.9.1
       '@types/node': 26.1.1
       '@vitest/coverage-v8': 4.1.10(vitest@4.1.10)
-      jsdom: 29.1.1
+      jsdom: 29.1.1(@noble/hashes@2.2.0)
     transitivePeerDependencies:
       - msw
 
@@ -10801,9 +10815,9 @@ snapshots:
 
   whatwg-mimetype@5.0.0: {}
 
-  whatwg-url@16.0.1:
+  whatwg-url@16.0.1(@noble/hashes@2.2.0):
     dependencies:
-      '@exodus/bytes': 1.15.1
+      '@exodus/bytes': 1.15.1(@noble/hashes@2.2.0)
       tr46: 6.0.0
       webidl-conversions: 8.0.1
     transitivePeerDependencies: